* // Declaring a cluster with an array of seeds
     * $redisCluster = new RedisCluster(null,['127.0.0.1:6379']);
     *
     * // Loading a cluster configuration by name
     * // In order to load a named array, one must first define the seed nodes in redis.ini.
     * // The following lines would define the cluster 'mycluster', and be loaded automatically by phpredis.
     *
     * // # In redis.ini
     * // redis.clusters.seeds = "mycluster[]=localhost:7000&test[]=localhost:7001"
     * // redis.clusters.timeout = "mycluster=5"
     * // redis.clusters.read_timeout = "mycluster=10"
     * // redis.clusters.auth = "mycluster=password" OR ['user' => 'foo', 'pass' => 'bar] as example
     *
     * //Then, this cluster can be loaded by doing the following
     *
     * $redisClusterPro = new RedisCluster('mycluster');
     * $redisClusterDev = new RedisCluster('test');
     * 

     * $redisCluster->get('key');
     * 

     * // Simple key -> value set
     * $redisCluster->set('key', 'value');
     *
     * // Will redirect, and actually make an SETEX call
     * $redisCluster->set('key','value', 10);
     *
     * // Will set the key, if it doesn't exist, with a ttl of 10 seconds
     * $redisCluster->set('key', 'value', Array('nx', 'ex'=>10));
     *
     * // Will set a key, if it does exist, with a ttl of 1000 milliseconds
     * $redisCluster->set('key', 'value', Array('xx', 'px'=>1000));
     * 

     * $redisCluster->del('x', 'y', 'z', 'h');    // remove x y z
     * $redisCluster->mset(array('x' => 'a', 'y' => 'b', 'z' => 'c'));
     * $redisCluster->hset('h', 'field', 'value');
     * var_dump($redisCluster->mget(array('x', 'y', 'z', 'h')));
     * // Output:
     * // array(3) {
     * // [0]=>
     * // string(1) "a"
     * // [1]=>
     * // string(1) "b"
     * // [2]=>
     * // string(1) "c"
     * // [3]=>
     * // bool(false)
     * // }
     * 

     * $redisCluster->mset(array('key0' => 'value0', 'key1' => 'value1'));
     * var_dump($redisCluster->get('key0'));
     * var_dump($redisCluster->get('key1'));
     * // Output:
     * // string(6) "value0"
     * // string(6) "value1"
     * 

     * $redisCluster->set('key1', 'val1');
     * $redisCluster->set('key2', 'val2');
     * $redisCluster->set('key3', 'val3');
     * $redisCluster->set('key4', 'val4');
     * $redisCluster->del('key1', 'key2');          // return 2
     * $redisCluster->del(array('key3', 'key4'));   // return 2
     * 

     * $redisCluster->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.
     * 

     * $redisCluster->psetex('key', 1000, 'value'); // sets key → value, with 1s TTL.
     * 

     * $redisCluster->setnx('key', 'value');   // return TRUE
     * $redisCluster->setnx('key', 'value');   // return FALSE
     * 

     * $redisCluster->set('x', '42');
     * $exValue = $redisCluster->getSet('x', 'lol');   // return '42', replaces x by 'lol'
     * $newValue = $redisCluster->get('x');            // return 'lol'
     * 

     * $redisCluster->set('key', 'value');
     * $redisCluster->exists('key');               //  TRUE
     * $redisCluster->exists('NonExistingKey');    // FALSE
     * 

     * $allKeys = $redisCluster->keys('*');   // all keys will match this.
     * $keyWithUserPrefix = $redisCluster->keys('user*');
     * 

     * $redisCluster->rPush('key1', 'A');
     * $redisCluster->rPush('key1', 'B');
     * $redisCluster->rPush('key1', 'C');
     * var_dump( $redisCluster->lRange('key1', 0, -1) );
     * // Output:
     * // array(3) {
     * //   [0]=> string(1) "A"
     * //   [1]=> string(1) "B"
     * //   [2]=> string(1) "C"
     * // }
     * $redisCluster->lPop('key1');
     * var_dump( $redisCluster->lRange('key1', 0, -1) );
     * // Output:
     * // array(2) {
     * //   [0]=> string(1) "B"
     * //   [1]=> string(1) "C"
     * // }
     * 

     * $redisCluster->rPush('key1', 'A');
     * $redisCluster->rPush('key1', 'B');
     * $redisCluster->rPush('key1', 'C');
     * var_dump( $redisCluster->lRange('key1', 0, -1) );
     * // Output:
     * // array(3) {
     * //   [0]=> string(1) "A"
     * //   [1]=> string(1) "B"
     * //   [2]=> string(1) "C"
     * // }
     * $redisCluster->rPop('key1');
     * var_dump( $redisCluster->lRange('key1', 0, -1) );
     * // Output:
     * // array(2) {
     * //   [0]=> string(1) "A"
     * //   [1]=> string(1) "B"
     * // }
     * 

     * $redisCluster->rPush('key1', 'A');
     * $redisCluster->rPush('key1', 'B');
     * $redisCluster->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
     * $redisCluster->lGet('key1', 0);     // 'A'
     * $redisCluster->lSet('key1', 0, 'X');
     * $redisCluster->lGet('key1', 0);     // 'X'
     * 

     * $redisCluster->sAdd('key1' , 'set1');
     * $redisCluster->sAdd('key1' , 'set2');
     * $redisCluster->sAdd('key1' , 'set3');
     * var_dump($redisCluster->sMembers('key1'));// 'key1' => {'set3', 'set1', 'set2'}
     * $redisCluster->sPop('key1');// 'set1'
     * var_dump($redisCluster->sMembers('key1'));// 'key1' => {'set3', 'set2'}
     * $redisCluster->sPop('key1');// 'set3',
     * var_dump($redisCluster->sMembers('key1'));// 'key1' => {'set2'}
     * 

     * $redisCluster->lPush('l', 'v1', 'v2', 'v3', 'v4')   // int(4)
     * var_dump( $redisCluster->lRange('l', 0, -1) );
     * //// Output:
     * // array(4) {
     * //   [0]=> string(2) "v4"
     * //   [1]=> string(2) "v3"
     * //   [2]=> string(2) "v2"
     * //   [3]=> string(2) "v1"
     * // }
     * 

     * $redisCluster->rPush('r', 'v1', 'v2', 'v3', 'v4');    // int(4)
     * var_dump( $redisCluster->lRange('r', 0, -1) );
     * //// Output:
     * // array(4) {
     * //   [0]=> string(2) "v1"
     * //   [1]=> string(2) "v2"
     * //   [2]=> string(2) "v3"
     * //   [3]=> string(2) "v4"
     * // }
     * 

     * // Non blocking feature
     * $redisCluster->lPush('key1', 'A');
     * $redisCluster->del('key2');
     *
     * $redisCluster->blPop('key1', 'key2', 10); // array('key1', 'A')
     * // OR
     * $redisCluster->blPop(array('key1', 'key2'), 10); // array('key1', 'A')
     *
     * $redisCluster->brPop('key1', 'key2', 10); // array('key1', 'A')
     * // OR
     * $redisCluster->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
     *
     * // Blocking feature
     *
     * // process 1
     * $redisCluster->del('key1');
     * $redisCluster->blPop('key1', 10);
     * // blocking for 10 seconds
     *
     * // process 2
     * $redisCluster->lPush('key1', 'A');
     *
     * // process 1
     * // array('key1', 'A') is returned
     * 

     * // Non blocking feature
     * $redisCluster->lPush('key1', 'A');
     * $redisCluster->del('key2');
     *
     * $redisCluster->blPop('key1', 'key2', 10); // array('key1', 'A')
     * // OR
     * $redisCluster->blPop(array('key1', 'key2'), 10); // array('key1', 'A')
     *
     * $redisCluster->brPop('key1', 'key2', 10); // array('key1', 'A')
     * // OR
     * $redisCluster->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
     *
     * // Blocking feature
     *
     * // process 1
     * $redisCluster->del('key1');
     * $redisCluster->blPop('key1', 10);
     * // blocking for 10 seconds
     *
     * // process 2
     * $redisCluster->lPush('key1', 'A');
     *
     * // process 1
     * // array('key1', 'A') is returned
     * 

     * $redisCluster->del('key1');
     * $redisCluster->rPushx('key1', 'A'); // returns 0
     * $redisCluster->rPush('key1', 'A'); // returns 1
     * $redisCluster->rPushx('key1', 'B'); // returns 2
     * $redisCluster->rPushx('key1', 'C'); // returns 3
     * // key1 now points to the following list: [ 'A', 'B', 'C' ]
     * 

     * $redisCluster->del('key1');
     * $redisCluster->lPushx('key1', 'A');     // returns 0
     * $redisCluster->lPush('key1', 'A');      // returns 1
     * $redisCluster->lPushx('key1', 'B');     // returns 2
     * $redisCluster->lPushx('key1', 'C');     // returns 3
     * // key1 now points to the following list: [ 'C', 'B', 'A' ]
     * 

     * $redisCluster->del('key1');
     * $redisCluster->lInsert('key1', RedisCluster::AFTER, 'A', 'X');    // 0
     *
     * $redisCluster->lPush('key1', 'A');
     * $redisCluster->lPush('key1', 'B');
     * $redisCluster->lPush('key1', 'C');
     *
     * $redisCluster->lInsert('key1', RedisCluster::BEFORE, 'C', 'X');   // 4
     * $redisCluster->lRange('key1', 0, -1);                      // array('X', 'C', 'B', 'A')
     *
     * $redisCluster->lInsert('key1', RedisCluster::AFTER, 'C', 'Y');    // 5
     * $redisCluster->lRange('key1', 0, -1);                      // array('X', 'C', 'Y', 'B', 'A')
     *
     * $redisCluster->lInsert('key1', RedisCluster::AFTER, 'W', 'value'); // -1
     * 

     * $redisCluster->rPush('key1', 'A');
     * $redisCluster->rPush('key1', 'B');
     * $redisCluster->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
     * $redisCluster->lGet('key1', 0);     // 'A'
     * $redisCluster->lGet('key1', -1);    // 'C'
     * $redisCluster->lGet('key1', 10);    // `FALSE`
     * 

     * $redisCluster->lPush('key1', 'A');
     * $redisCluster->lPush('key1', 'B');
     * $redisCluster->lPush('key1', 'C');
     * $redisCluster->lPush('key1', 'A');
     * $redisCluster->lPush('key1', 'A');
     *
     * $redisCluster->lRange('key1', 0, -1);   // array('A', 'A', 'C', 'B', 'A')
     * $redisCluster->lRem('key1', 'A', 2);    // 2
     * $redisCluster->lRange('key1', 0, -1);   // array('C', 'B', 'A')
     * 

     * $redisCluster->del('x', 'y');
     *
     * $redisCluster->lPush('x', 'abc');
     * $redisCluster->lPush('x', 'def');
     * $redisCluster->lPush('y', '123');
     * $redisCluster->lPush('y', '456');
     *
     * // move the last of x to the front of y.
     * var_dump($redisCluster->rpoplpush('x', 'y'));
     * var_dump($redisCluster->lRange('x', 0, -1));
     * var_dump($redisCluster->lRange('y', 0, -1));
     *
     * ////Output:
     * //
     * //string(3) "abc"
     * //array(1) {
     * //  [0]=>
     * //  string(3) "def"
     * //}
     * //array(3) {
     * //  [0]=>
     * //  string(3) "abc"
     * //  [1]=>
     * //  string(3) "456"
     * //  [2]=>
     * //  string(3) "123"
     * //}
     * 

     * $redisCluster->rPush('key1', 'A');
     * $redisCluster->rPush('key1', 'B');
     * $redisCluster->rPush('key1', 'C');  // key1 => [ 'A', 'B', 'C' ]
     * $redisCluster->lLen('key1');       // 3
     * $redisCluster->rPop('key1');
     * $redisCluster->lLen('key1');       // 2
     * 

     * $redisCluster->sAdd('key1' , 'set1');
     * $redisCluster->sAdd('key1' , 'set2');
     * $redisCluster->sAdd('key1' , 'set3');   // 'key1' => {'set1', 'set2', 'set3'}
     * $redisCluster->sCard('key1');           // 3
     * $redisCluster->sCard('keyX');           // 0
     * 

     * $redisCluster->del('s');
     * $redisCluster->sAdd('s', 'a');
     * $redisCluster->sAdd('s', 'b');
     * $redisCluster->sAdd('s', 'a');
     * $redisCluster->sAdd('s', 'c');
     * var_dump($redisCluster->sMembers('s'));
     *
     * ////Output:
     * //
     * //array(3) {
     * //  [0]=>
     * //  string(1) "b"
     * //  [1]=>
     * //  string(1) "c"
     * //  [2]=>
     * //  string(1) "a"
     * //}
     * // The order is random and corresponds to redis' own internal representation of the set structure.
     * 

     * $redisCluster->sAdd('key1' , 'set1');
     * $redisCluster->sAdd('key1' , 'set2');
     * $redisCluster->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
     *
     * $redisCluster->sIsMember('key1', 'set1'); // TRUE
     * $redisCluster->sIsMember('key1', 'setX'); // FALSE
     * 

     * $redisCluster->sAdd('k', 'v1');                // int(1)
     * $redisCluster->sAdd('k', 'v1', 'v2', 'v3');    // int(2)
     * 

     * $redisCluster->sAddArray('k', ['v1', 'v2', 'v3']);
     * //This is a feature in php only. Same as $redisCluster->sAdd('k', 'v1', 'v2', 'v3');
     * 

     * var_dump( $redisCluster->sAdd('k', 'v1', 'v2', 'v3') );    // int(3)
     * var_dump( $redisCluster->sRem('k', 'v2', 'v3') );          // int(2)
     * var_dump( $redisCluster->sMembers('k') );
     * //// Output:
     * // array(1) {
     * //   [0]=> string(2) "v1"
     * // }
     * 

     * $redisCluster->del('s0', 's1', 's2');
     *
     * $redisCluster->sAdd('s0', '1');
     * $redisCluster->sAdd('s0', '2');
     * $redisCluster->sAdd('s1', '3');
     * $redisCluster->sAdd('s1', '1');
     * $redisCluster->sAdd('s2', '3');
     * $redisCluster->sAdd('s2', '4');
     *
     * var_dump($redisCluster->sUnion('s0', 's1', 's2'));
     *
     * //// Output:
     * //
     * //array(4) {
     * //  [0]=>
     * //  string(1) "3"
     * //  [1]=>
     * //  string(1) "4"
     * //  [2]=>
     * //  string(1) "1"
     * //  [3]=>
     * //  string(1) "2"
     * //}
     * 

     * $redisCluster->del('s0', 's1', 's2');
     *
     * $redisCluster->sAdd('s0', '1');
     * $redisCluster->sAdd('s0', '2');
     * $redisCluster->sAdd('s1', '3');
     * $redisCluster->sAdd('s1', '1');
     * $redisCluster->sAdd('s2', '3');
     * $redisCluster->sAdd('s2', '4');
     *
     * var_dump($redisCluster->sUnionStore('dst', 's0', 's1', 's2'));
     * var_dump($redisCluster->sMembers('dst'));
     *
     * //// Output:
     * //
     * //int(4)
     * //array(4) {
     * //  [0]=>
     * //  string(1) "3"
     * //  [1]=>
     * //  string(1) "4"
     * //  [2]=>
     * //  string(1) "1"
     * //  [3]=>
     * //  string(1) "2"
     * //}
     * 

     * $redisCluster->sAdd('key1', 'val1');
     * $redisCluster->sAdd('key1', 'val2');
     * $redisCluster->sAdd('key1', 'val3');
     * $redisCluster->sAdd('key1', 'val4');
     *
     * $redisCluster->sAdd('key2', 'val3');
     * $redisCluster->sAdd('key2', 'val4');
     *
     * $redisCluster->sAdd('key3', 'val3');
     * $redisCluster->sAdd('key3', 'val4');
     *
     * var_dump($redisCluster->sInter('key1', 'key2', 'key3'));
     *
     * // Output:
     * //
     * //array(2) {
     * //  [0]=>
     * //  string(4) "val4"
     * //  [1]=>
     * //  string(4) "val3"
     * //}
     * 

     * $redisCluster->sAdd('key1', 'val1');
     * $redisCluster->sAdd('key1', 'val2');
     * $redisCluster->sAdd('key1', 'val3');
     * $redisCluster->sAdd('key1', 'val4');
     *
     * $redisCluster->sAdd('key2', 'val3');
     * $redisCluster->sAdd('key2', 'val4');
     *
     * $redisCluster->sAdd('key3', 'val3');
     * $redisCluster->sAdd('key3', 'val4');
     *
     * var_dump($redisCluster->sInterStore('output', 'key1', 'key2', 'key3'));
     * var_dump($redisCluster->sMembers('output'));
     *
     * //// Output:
     * //
     * //int(2)
     * //array(2) {
     * //  [0]=>
     * //  string(4) "val4"
     * //  [1]=>
     * //  string(4) "val3"
     * //}
     * 

     * $redisCluster->del('s0', 's1', 's2');
     *
     * $redisCluster->sAdd('s0', '1');
     * $redisCluster->sAdd('s0', '2');
     * $redisCluster->sAdd('s0', '3');
     * $redisCluster->sAdd('s0', '4');
     *
     * $redisCluster->sAdd('s1', '1');
     * $redisCluster->sAdd('s2', '3');
     *
     * var_dump($redisCluster->sDiff('s0', 's1', 's2'));
     *
     * //// Output:
     * //
     * //array(2) {
     * //  [0]=>
     * //  string(1) "4"
     * //  [1]=>
     * //  string(1) "2"
     * //}
     * 

     * $redisCluster->del('s0', 's1', 's2');
     *
     * $redisCluster->sAdd('s0', '1');
     * $redisCluster->sAdd('s0', '2');
     * $redisCluster->sAdd('s0', '3');
     * $redisCluster->sAdd('s0', '4');
     *
     * $redisCluster->sAdd('s1', '1');
     * $redisCluster->sAdd('s2', '3');
     *
     * var_dump($redisCluster->sDiffStore('dst', 's0', 's1', 's2'));
     * var_dump($redisCluster->sMembers('dst'));
     *
     * //// Output:
     * //
     * //int(2)
     * //array(2) {
     * //  [0]=>
     * //  string(1) "4"
     * //  [1]=>
     * //  string(1) "2"
     * //}
     * 

     * $redisCluster->sAdd('key1' , 'one');
     * $redisCluster->sAdd('key1' , 'two');
     * $redisCluster->sAdd('key1' , 'three');              // 'key1' => {'one', 'two', 'three'}
     *
     * var_dump( $redisCluster->sRandMember('key1') );     // 'key1' => {'one', 'two', 'three'}
     *
     * // string(5) "three"
     *
     * var_dump( $redisCluster->sRandMember('key1', 2) );  // 'key1' => {'one', 'two', 'three'}
     *
     * // array(2) {
     * //   [0]=> string(2) "one"
     * //   [1]=> string(2) "three"
     * // }
     * 

     * $redisCluster->set('key', 'value');
     * $redisCluster->strlen('key'); // 5
     * 

     * $redisCluster->zAdd('key', 0, 'val0');
     * $redisCluster->zAdd('key', 2, 'val2');
     * $redisCluster->zAdd('key', 10, 'val10');
     * $redisCluster->zCard('key');            // 3
     * 

     * $redisCluster->zAdd('key', 0, 'val0');
     * $redisCluster->zAdd('key', 2, 'val2');
     * $redisCluster->zAdd('key', 10, 'val10');
     * $redisCluster->zCount('key', 0, 3); // 2, corresponding to array('val0', 'val2')
     * 

     * $redisCluster->zAdd('key', 0, 'val0');
     * $redisCluster->zAdd('key', 2, 'val2');
     * $redisCluster->zAdd('key', 10, 'val10');
     * $redisCluster->zRemRangeByScore('key', '0', '3'); // 2
     * 

     * $redisCluster->zAdd('key', 2.5, 'val2');
     * $redisCluster->zScore('key', 'val2'); // 2.5
     * 

     * $redisCluster->zAdd('z', 1, 'v2', 2, 'v2', 3, 'v3', 4, 'v4' );  // int(3)
     * $redisCluster->zRem('z', 'v2', 'v3');                           // int(2)
     * var_dump( $redisCluster->zRange('z', 0, -1) );
     *
     * //// Output:
     * // array(1) {
     * //   [0]=> string(2) "v4"
     * // }
     * 

     * $redisCluster->del('key');
     * $redisCluster->zIncrBy('key', 2.5, 'member1');// key or member1 didn't exist, so member1's score is to 0 ;
     *                                              //before the increment and now has the value 2.5
     * $redisCluster->zIncrBy('key', 1, 'member1');    // 3.5
     * 

     * $redisCluster->del('h');
     * $redisCluster->hSet('h', 'key1', 'hello');
     * $redisCluster->hSet('h', 'key2', 'plop');
     * $redisCluster->hLen('h'); // returns 2
     * 

     * $redisCluster->del('h');
     * $redisCluster->hSet('h', 'a', 'x');
     * $redisCluster->hSet('h', 'b', 'y');
     * $redisCluster->hSet('h', 'c', 'z');
     * $redisCluster->hSet('h', 'd', 't');
     * var_dump($redisCluster->hKeys('h'));
     *
     * //// Output:
     * //
     * // array(4) {
     * // [0]=>
     * // string(1) "a"
     * // [1]=>
     * // string(1) "b"
     * // [2]=>
     * // string(1) "c"
     * // [3]=>
     * // string(1) "d"
     * // }
     * // The order is random and corresponds to redis' own internal representation of the set structure.
     * 

     * $redisCluster->del('h');
     * $redisCluster->hSet('h', 'a', 'x');
     * $redisCluster->hSet('h', 'b', 'y');
     * $redisCluster->hSet('h', 'c', 'z');
     * $redisCluster->hSet('h', 'd', 't');
     * var_dump($redisCluster->hVals('h'));
     *
     * //// Output:
     * //
     * // array(4) {
     * //   [0]=>
     * //   string(1) "x"
     * //   [1]=>
     * //   string(1) "y"
     * //   [2]=>
     * //   string(1) "z"
     * //   [3]=>
     * //   string(1) "t"
     * // }
     * // The order is random and corresponds to redis' own internal representation of the set structure.
     * 

     * $redisCluster->del('h');
     * $redisCluster->hSet('h', 'a', 'x');
     * $redisCluster->hGet('h', 'a'); // 'X'
     * 

     * $redisCluster->del('h');
     * $redisCluster->hSet('h', 'a', 'x');
     * $redisCluster->hSet('h', 'b', 'y');
     * $redisCluster->hSet('h', 'c', 'z');
     * $redisCluster->hSet('h', 'd', 't');
     * var_dump($redisCluster->hGetAll('h'));
     *
     * //// Output:
     * //
     * // array(4) {
     * //   ["a"]=>
     * //   string(1) "x"
     * //   ["b"]=>
     * //   string(1) "y"
     * //   ["c"]=>
     * //   string(1) "z"
     * //   ["d"]=>
     * //   string(1) "t"
     * // }
     * // The order is random and corresponds to redis' own internal representation of the set structure.
     * 

     * $redisCluster->hSet('h', 'a', 'x');
     * $redisCluster->hExists('h', 'a');               //  TRUE
     * $redisCluster->hExists('h', 'NonExistingKey');  // FALSE
     * 

     * $redisCluster->del('h');
     * $redisCluster->hIncrBy('h', 'x', 2); // returns 2: h[x] = 2 now.
     * $redisCluster->hIncrBy('h', 'x', 1); // h[x] ← 2 + 1. Returns 3
     * 

     * $redisCluster->del('h')
     * $redisCluster->hSet('h', 'key1', 'hello');  // 1, 'key1' => 'hello' in the hash at "h"
     * $redisCluster->hGet('h', 'key1');           // returns "hello"
     *
     * $redisCluster->hSet('h', 'key1', 'plop');   // 0, value was replaced.
     * $redisCluster->hGet('h', 'key1');           // returns "plop"
     * 

     * $redisCluster->del('h')
     * $redisCluster->hSetNx('h', 'key1', 'hello'); // TRUE, 'key1' => 'hello' in the hash at "h"
     * $redisCluster->hSetNx('h', 'key1', 'world'); // FALSE, 'key1' => 'hello' in the hash at "h". No change since the
     * field wasn't replaced.
     * 

     * $redisCluster->del('h');
     * $redisCluster->hSet('h', 'field1', 'value1');
     * $redisCluster->hSet('h', 'field2', 'value2');
     * $redisCluster->hMGet('h', array('field1', 'field2')); // returns array('field1' => 'value1', 'field2' =>
     * 'value2')
     * 

     * $redisCluster->del('user:1');
     * $redisCluster->hMSet('user:1', array('name' => 'Joe', 'salary' => 2000));
     * $redisCluster->hIncrBy('user:1', 'salary', 100); // Joe earns 100 more now.
     * 

     * $redisCluster->hMSet('h',
     *               array(
     *                    'f1' => 'v1',
     *                    'f2' => 'v2',
     *                    'f3' => 'v3',
     *                    'f4' => 'v4',
     *               ));
     *
     * var_dump( $redisCluster->hDel('h', 'f1') );        // int(1)
     * var_dump( $redisCluster->hDel('h', 'f2', 'f3') );  // int(2)
     *
     * var_dump( $redisCluster->hGetAll('h') );
     *
     * //// Output:
     * //
     * //  array(1) {
     * //    ["f4"]=> string(2) "v4"
     * //  }
     * 

     * $redisCluster->hset('h', 'float', 3);
     * $redisCluster->hset('h', 'int',   3);
     * var_dump( $redisCluster->hIncrByFloat('h', 'float', 1.5) ); // float(4.5)
     *
     * var_dump( $redisCluster->hGetAll('h') );
     *
     * //// Output:
     * //
     * // array(2) {
     * //   ["float"]=>
     * //   string(3) "4.5"
     * //   ["int"]=>
     * //   string(1) "3"
     * // }
     * 

     * $redisCluster->set('foo', 'bar');
     * $val = $redisCluster->dump('foo'); // $val will be the Redis encoded key value
     * 

     * $redisCluster->del('z');
     * $redisCluster->zAdd('key', 1, 'one');
     * $redisCluster->zAdd('key', 2, 'two');
     * $redisCluster->zRank('key', 'one');     // 0
     * $redisCluster->zRank('key', 'two');     // 1
     * $redisCluster->zRevRank('key', 'one');  // 1
     * $redisCluster->zRevRank('key', 'two');  // 0
     * 

     * $redisCluster->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
     * $redisCluster->incr('key1'); // 2
     * $redisCluster->incr('key1'); // 3
     * $redisCluster->incr('key1'); // 4
     * 

     * $redisCluster->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
     * $redisCluster->decr('key1'); // -2
     * $redisCluster->decr('key1'); // -3
     * 

     * $redisCluster->incr('key1');        // key1 didn't exists, set to 0 before the increment and now has the value 1
     * $redisCluster->incr('key1');        // 2
     * $redisCluster->incr('key1');        // 3
     * $redisCluster->incr('key1');        // 4
     * $redisCluster->incrBy('key1', 10);  // 14
     * 

     * $redisCluster->decr('key1');        // key1 didn't exists, set to 0 before the increment and now has the value -1
     * $redisCluster->decr('key1');        // -2
     * $redisCluster->decr('key1');        // -3
     * $redisCluster->decrBy('key1', 10);  // -13
     * 

     * $redisCluster->set('x', 3);
     * var_dump( $redisCluster->incrByFloat('x', 1.5) );   // float(4.5)
     *
     * var_dump( $redisCluster->get('x') );                // string(3) "4.5"
     * 

     * $redisCluster->set('x', '42');
     * $redisCluster->expire('x', 3);  // x will disappear in 3 seconds.
     * sleep(5);                    // wait 5 seconds
     * $redisCluster->get('x');            // will return `FALSE`, as 'x' has expired.
     * 

     * $redisCluster->set('x', '42');
     * $redisCluster->pExpire('x', 11500); // x will disappear in 11500 milliseconds.
     * $redisCluster->ttl('x');            // 12
     * $redisCluster->pttl('x');           // 11500
     * 

     * $redisCluster->set('x', '42');
     * $now = time();               // current timestamp
     * $redisCluster->expireAt('x', $now + 3); // x will disappear in 3 seconds.
     * sleep(5);                        // wait 5 seconds
     * $redisCluster->get('x');                // will return `FALSE`, as 'x' has expired.
     * 

     * $redisCluster->set('x', '42');
     * $redisCluster->pExpireAt('x', 1555555555005);
     * $redisCluster->ttl('x');                       // 218270121
     * $redisCluster->pttl('x');                      // 218270120575
     * 

     * $redisCluster->set('key', 'value1');
     * $redisCluster->append('key', 'value2'); // 12
     * $redisCluster->get('key');              // 'value1value2'
     * 

     * $redisCluster->set('key', "\x7f");  // this is 0111 1111
     * $redisCluster->getBit('key', 0);    // 0
     * $redisCluster->getBit('key', 1);    // 1
     * 

     * $redisCluster->set('key', "*");     // ord("*") = 42 = 0x2f = "0010 1010"
     * $redisCluster->setBit('key', 5, 1); // returns 0
     * $redisCluster->setBit('key', 7, 1); // returns 0
     * $redisCluster->get('key');          // chr(0x2f) = "/" = b("0010 1111")
     * 

     * $redisCluster->set('bit1', '1'); // 11 0001
     * $redisCluster->set('bit2', '2'); // 11 0010
     *
     * $redisCluster->bitOp('AND', 'bit', 'bit1', 'bit2'); // bit = 110000
     * $redisCluster->bitOp('OR',  'bit', 'bit1', 'bit2'); // bit = 110011
     * $redisCluster->bitOp('NOT', 'bit', 'bit1', 'bit2'); // bit = 110011
     * $redisCluster->bitOp('XOR', 'bit', 'bit1', 'bit2'); // bit = 11
     * 

     * $redisCluster->set('key', '\xff\xff');
     * $redisCluster->bitpos('key', 1); // int(0)
     * $redisCluster->bitpos('key', 1, 1); // int(8)
     * $redisCluster->bitpos('key', 1, 3); // int(-1)
     * $redisCluster->bitpos('key', 0); // int(16)
     * $redisCluster->bitpos('key', 0, 1); // int(16)
     * $redisCluster->bitpos('key', 0, 1, 5); // int(-1)
     * 

     * $redisCluster->set('bit', '345'); // // 11 0011  0011 0100  0011 0101
     * var_dump( $redisCluster->bitCount('bit', 0, 0) ); // int(4)
     * var_dump( $redisCluster->bitCount('bit', 1, 1) ); // int(3)
     * var_dump( $redisCluster->bitCount('bit', 2, 2) ); // int(4)
     * var_dump( $redisCluster->bitCount('bit', 0, 2) ); // int(11)
     * 

     * $redisCluster->set('key', 'string value');
     * $redisCluster->getRange('key', 0, 5);   // 'string'
     * $redisCluster->getRange('key', -5, -1); // 'value'
     * 

     * $redisCluster->rPush('key1', 'A');
     * $redisCluster->rPush('key1', 'B');
     * $redisCluster->rPush('key1', 'C');
     * $redisCluster->lRange('key1', 0, -1); // array('A', 'B', 'C')
     * $redisCluster->lTrim('key1', 0, 1);
     * $redisCluster->lRange('key1', 0, -1); // array('A', 'B')
     * 

     * $redisCluster->rPush('key1', 'A');
     * $redisCluster->rPush('key1', 'B');
     * $redisCluster->rPush('key1', 'C');
     * $redisCluster->lRange('key1', 0, -1); // array('A', 'B', 'C')
     * 

     * $redisCluster->zAdd('key', 1, 'one');
     * $redisCluster->zAdd('key', 2, 'two');
     * $redisCluster->zAdd('key', 3, 'three');
     * $redisCluster->zRemRangeByRank('key', 0, 1); // 2
     * $redisCluster->zRange('key', 0, -1, true); // array('three' => 3)
     * 

     * $redisCluster->set('x', '42');
     * $redisCluster->rename('x', 'y');
     * $redisCluster->get('y');   // → 42
     * $redisCluster->get('x');   // → `FALSE`
     * 

     * $redisCluster->set('x', '42');
     * $redisCluster->renameNx('x', 'y');
     * $redisCluster->get('y');   // → 42
     * $redisCluster->get('x');   // → `FALSE`
     * 

     * $redisCluster->pfAdd('key1', array('elem1', 'elem2'));
     * $redisCluster->pfAdd('key2', array('elem3', 'elem2'));
     * $redisCluster->pfCount('key1'); // int(2)
     * $redisCluster->pfCount(array('key1', 'key2')); // int(3)
     * 

     * $redisCluster->pfAdd('key1', array('elem1', 'elem2'));
     * $redisCluster->pfAdd('key2', array('elem3', 'elem2'));
     * $redisCluster->pfMerge('key3', array('key1', 'key2'));
     * $redisCluster->pfCount('key3'); // int(3)
     * 

     * $redisCluster->set('key', 'Hello world');
     * $redisCluster->setRange('key', 6, "redis"); // returns 11
     * $redisCluster->get('key');                  // "Hello redis"
     * 

     * $redisCluster->set('foo', 'bar');
     * $val = $redisCluster->dump('foo');
     * $redisCluster->restore('bar', 0, $val); // The key 'bar', will now be equal to the key 'foo'
     * 

     * $redisCluster->sAdd('key1' , 'set11');
     * $redisCluster->sAdd('key1' , 'set12');
     * $redisCluster->sAdd('key1' , 'set13');          // 'key1' => {'set11', 'set12', 'set13'}
     * $redisCluster->sAdd('key2' , 'set21');
     * $redisCluster->sAdd('key2' , 'set22');          // 'key2' => {'set21', 'set22'}
     * $redisCluster->sMove('key1', 'key2', 'set13');  // 'key1' =>  {'set11', 'set12'}
     *                                          // 'key2' =>  {'set21', 'set22', 'set13'}
     * 

     * $redisCluster->zAdd('key1', 0, 'val0');
     * $redisCluster->zAdd('key1', 2, 'val2');
     * $redisCluster->zAdd('key1', 10, 'val10');
     * $redisCluster->zRange('key1', 0, -1); // array('val0', 'val2', 'val10')
     * // with scores
     * $redisCluster->zRange('key1', 0, -1, true); // array('val0' => 0, 'val2' => 2, 'val10' => 10)
     * 

     * $redisCluster->zAdd('key', 0, 'val0');
     * $redisCluster->zAdd('key', 2, 'val2');
     * $redisCluster->zAdd('key', 10, 'val10');
     * $redisCluster->zRevRange('key', 0, -1); // array('val10', 'val2', 'val0')
     *
     * // with scores
     * $redisCluster->zRevRange('key', 0, -1, true); // array('val10' => 10, 'val2' => 2, 'val0' => 0)
     * 

     * $redisCluster->zAdd('key', 0, 'val0');
     * $redisCluster->zAdd('key', 2, 'val2');
     * $redisCluster->zAdd('key', 10, 'val10');
     * $redisCluster->zRangeByScore('key', 0, 3);
     * // array('val0', 'val2')
     * $redisCluster->zRangeByScore('key', 0, 3, array('withscores' => TRUE);
     * // array('val0' => 0, 'val2' => 2)
     * $redisCluster->zRangeByScore('key', 0, 3, array('limit' => array(1, 1));
     * // array('val2' => 2)
     * $redisCluster->zRangeByScore('key', 0, 3, array('limit' => array(1, 1));
     * // array('val2')
     * $redisCluster->zRangeByScore('key', 0, 3, array('withscores' => TRUE, 'limit' => array(1, 1));
     * // array('val2'=> 2)
     * 

     * foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $k => $char) {
     *     $redisCluster->zAdd('key', $k, $char);
     * }
     *
     * $redisCluster->zRangeByLex('key', '-', '[c'); // array('a', 'b', 'c')
     * $redisCluster->zRangeByLex('key', '-', '(c'); // array('a', 'b')
     * $redisCluster->zRevRangeByLex('key', '(c','-'); // array('b', 'a')
     * 

     * foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $k => $char) {
     *     $redisCluster->zAdd('key', $k, $char);
     * }
     * $redisCluster->zLexCount('key', '[b', '[f'); // 5
     * 

     * foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $k => $char) {
     *     $redisCluster->zAdd('key', $k, $char);
     * }
     * $redisCluster->zRemRangeByLex('key', '(b','[d'); // 2 , remove element 'c' and 'd'
     * $redisCluster->zRange('key',0,-1);// array('a','b','e','f','g')
     * 

     * $redisCluster->del('k1');
     * $redisCluster->del('k2');
     * $redisCluster->del('k3');
     * $redisCluster->del('ko1');
     * $redisCluster->del('ko2');
     * $redisCluster->del('ko3');
     *
     * $redisCluster->zAdd('k1', 0, 'val0');
     * $redisCluster->zAdd('k1', 1, 'val1');
     *
     * $redisCluster->zAdd('k2', 2, 'val2');
     * $redisCluster->zAdd('k2', 3, 'val3');
     *
     * $redisCluster->zUnionStore('ko1', array('k1', 'k2')); // 4, 'ko1' => array('val0', 'val1', 'val2', 'val3')
     *
     * // Weighted zUnionStore
     * $redisCluster->zUnionStore('ko2', array('k1', 'k2'), array(1, 1)); // 4, 'ko2' => array('val0', 'val1', 'val2','val3')
     * $redisCluster->zUnionStore('ko3', array('k1', 'k2'), array(5, 1)); // 4, 'ko3' => array('val0', 'val2', 'val3','val1')
     * 

     * $redisCluster->del('k1');
     * $redisCluster->del('k2');
     * $redisCluster->del('k3');
     *
     * $redisCluster->del('ko1');
     * $redisCluster->del('ko2');
     * $redisCluster->del('ko3');
     * $redisCluster->del('ko4');
     *
     * $redisCluster->zAdd('k1', 0, 'val0');
     * $redisCluster->zAdd('k1', 1, 'val1');
     * $redisCluster->zAdd('k1', 3, 'val3');
     *
     * $redisCluster->zAdd('k2', 2, 'val1');
     * $redisCluster->zAdd('k2', 3, 'val3');
     *
     * $redisCluster->zInterStore('ko1', array('k1', 'k2'));               // 2, 'ko1' => array('val1', 'val3')
     * $redisCluster->zInterStore('ko2', array('k1', 'k2'), array(1, 1));  // 2, 'ko2' => array('val1', 'val3')
     *
     * // Weighted zInterStore
     * $redisCluster->zInterStore('ko3', array('k1', 'k2'), array(1, 5), 'min'); // 2, 'ko3' => array('val1', 'val3')
     * $redisCluster->zInterStore('ko4', array('k1', 'k2'), array(1, 5), 'max'); // 2, 'ko4' => array('val3', 'val1')
     * 

     * $redisCluster->zAdd('z', 1, 'v1', 2, 'v2', 3, 'v3', 4, 'v4' );  // int(2)
     * $redisCluster->zRem('z', 'v2', 'v3');                           // int(2)
     * var_dump( $redisCluster->zRange('z', 0, -1) );
     * //// Output:
     * //
     * // array(2) {
     * //   [0]=> string(2) "v1"
     * //   [1]=> string(2) "v4"
     * // }
     * 

     * $redisCluster->del('s');
     * $redisCluster->sadd('s', 5);
     * $redisCluster->sadd('s', 4);
     * $redisCluster->sadd('s', 2);
     * $redisCluster->sadd('s', 1);
     * $redisCluster->sadd('s', 3);
     *
     * var_dump($redisCluster->sort('s')); // 1,2,3,4,5
     * var_dump($redisCluster->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
     * var_dump($redisCluster->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5
     * 

     * $redisCluster->object("encoding", "l"); // → ziplist
     * $redisCluster->object("refcount", "l"); // → 1
     * $redisCluster->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).
     * 

     * function f($redisCluster, $chan, $msg) {
     *  switch($chan) {
     *      case 'chan-1':
     *          ...
     *          break;
     *
     *      case 'chan-2':
     *                     ...
     *          break;
     *
     *      case 'chan-2':
     *          ...
     *          break;
     *      }
     * }
     *
     * $redisCluster->subscribe(array('chan-1', 'chan-2', 'chan-3'), 'f'); // subscribe to 3 chans
     * 

     * function psubscribe($redisCluster, $pattern, $chan, $msg) {
     *  echo "Pattern: $pattern\n";
     *  echo "Channel: $chan\n";
     *  echo "Payload: $msg\n";
     * }
     * 

     * $script = 'return 1';
     * $sha = $redisCluster->script('load', $script);
     * $redisCluster->evalSha($sha); // Returns 1
     * 

     * $iterator = null;
     * while($keys = $redisCluster->scan($iterator)) {
     *     foreach($keys as $key) {
     *         echo $key . PHP_EOL;
     *     }
     * }
     * 

     * $iterator = null;
     * while ($members = $redisCluster->sScan('set', $iterator)) {
     *     foreach ($members as $member) {
     *         echo $member . PHP_EOL;
     *     }
     * }
     * 

     * $iterator = null;
     * while ($members = $redis-zscan('zset', $iterator)) {
     *     foreach ($members as $member => $score) {
     *         echo $member . ' => ' . $score . PHP_EOL;
     *     }
     * }
     * 

     * $iterator = null;
     * while($elements = $redisCluster->hscan('hash', $iterator)) {
     *    foreach($elements as $key => $value) {
     *         echo $key . ' => ' . $value . PHP_EOL;
     *     }
     * }
     * 

     * $redisCluster->eval('this-is-not-lua');
     * $err = $redisCluster->getLastError();
     * // "ERR Error compiling script (new function): user_script:1: '=' expected near '-'"
     * 

     * $redisCluster->set('x', 'a');
     * $redisCluster->incr('x');
     * $err = $redisCluster->getLastError();
     * // "ERR value is not an integer or out of range"
     * $redisCluster->clearLastError();
     * $err = $redisCluster->getLastError();
     * // NULL
     * 

     * $redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_NONE);        // don't serialize data
     * $redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_PHP);         // use built-in serialize/unserialize
     * $redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_IGBINARY);    // use igBinary serialize/unserialize
     * $redisCluster->setOption(RedisCluster::OPT_PREFIX, 'myAppName:');                             // use custom prefix on all keys
     * 

     * $redisCluster->setOption(RedisCluster::OPT_PREFIX, 'my-prefix:');
     * $redisCluster->_prefix('my-value'); // Will return 'my-prefix:my-value'
     * 

     * $redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_NONE);
     * $redisCluster->_serialize("foo"); // returns "foo"
     * $redisCluster->_serialize(Array()); // Returns "Array"
     * $redisCluster->_serialize(new stdClass()); // Returns "Object"
     *
     * $redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_PHP);
     * $redisCluster->_serialize("foo"); // Returns 's:3:"foo";'
     * 

     * $redisCluster->setOption(RedisCluster::OPT_SERIALIZER, RedisCluster::SERIALIZER_PHP);
     * $redisCluster->_unserialize('a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}'); // Will return Array(1,2,3)
     * 

     * $redisCluster->_masters(); // Will return [[0=>'127.0.0.1','6379'],[0=>'127.0.0.1','6380']]
     * 

     * $ret = $redisCluster->multi()
     *      ->set('key1', 'val1')
     *      ->get('key1')
     *      ->set('key2', 'val2')
     *      ->get('key2')
     *      ->exec();
     *
     * //$ret == array (
     * //    0 => TRUE,
     * //    1 => 'val1',
     * //    2 => TRUE,
     * //    3 => 'val2');
     * 

     * $redisCluster->watch('x');
     * // long code here during the execution of which other clients could well modify `x`
     * $ret = $redisCluster->multi()
     *          ->incr('x')
     *          ->exec();
     * // $ret = FALSE if x has been modified between the call to WATCH and the call to EXEC.
     * 

     * $count = $redisCluster->dbSize('x');
     * echo "Redis has $count keys\n";
     * 

     * $redisCluster->info();
     *
     * or
     *
     * $redisCluster->info("COMMANDSTATS"); //Information on the commands that have been run (>=2.6 only)
     * $redisCluster->info("CPU"); // just CPU information from Redis INFO
     * 

     * $redisCluster->role(['127.0.0.1',6379]);
     * // [ 0=>'master',1 => 3129659, 2 => [ ['127.0.0.1','9001','3129242'], ['127.0.0.1','9002','3129543'] ] ]
     * 

     * $key = $redisCluster->randomKey('x');
     * $surprise = $redisCluster->get($key);  // who knows what's in there.
     * 

     * var_dump( $redisCluster->time('x') );
     * //// Output:
     * //
     * // array(2) {
     * //   [0] => string(10) "1342364352"
     * //   [1] => string(6) "253002"
     * // }
     * 

     * $redisCluster->cluster(['127.0.0.1',6379],'INFO');
     * 

     * $redisCluster->config(['127.0.0.1',6379], "GET", "*max-*-entries*");
     * $redisCluster->config(['127.0.0.1',6379], "SET", "dir", "/var/run/redis/dumps/");
     * 

     * $redisCluster->pubsub(['127.0.0.1',6379], 'channels'); // All channels
     * $redisCluster->pubsub(['127.0.0.1',6379], 'channels', '*pattern*'); // Just channels matching your pattern
     * $redisCluster->pubsub(['127.0.0.1',6379], 'numsub', array('chan1', 'chan2')); // Get subscriber counts for
     * 'chan1' and 'chan2'
     * $redisCluster->pubsub(['127.0.0.1',6379], 'numpat'); // Get the number of pattern subscribers
     * 

     * $redisCluster->script(['127.0.0.1',6379], 'load', $script);
     * $redisCluster->script(['127.0.0.1',6379], 'flush');
     * $redisCluster->script(['127.0.0.1',6379], 'kill');
     * $redisCluster->script(['127.0.0.1',6379], 'exists', $script1, [$script2, $script3, ...]);
     * 

     * $redisCluster->slowLog(['127.0.0.1',6379],'get','2');
     * 

     * $redisCluster->geoAdd('Sicily', 13.361389, 38.115556, 'Palermo'); // int(1)
     * $redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
     * 

     * $redisCluster->geoAdd('Sicily', 13.361389, 38.115556, 'Palermo'); // int(1)
     * $redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
     * $redisCluster->geohash('Sicily','Palermo','Catania');//['sqc8b49rny0','sqdtr74hyu0']
     * 

     * $redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
     * $redisCluster->geopos('Sicily','Palermo');//[['13.36138933897018433','38.11555639549629859']]
     * 

     * $redisCluster->geoAdd('Sicily', 13.361389, 38.115556, 'Palermo'); // int(1)
     * $redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
     * $redisCluster->geoDist('Sicily', 'Palermo' ,'Catania'); // float(166274.1516)
     * $redisCluster->geoDist('Sicily', 'Palermo','Catania', 'km'); // float(166.2742)
     * 

     * $redisCluster->del('Sicily');
     * $redisCluster->geoAdd('Sicily', 12.361389, 35.115556, 'Palermo'); // int(1)
     * $redisCluster->geoAdd('Sicily', 15.087269, 37.502669, "Catania"); // int(1)
     * $redisCluster->geoAdd('Sicily', 13.3585, 35.330022, "Agrigento"); // int(1)
     *
     * var_dump( $redisCluster->geoRadius('Sicily',13.3585, 35.330022, 300, 'km', ['WITHDIST' ,'DESC']) );
     *
     * array(3) {
     *    [0]=>
     *   array(2) {
     *        [0]=>
     *     string(7) "Catania"
     *        [1]=>
     *     string(8) "286.9362"
     *   }
     *   [1]=>
     *   array(2) {
     *        [0]=>
     *     string(7) "Palermo"
     *        [1]=>
     *     string(7) "93.6874"
     *   }
     *   [2]=>
     *   array(2) {
     *        [0]=>
     *     string(9) "Agrigento"
     *        [1]=>
     *     string(6) "0.0002"
     *   }
     * }
     * var_dump( $redisCluster->geoRadiusByMember('Sicily','Agrigento', 100, 'km', ['WITHDIST' ,'DESC']) );
     *
     * * array(2) {
     *    [0]=>
     *   array(2) {
     *        [0]=>
     *     string(7) "Palermo"
     *        [1]=>
     *     string(7) "93.6872"
     *   }
     *   [1]=>
     *   array(2) {
     *        [0]=>
     *     string(9) "Agrigento"
     *        [1]=>
     *     string(6) "0.0000"
     *   }
     * }
     *
     * 
     */
    public function geoRadius($key, $longitude, $latitude, $radius, $radiusUnit, array $options) {}

    /**
     * Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member
     *
     * @see geoRadius
     *
     * @param string $key
     * @param string $member
     * @param float  $radius
     * @param string $radiusUnit
     * @param array  $options
     */
    public function geoRadiusByMember($key, $member, $radius, $radiusUnit, array $options) {}
}

class RedisClusterException extends Exception {}

     * $redis->info();
     * 
     */
    public function info(): bool|array {}
}
 'localhost',
     *         'port'           => 6379,
     *         'readTimeout'    => 2.5,
     *         'connectTimeout' => 2.5,
     *         'persistent'     => true,
     *         // Valid formats: NULL, ['user', 'pass'], 'pass', or ['pass']
     *         'auth' => ['phpredis', 'phpredis'],
     *         // See PHP stream options for valid SSL configuration settings.
     *         'ssl' => ['verify_peer' => false],
     *         // How quickly to retry a connection after we time out or it  closes.
     *         // Note that this setting is overridden by 'backoff' strategies.
     *         'retryInterval'  => 100,
     *          // Which backoff algorithm to use.  'decorrelated jitter' is
     *          // likely the best one for most solution, but there are many
     *          // to choose from:
     *          //     REDIS_BACKOFF_ALGORITHM_DEFAULT
     *          //     REDIS_BACKOFF_ALGORITHM_CONSTANT
     *          //     REDIS_BACKOFF_ALGORITHM_UNIFORM
     *          //     REDIS_BACKOFF_ALGORITHM_EXPONENTIAL
     *          //     REDIS_BACKOFF_ALGORITHM_FULL_JITTER
     *          //     REDIS_BACKOFF_ALGORITHM_EQUAL_JITTER
     *          //     REDIS_BACKOFF_ALGORITHM_DECORRELATED_JITTER
     *          // 'base', and 'cap' are in milliseconds and represent the first
     *          // delay redis will use when reconnecting, and the maximum delay
     *          // we will reach while retrying.
     *         'backoff' => [
     *             'algorithm' => Redis::BACKOFF_ALGORITHM_DECORRELATED_JITTER,
     *             'base'      => 500,
     *             'cap'       => 750,
     *         ]
     *     ];
     * Note: If you do wish to connect via the constructor, only 'host' is
     *       strictly required, which will cause PhpRedis to connect to that
     *       host on Redis' default port (6379).
     * @param array|null $options
     * @see https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
     * @see Redis::connect()
     */
    public function __construct(?array $options = null) {}

    public function __destruct() {}

    /**
     * Compress a value with the currently configured compressor as set with
     * Redis::setOption().
     * @param string $value The value to be compressed
     * @return string        The compressed result
     * @see Redis::setOption()
     */
    public function _compress(string $value): string {}

    /**
     * Uncompress the provided argument that has been compressed with the
     * currently configured compressor as set with Redis::setOption().
     * @param string $value The compressed value to uncompress.
     * @return string         The uncompressed result.
     * @see Redis::setOption()
     */
    public function _uncompress(string $value): string {}

    /**
     * Prefix the passed argument with the currently set key prefix as set
     * with Redis::setOption().
     * @param string $key The key/string to prefix
     * @return string The prefixed string
     */
    public function _prefix(string $key): string {}

    /**
     * Serialize the provided value with the currently set serializer as set
     * with Redis::setOption().
     * @param mixed $value The value to serialize
     * @return string The serialized result
     * @see Redis::setOption()
     */
    public function _serialize(mixed $value): string {}

    /**
     * Unserialize the passed argument with the currently set serializer as set
     * with Redis::setOption().
     * @param string $value The value to unserialize
     * @return mixed The unserialized result
     * @see Redis::setOption()
     */
    public function _unserialize(string $value): mixed {}

    /**
     * Pack the provided value with the configured serializer and compressor
     * as set with Redis::setOption().
     * @param mixed $value The value to pack
     * @return string        The packed result having been serialized and
     *                       compressed.
     */
    public function _pack(mixed $value): string {}

    /**
     * Unpack the provided value with the configured compressor and serializer
     * as set with Redis::setOption().
     * @param string $value The value which has been serialized and compressed.
     * @return mixed          The uncompressed and eserialized value.
     */
    public function _unpack(string $value): mixed {}

    public function acl(string $subcmd, string ...$args): mixed {}

    /**
     * Append data to a Redis STRING key.
     * @param string $key The key in question
     * @param mixed $value The data to append to the key.
     * @return Redis|int|false The new string length of the key or false on failure.
     * @see https://redis.io/commands/append
     * @example
     * $redis->set('foo', 'hello);
     * $redis->append('foo', 'world');
     */
    public function append(string $key, mixed $value): Redis|int|false {}

    /**
     * Authenticate a Redis connection after its been established.
     *     $redis->auth('password');
     *     $redis->auth(['password']);
     *     $redis->auth(['username', 'password']);
     * @see https://redis.io/commands/auth
     * @param mixed $credentials A string password, or an array with one or two string elements.
     * @return Redis|bool Whether the AUTH was successful.
     */
    public function auth(#[\SensitiveParameter] mixed $credentials): Redis|bool {}

    /**
     * Execute a save of the Redis database in the background.
     * @see https://redis.io/commands/bgsave
     * @return Redis|bool Whether the command was successful.
     */
    public function bgSave(): Redis|bool {}

    /**
     * Asynchronously rewrite Redis' append-only file
     * @see https://redis.io/commands/bgrewriteaof
     * @return Redis|bool Whether the command was successful.
     */
    public function bgrewriteaof(): Redis|bool {}

    /**
     * Count the number of set bits in a Redis string.
     * @see https://redis.io/commands/bitcount/
     * @param string $key The key in question (must be a string key)
     * @param int $start The index where Redis should start counting.  If omitted it
     *                        defaults to zero, which means the start of the string.
     * @param int $end The index where Redis should stop counting.  If omitted it
     *                        defaults to -1, meaning the very end of the string.
     * @param bool $bybit Whether or not Redis should treat $start and $end as bit
     *                        positions, rather than bytes.
     * @return Redis|int|false The number of bits set in the requested range.
     */
    public function bitcount(string $key, int $start = 0, int $end = -1, bool $bybit = false): Redis|int|false {}

    public function bitop(string $operation, string $deskey, string $srckey, string ...$other_keys): Redis|int|false {}

    /**
     * Return the position of the first bit set to 0 or 1 in a string.
     * @see https://redis.io/commands/bitpos/
     * @param string $key The key to check (must be a string)
     * @param bool $bit Whether to look for an unset (0) or set (1) bit.
     * @param int $start Where in the string to start looking.
     * @param int $end Where in the string to stop looking.
     * @param bool $bybit If true, Redis will treat $start and $end as BIT values and not bytes, so if start
     *                      was 0 and end was 2, Redis would only search the first two bits.
     * @return Redis|int|false The position of the first set or unset bit.
     **/
    public function bitpos(string $key, bool $bit, int $start = 0, int $end = -1, bool $bybit = false): Redis|int|false {}

    /**
     * Pop an element off the beginning of a Redis list or lists, potentially blocking up to a specified
     * timeout.  This method may be called in two distinct ways, of which examples are provided below.
     * @see https://redis.io/commands/blpop/
     * @param string|array $key_or_keys This can either be a string key or an array of one or more
     *                                         keys.
     * @param string|float|int $timeout_or_key If the previous argument was a string key, this can either
     *                                         be an additional key, or the timeout you wish to send to
     *                                         the command.
     * @return Redis|array|null|false Can return various things depending on command and data in Redis.
     * @example
     * $redis->blPop('list1', 'list2', 'list3', 1.5);
     * $relay->blPop(['list1', 'list2', 'list3'], 1.5);
     */
    public function blPop(string|array $key_or_keys, string|float|int $timeout_or_key, mixed ...$extra_args): Redis|array|null|false {}

    /**
     * Pop an element off of the end of a Redis list or lists, potentially blocking up to a specified timeout.
     * The calling convention is identical to Redis::blPop() so see that documentation for more details.
     * @see https://redis.io/commands/brpop/
     * @see Redis::blPop()
     */
    public function brPop(string|array $key_or_keys, string|float|int $timeout_or_key, mixed ...$extra_args): Redis|array|null|false {}

    /**
     * Pop an element from the end of a Redis list, pushing it to the beginning of another Redis list,
     * optionally blocking up to a specified timeout.
     * @see https://redis.io/commands/brpoplpush/
     * @param string $src The source list
     * @param string $dst The destination list
     * @param int|float $timeout The number of seconds to wait.  Note that you must be connected
     *                           to Redis >= 6.0.0 to send a floating point timeout.
     */
    public function brpoplpush(string $src, string $dst, int|float $timeout): Redis|string|false {}

    /**
     * POP the maximum scoring element off of one or more sorted sets, blocking up to a specified
     * timeout if no elements are available.
     * Following are examples of the two main ways to call this method.
     * **NOTE**:  We reccomend calling this function with an array and a timeout as the other strategy
     *            may be deprecated in future versions of PhpRedis
     * @see https://redis.io/commands/bzpopmax
     * @param string|array $key Either a string key or an array of one or more keys.
     * @param string|int $timeout_or_key If the previous argument was an array, this argument
     *                                     must be a timeout value.  Otherwise it could also be
     *                                     another key.
     * @param mixed $extra_args Can consist of additional keys, until the last argument
     *                                     which needs to be a timeout.
     * @return Redis|array|false The popped elements.
     * @example
     * $redis->bzPopMax('key1', 'key2', 'key3', 1.5);
     * $redis->bzPopMax(['key1', 'key2', 'key3'], 1.5);
     */
    public function bzPopMax(string|array $key, string|int $timeout_or_key, mixed ...$extra_args): Redis|array|false {}

    /**
     * POP the minimum scoring element off of one or more sorted sets, blocking up to a specified timeout
     * if no elements are available
     * This command is identical in semantics to bzPopMax so please see that method for more information.
     * @see https://redis.io/commands/bzpopmin
     * @see Redis::bzPopMax()
     */
    public function bzPopMin(string|array $key, string|int $timeout_or_key, mixed ...$extra_args): Redis|array|false {}

    /**
     * POP one or more elements from one or more sorted sets, blocking up to a specified amount of time
     * when no elements are available.
     * @param float $timeout How long to block if there are no element available
     * @param array $keys The sorted sets to pop from
     * @param string $from The string 'MIN' or 'MAX' (case insensitive) telling Redis whether you wish to
     *                        pop the lowest or highest scoring members from the set(s).
     * @param int $count Pop up to how many elements.
     * @return Redis|array|null|false This function will return an array of popped elements, or false
     *                                depending on whether any elements could be popped within the
     *                                specified timeout.
     * NOTE:  If Redis::OPT_NULL_MULTIBULK_AS_NULL is set to true via Redis::setOption(), this method will
     *        instead return NULL when Redis doesn't pop any elements.
     */
    public function bzmpop(float $timeout, array $keys, string $from, int $count = 1): Redis|array|null|false {}

    /**
     * POP one or more of the highest or lowest scoring elements from one or more sorted sets.
     * @see https://redis.io/commands/zmpop
     * @param array $keys One or more sorted sets
     * @param string $from The string 'MIN' or 'MAX' (case insensitive) telling Redis whether you want to
     *                      pop the lowest or highest scoring elements.
     * @param int $count Pop up to how many elements at once.
     * @return Redis|array|null|false An array of popped elements or false if none could be popped.
     */
    public function zmpop(array $keys, string $from, int $count = 1): Redis|array|null|false {}

    /**
     * Pop one or more elements from one or more Redis LISTs, blocking up to a specified timeout when
     * no elements are available.
     * @see https://redis.io/commands/blmpop
     * @param float $timeout The number of seconds Redis will block when no elements are available.
     * @param array $keys One or more Redis LISTs to pop from.
     * @param string $from The string 'LEFT' or 'RIGHT' (case insensitive), telling Redis whether
     *                        to pop elements from the beginning or end of the LISTs.
     * @param int $count Pop up to how many elements at once.
     * @return Redis|array|null|false One or more elements popped from the list(s) or false if all LISTs
     *                                were empty.
     */
    public function blmpop(float $timeout, array $keys, string $from, int $count = 1): Redis|array|null|false {}

    /**
     * Pop one or more elements off of one or more Redis LISTs.
     * @see https://redis.io/commands/lmpop
     * @param array $keys An array with one or more Redis LIST key names.
     * @param string $from The string 'LEFT' or 'RIGHT' (case insensitive), telling Redis whether to pop\
     *                      elements from the beginning or end of the LISTs.
     * @param int $count The maximum number of elements to pop at once.
     * @return Redis|array|null|false One or more elements popped from the LIST(s) or false if all the LISTs
     *                                were empty.
     */
    public function lmpop(array $keys, string $from, int $count = 1): Redis|array|null|false {}

    /**
     * Reset any last error on the connection to NULL
     * @return bool This should always return true or throw an exception if we're not connected.
     * @see Redis::getLastError()
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->set('string', 'this_is_a_string');
     * $redis->smembers('string');
     * var_dump($redis->getLastError());
     * $redis->clearLastError();
     * var_dump($redis->getLastError());
     */
    public function clearLastError(): bool {}

    public function client(string $opt, mixed ...$args): mixed {}

    public function close(): bool {}

    public function command(?string $opt = null, mixed ...$args): mixed {}

    /**
     *  Execute the Redis CONFIG command in a variety of ways.
     *  What the command does in particular depends on the `$operation` qualifier.
     *  Operations that PhpRedis supports are: RESETSTAT, REWRITE, GET, and SET.
     * @param string $operation The CONFIG operation to execute (e.g. GET, SET, REWRITE).
     * @param array|string|null $key_or_settings One or more keys or values.
     * @param string|null $value The value if this is a `CONFIG SET` operation.
     * @return mixed
     * @see https://redis.io/commands/config
     * @example
     * $redis->config('GET', 'timeout');
     * $redis->config('GET', ['timeout', 'databases']);
     * $redis->config('SET', 'timeout', 30);
     * $redis->config('SET', ['timeout' => 30, 'loglevel' => 'warning']);
     */
    public function config(string $operation, array|string|null $key_or_settings = null, ?string $value = null): mixed {}

    public function connect(
        string $host,
        int $port = 6379,
        float $timeout = 0,
        ?string $persistent_id = null,
        int $retry_interval = 0,
        float $read_timeout = 0,
        ?array $context = null
    ): bool {}

    /**
     * Make a copy of a key.
     * $redis = new Redis(['host' => 'localhost']);
     * @param string $src The key to copy
     * @param string $dst The name of the new key created from the source key.
     * @param array|null $options An array with modifiers on how COPY should operate.
     *                        
     *                        $options = [
     *                            'REPLACE' => true|false # Whether to replace an existing key.
     *                            'DB' => int             # Copy key to specific db.
     *                        ];
     *                        
     * @return Redis|bool True if the copy was completed and false if not.
     * @see https://redis.io/commands/copy
     * @example
     * $redis->pipeline()
     *       ->select(1)
     *       ->del('newkey')
     *       ->select(0)
     *       ->del('newkey')
     *       ->mset(['source1' => 'value1', 'exists' => 'old_value'])
     *       ->exec();
     * var_dump($redis->copy('source1', 'newkey'));
     * var_dump($redis->copy('source1', 'newkey', ['db' => 1]));
     * var_dump($redis->copy('source1', 'exists'));
     * var_dump($redis->copy('source1', 'exists', ['REPLACE' => true]));
     */
    public function copy(string $src, string $dst, ?array $options = null): Redis|bool {}

    /**
     * Return the number of keys in the currently selected Redis database.
     * @see https://redis.io/commands/dbsize
     * @return Redis|int|false The number of keys or false on failure.
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->flushdb();
     * $redis->set('foo', 'bar');
     * var_dump($redis->dbsize());
     * $redis->mset(['a' => 'a', 'b' => 'b', 'c' => 'c', 'd' => 'd']);
     * var_dump($redis->dbsize());
     */
    public function dbSize(): Redis|int|false {}

    public function debug(string $key): Redis|string {}

    /**
     * Decrement a Redis integer by 1 or a provided value.
     * @param string $key The key to decrement
     * @param int $by How much to decrement the key.  Note that if this value is
     *                    not sent or is set to `1`, PhpRedis will actually invoke
     *                    the 'DECR' command.  If it is any value other than `1`
     *                    PhpRedis will actually send the `DECRBY` command.
     * @return Redis|int|false The new value of the key or false on failure.
     * @see https://redis.io/commands/decr
     * @see https://redis.io/commands/decrby
     * @example $redis->decr('counter');
     * @example $redis->decr('counter', 2);
     */
    public function decr(string $key, int $by = 1): Redis|int|false {}

    /**
     * Decrement a redis integer by a value
     * @param string $key The integer key to decrement.
     * @param int $value How much to decrement the key.
     * @return Redis|int|false The new value of the key or false on failure.
     * @see https://redis.io/commands/decrby
     * @example $redis->decrby('counter', 1);
     * @example $redis->decrby('counter', 2);
     */
    public function decrBy(string $key, int $value): Redis|int|false {}

    /**
     * Delete one or more keys from Redis.
     * This method can be called in two distinct ways.  The first is to pass a single array
     * of keys to delete, and the second is to pass N arguments, all names of keys.  See
     * below for an example of both strategies.
     * @param array|string $key Either an array with one or more key names or a string with
     *                                  the name of a key.
     * @param string ...$other_keys One or more additional keys passed in a variadic fashion.
     * @return Redis|int|false The number of keys that were deleted
     * @see https://redis.io/commands/del
     * @example $redis->del('key:0', 'key:1');
     * @example $redis->del(['key:2', 'key:3', 'key:4']);
     */
    public function del(array|string $key, string ...$other_keys): Redis|int|false {}

    /**
     * @deprecated
     */
    public function delete(array|string $key, string ...$other_keys): Redis|int|false {}

    /**
     * Discard a transaction currently in progress.
     * @return Redis|bool  True if we could discard the transaction.
     * @example
     * $redis->getMode();
     * $redis->set('foo', 'bar');
     * $redis->discard();
     * $redis->getMode();
     */
    public function discard(): Redis|bool {}

    /**
     * Dump Redis' internal binary representation of a key.
     * $redis->zRange('new-zset', 0, -1, true);
     * 
     * @param string $key The key to dump.
     * @return Redis|string A binary string representing the key's value.
     * @see https://redis.io/commands/dump
     * @example
     * $redis->zadd('zset', 0, 'zero', 1, 'one', 2, 'two');
     * $binary = $redis->dump('zset');
     * $redis->restore('new-zset', 0, $binary);
     */
    public function dump(string $key): Redis|string {}

    /**
     * Have Redis repeat back an arbitrary string to the client.
     * @param string $str The string to echo
     * @return Redis|string|false The string sent to Redis or false on failure.
     * @see https://redis.io/commands/echo
     * @example $redis->echo('Hello, World');
     */
    public function echo(string $str): Redis|string|false {}

    /**
     * Execute a LUA script on the redis server.
     * @see https://redis.io/commands/eval/
     * @param string $script A string containing the LUA script
     * @param array $args An array of arguments to pass to this script
     * @param int $num_keys How many of the arguments are keys.  This is needed
     *                         as redis distinguishes between key name arguments
     *                         and other data.
     * @return mixed LUA scripts may return arbitrary data so this method can return
     *               strings, arrays, nested arrays, etc.
     */
    public function eval(string $script, array $args = [], int $num_keys = 0): mixed {}

    /**
     * This is simply the read-only variant of eval, meaning the underlying script
     * may not modify data in redis.
     * @see Redis::eval_ro()
     */
    public function eval_ro(string $script_sha, array $args = [], int $num_keys = 0): mixed {}

    /**
     * Execute a LUA script on the server but instead of sending the script, send
     * the SHA1 hash of the script.
     * @param string $sha1 The SHA1 hash of the lua code.  Note that the script
     *                           must already exist on the server, either having been
     *                           loaded with `SCRIPT LOAD` or having been executed directly
     *                           with `EVAL` first.
     * @param array $args Arguments to send to the script.
     * @param int $num_keys The number of arguments that are keys
     * @return mixed Returns whatever the specific script does.
     * @see https://redis.io/commands/evalsha/
     * @see Redis::eval();
     */
    public function evalsha(string $sha1, array $args = [], int $num_keys = 0): mixed {}

    /**
     * This is simply the read-only variant of evalsha, meaning the underlying script
     * may not modify data in redis.
     * @see Redis::evalsha()
     */
    public function evalsha_ro(string $sha1, array $args = [], int $num_keys = 0): mixed {}

    /**
     * Execute either a MULTI or PIPELINE block and return the array of replies.
     * @return Redis|array|false The array of pipeline'd or multi replies or false on failure.
     * @see https://redis.io/commands/exec
     * @see https://redis.io/commands/multi
     * @see Redis::pipeline()
     * @see Redis::multi()
     * @example
     * $res = $redis->multi()
     *              ->set('foo', 'bar')
     *              ->get('foo')
     *              ->del('list')
     *              ->rpush('list', 'one', 'two', 'three')
     *              ->exec();
     */
    public function exec(): Redis|array|false {}

    /**
     * Test if one or more keys exist.
     * @param mixed $key Either an array of keys or a string key
     * @param mixed $other_keys If the previous argument was a string, you may send any number of
     *                           additional keys to test.
     * @return Redis|int|bool    The number of keys that do exist and false on failure
     * @see https://redis.io/commands/exists
     * @example $redis->exists(['k1', 'k2', 'k3']);
     * @example $redis->exists('k4', 'k5', 'notakey');
     */
    public function exists(mixed $key, mixed ...$other_keys): Redis|int|bool {}

    /**
     * Sets an expiration in seconds on the key in question.  If connected to
     * redis-server >= 7.0.0 you may send an additional "mode" argument which
     * modifies how the command will execute.
     * @param string $key The key to set an expiration on.
     * @param int $timeout The number of seconds after which key will be automatically deleted.
     * @param string|null $mode A two character modifier that changes how the
     *                      command works.
     *                      
     *                      NX - Set expiry only if key has no expiry
     *                      XX - Set expiry only if key has an expiry
     *                      LT - Set expiry only when new expiry is < current expiry
     *                      GT - Set expiry only when new expiry is > current expiry
     *                      
     * @return Redis|bool True if an expiration was set and false otherwise.
     * @see https://redis.io/commands/expire
     */
    public function expire(string $key, int $timeout, ?string $mode = null): Redis|bool {}

    /*
     * Set a key's expiration to a specific Unix timestamp in seconds.
     *
     * If connected to Redis >= 7.0.0 you can pass an optional 'mode' argument.
     * @see Redis::expire() For a description of the mode argument.
     *
     * @param string $key The key to set an expiration on.
     *
     * @return Redis|bool True if an expiration was set, false if not.
     *
     */

    /**
     * Set a key to expire at an exact unix timestamp.
     * @param string $key The key to set an expiration on.
     * @param int $timestamp The unix timestamp to expire at.
     * @param string|null $mode An option 'mode' that modifies how the command acts (see {@link Redis::expire}).
     * @return Redis|bool True if an expiration was set, false if not.
     * @see https://redis.io/commands/expireat
     * @see https://redis.io/commands/expire
     * @see Redis::expire()
     */
    public function expireAt(string $key, int $timestamp, ?string $mode = null): Redis|bool {}

    public function failover(?array $to = null, bool $abort = false, int $timeout = 0): Redis|bool {}

    /**
     * Get the expiration of a given key as a unix timestamp
     * @param string $key The key to check.
     * @return Redis|int|false The timestamp when the key expires, or -1 if the key has no expiry
     *                         and -2 if the key doesn't exist.
     * @see https://redis.io/commands/expiretime
     * @example
     * $redis->setEx('mykey', 60, 'myval');
     * $redis->expiretime('mykey');
     */
    public function expiretime(string $key): Redis|int|false {}

    /**
     * Get the expriation timestamp of a given Redis key but in milliseconds.
     * @see https://redis.io/commands/pexpiretime
     * @see Redis::expiretime()
     * @param string $key The key to check
     * @return Redis|int|false The expiration timestamp of this key (in milliseconds) or -1 if the
     *                         key has no expiration, and -2 if it does not exist.
     */
    public function pexpiretime(string $key): Redis|int|false {}

    /**
     * Invoke a function.
     * @param string $fn The name of the function
     * @param array $keys Optional list of keys
     * @param array $args Optional list of args
     * @return mixed        Function may return arbitrary data so this method can return
     *                      strings, arrays, nested arrays, etc.
     * @see https://redis.io/commands/fcall
     */
    public function fcall(string $fn, array $keys = [], array $args = []): mixed {}

    /**
     * This is a read-only variant of the FCALL command that cannot execute commands that modify data.
     * @param string $fn The name of the function
     * @param array $keys Optional list of keys
     * @param array $args Optional list of args
     * @return mixed        Function may return arbitrary data so this method can return
     *                      strings, arrays, nested arrays, etc.
     * @see https://redis.io/commands/fcall_ro
     */
    public function fcall_ro(string $fn, array $keys = [], array $args = []): mixed {}

    /**
     * Deletes every key in all Redis databases
     * @param bool $sync Whether to perform the task in a blocking or non-blocking way.
     * @return Redis|bool
     * @see https://redis.io/commands/flushall
     */
    public function flushAll(?bool $sync = null): Redis|bool {}

    /**
     * Deletes all the keys of the currently selected database.
     * @param bool $sync Whether to perform the task in a blocking or non-blocking way.
     * @return Redis|bool
     * @see https://redis.io/commands/flushdb
     */
    public function flushDB(?bool $sync = null): Redis|bool {}

    /**
     * Functions is an API for managing code to be executed on the server.
     * @param string $operation The subcommand you intend to execute.  Valid options are as follows
     *                                  'LOAD'      - Create a new library with the given library name and code.
     *                                  'DELETE'    - Delete the given library.
     *                                  'LIST'      - Return general information on all the libraries
     *                                  'STATS'     - Return information about the current function running
     *                                  'KILL'      - Kill the current running function
     *                                  'FLUSH'     - Delete all the libraries
     *                                  'DUMP'      - Return a serialized payload representing the current libraries
     *                                  'RESTORE'   - Restore the libraries represented by the given payload
     * @param mixed ...$args Additional arguments
     * @return Redis|bool|string|array  Depends on subcommand.
     * @see https://redis.io/commands/function
     */
    public function function(string $operation, mixed ...$args): Redis|bool|string|array {}

    /**
     * Add one or more members to a geospacial sorted set
     * @param string $key The sorted set to add data to.
     * @param float $lng The longitude of the first member
     * @param float $lat The lattitude of the first member.
     * @param mixed ...$other_triples_and_options You can continue to pass longitude, lattitude, and member
     *               arguments to add as many members as you wish.  Optionally, the final argument may be
     *               a string with options for the command @return Redis|int|false The number of added elements is returned.  If the 'CH' option is specified,
     *                         the return value is the number of members *changed*.
     * @see Redis documentation for the options.
     * @example $redis->geoAdd('cities', -121.8374, 39.7284, 'Chico', -122.03218, 37.322, 'Cupertino');
     * @example $redis->geoadd('cities', -121.837478, 39.728494, 'Chico', ['XX', 'CH']);
     * @see https://redis.io/commands/geoadd
     */
    public function geoadd(string $key, float $lng, float $lat, string $member, mixed ...$other_triples_and_options): Redis|int|false {}

    /**
     * Get the distance between two members of a geospacially encoded sorted set.
     * @param string $key The Sorted set to query.
     * @param string $src The first member.
     * @param string $dst The second member.
     * @param string|null $unit Which unit to use when computing distance, defaulting to meters.
     *                     
     *                     M  - meters
     *                     KM - kilometers
     *                     FT - feet
     *                     MI - miles
     *                     
     * @return Redis|float|false The calculated distance in whichever units were specified or false
     *                           if one or both members did not exist.
     * @example $redis->geodist('cities', 'Chico', 'Cupertino', 'mi');
     * @see https://redis.io/commands/geodist
     */
    public function geodist(string $key, string $src, string $dst, ?string $unit = null): Redis|float|false {}

    /**
     * Retrieve one or more GeoHash encoded strings for members of the set.
     * @param string $key The key to query
     * @param string $member The first member to request
     * @param string ...$other_members One or more additional members to request.
     * @return Redis|array|false    An array of GeoHash encoded values.
     * @see https://redis.io/commands/geohash
     * @see https://en.wikipedia.org/wiki/Geohash
     * @example $redis->geohash('cities', 'Chico', 'Cupertino');
     */
    public function geohash(string $key, string $member, string ...$other_members): Redis|array|false {}

    /**
     * Return the longitude and lattitude for one or more members of a geospacially encoded sorted set.
     * @param string $key The set to query.
     * @param string $member The first member to query.
     * @param string ...$other_members One or more members to query.
     * @return Redis|array|false array of longitude and lattitude pairs.
     * @see https://redis.io/commands/geopos
     * @example $redis->geopos('cities', 'Seattle', 'New York');
     */
    public function geopos(string $key, string $member, string ...$other_members): Redis|array|false {}

    /**
     * Retrieve members of a geospacially sorted set that are within a certain radius of a location.
     * @param string $key The set to query
     * @param float $lng The longitude of the location to query.
     * @param float $lat The latitude of the location to query.
     * @param float $radius The radius of the area to include.
     * @param string $unit The unit of the provided radius (defaults to 'meters).
     *                        See {@link Redis::geodist} for possible units.
     * @param array $options An array of options that modifies how the command behaves.
     *                        
     *                        $options = [
     *                            'WITHCOORD',     # Return members and their coordinates.
     *                            'WITHDIST',      # Return members and their distances from the center.
     *                            'WITHHASH',      # Return members GeoHash string.
     *                            'ASC' | 'DESC',  # The sort order of returned members
     *                            # Limit to N returned members.  Optionally a two element array may be
     *                            # passed as the `LIMIT` argument, and the `ANY` argument.
     *                            'COUNT' => [], or [, ]
     *                            # Instead of returning members, store them in the specified key.
     *                            'STORE' => 
     *                            # Store the distances in the specified key
     *                            'STOREDIST' => 
     *                        ];
     *                        
     * @return mixed This command can return various things, depending on the options passed.
     * @see https://redis.io/commands/georadius
     * @example $redis->georadius('cities', 47.608013, -122.335167, 1000, 'km');
     */
    public function georadius(string $key, float $lng, float $lat, float $radius, string $unit, array $options = []): mixed {}

    /**
     * A readonly variant of `GEORADIUS` that may be executed on replicas.
     * @see Redis::georadius
     */
    public function georadius_ro(string $key, float $lng, float $lat, float $radius, string $unit, array $options = []): mixed {}

    /**
     * Similar to `GEORADIUS` except it uses a member as the center of the query.
     * @param string $key The key to query.
     * @param string $member The member to treat as the center of the query.
     * @param float $radius The radius from the member to include.
     * @param string $unit The unit of the provided radius
     *                        See {@link Redis::geodist} for possible units.
     * @param array $options An array with various options to modify the command's behavior.
     *                        See {@link Redis::georadius} for options.
     * @return mixed This command can return various things depending on options.
     * @example $redis->georadiusbymember('cities', 'Seattle', 200, 'mi');
     */
    public function georadiusbymember(string $key, string $member, float $radius, string $unit, array $options = []): mixed {}

    /**
     * This is the read-only variant of `GEORADIUSBYMEMBER` that can be run on replicas.
     */
    public function georadiusbymember_ro(string $key, string $member, float $radius, string $unit, array $options = []): mixed {}

    /**
     * Search a geospacial sorted set for members in various ways.
     * @param string $key The set to query.
     * @param array|string $position Either a two element array with longitude and lattitude, or
     *                                  a string representing a member of the set.
     * @param array|int|float $shape Either a number representine the radius of a circle to search, or
     *                                  a two element array representing the width and height of a box
     *                                  to search.
     * @param string $unit The unit of our shape.  See {@link Redis::geodist} for possible units.
     * @param array $options @see {@link Redis::georadius} for options.  Note that the `STORE`
     *                                  options are not allowed for this command.
     */
    public function geosearch(string $key, array|string $position, array|int|float $shape, string $unit, array $options = []): array {}

    /**
     * Search a geospacial sorted set for members within a given area or range, storing the results into
     * a new set.
     * @param string $dst The destination where results will be stored.
     * @param string $src The key to query.
     * @param array|string $position Either a two element array with longitude and lattitude, or
     *                                  a string representing a member of the set.
     * @param array|int|float $shape Either a number representine the radius of a circle to search, or
     *                                  a two element array representing the width and height of a box
     *                                  to search.
     * @param string $unit The unit of our shape.  See {@link Redis::geodist} for possible units.
     * @param array $options
     *                        
     *                        $options = [
     *                            'ASC' | 'DESC',  # The sort order of returned members
     *                            'WITHDIST'       # Also store distances.
     *                            # Limit to N returned members.  Optionally a two element array may be
     *                            # passed as the `LIMIT` argument, and the `ANY` argument.
     *                            'COUNT' => [], or [, ]
     *                        ];
     *                        
     */
    public function geosearchstore(string $dst, string $src, array|string $position, array|int|float $shape, string $unit, array $options = []): Redis|array|int|false {}

    /**
     * Retrieve a string keys value.
     * @param string $key The key to query
     * @return mixed   The keys value or false if it did not exist.
     * @see https://redis.io/commands/get
     * @example $redis->get('foo');
     */
    public function get(string $key): mixed {}

    /**
     * Get the authentication information on the connection, if any.
     * @return mixed The authentication information used to authenticate the connection.
     * @see Redis::auth()
     */
    public function getAuth(): mixed {}

    /**
     * Get the bit at a given index in a string key.
     * @param string $key The key to query.
     * @param int $idx The Nth bit that we want to query.
     * @example $redis->getbit('bitmap', 1337);
     * @see https://redis.io/commands/getbit
     */
    public function getBit(string $key, int $idx): Redis|int|false {}

    /**
     * Get the value of a key and optionally set it's expiration.
     * @param string $key The key to query
     * @param array $options Options to modify how the command works.
     *                       
     *                       $options = [
     *                           'EX'     =>       # Expire in N seconds
     *                           'PX'     =>  # Expire in N milliseconds
     *                           'EXAT'   =>     # Expire at a unix timestamp (in seconds)
     *                           'PXAT'   =>   # Expire at a unix timestamp (in milliseconds);
     *                           'PERSIST'                  # Remove any configured expiration on the key.
     *                       ];
     *                       
     * @return Redis|string|bool The key's value or false if it didn't exist.
     * @see https://redis.io/comands/getex
     * @example $redis->getEx('mykey', ['EX' => 60]);
     */
    public function getEx(string $key, array $options = []): Redis|string|bool {}

    /**
     * Get the database number PhpRedis thinks we're connected to.
     * This value is updated internally in PhpRedis each time {@link Redis::select} is called.
     * @return int The database we're connected to.
     * @see Redis::select()
     * @see https://redis.io/commands/select
     */
    public function getDBNum(): int {}

    /**
     * Get a key from Redis and delete it in an atomic operation.
     * @param string $key The key to get/delete.
     * @return Redis|string|bool The value of the key or false if it didn't exist.
     * @see https://redis.io/commands/getdel
     * @example $redis->getdel('token:123');
     */
    public function getDel(string $key): Redis|string|bool {}

    /**
     * Return the host or Unix socket we are connected to.
     * @return string The host or Unix socket.
     */
    public function getHost(): string {}

    /**
     * Get the last error returned to us from Redis, if any.
     * @return string|null The error string or NULL if there is none.
     */
    public function getLastError(): ?string {}

    /**
     * Returns whether the connection is in ATOMIC, MULTI, or PIPELINE mode
     * @return int The mode we're in.
     */
    public function getMode(): int {}

    /**
     * Retrieve the value of a configuration setting as set by Redis::setOption()
     * @return mixed The setting itself or false on failure
     * @see Redis::setOption() for a detailed list of options and their values.
     */
    public function getOption(int $option): mixed {}

    /**
     * Get the persistent connection ID, if there is one.
     * @return string|null The ID or NULL if we don't have one.
     */
    public function getPersistentID(): ?string {}

    /**
     * Get the port we are connected to.  This number will be zero if we are connected to a unix socket.
     * @return int The port.
     */
    public function getPort(): int {}

    /**
     * Retrieve a substring of a string by index.
     * @param string $key The string to query.
     * @param int $start The zero-based starting index.
     * @param int $end The zero-based ending index.
     * @return Redis|string|false The substring or false on failure.
     * @see https://redis.io/commands/getrange
     * @example
     * $redis->set('silly-word', 'Supercalifragilisticexpialidocious');
     * echo $redis->getRange('silly-word', 0, 4) . "\n";
     */
    public function getRange(string $key, int $start, int $end): Redis|string|false {}

    /**
     * Get the longest common subsequence between two string keys.
     * @param string $key1 The first key to check
     * @param string $key2 The second key to check
     * @param array|null $options An optional array of modifiers for the comand.
     *                        
     *                        $options = [
     *                            'MINMATCHLEN'  => int  # Exclude matching substrings that are less than this value
     *                            'WITHMATCHLEN' => bool # Whether each match should also include its length.
     *                            'LEN'                  # Return the length of the longest subsequence
     *                            'IDX'                  # Each returned match will include the indexes where the
     *                                                   # match occurs in each string.
     *                        ];
     *                        
     *                        NOTE:  'LEN' cannot be used with 'IDX'.
     * @return Redis|string|array|int|false Various reply types depending on options.
     * @see https://redis.io/commands/lcs
     * @example
     * $redis->set('seq1', 'gtaggcccgcacggtctttaatgtatccctgtttaccatgccatacctgagcgcatacgc');
     * $redis->set('seq2', 'aactcggcgcgagtaccaggccaaggtcgttccagagcaaagactcgtgccccgctgagc');
     * echo $redis->lcs('seq1', 'seq2') . "\n";
     */
    public function lcs(string $key1, string $key2, ?array $options = null): Redis|string|array|int|false {}

    /**
     * Get the currently set read timeout on the connection.
     * @return float The timeout.
     */
    public function getReadTimeout(): float {}

    /**
     * Sets a key and returns any previously set value, if the key already existed.
     * @param string $key The key to set.
     * @param mixed $value The value to set the key to.
     * @return Redis|string|false The old value of the key or false if it didn't exist.
     * @see https://redis.io/commands/getset
     * @example
     * $redis->getset('captain', 'Pike');
     * $redis->getset('captain', 'Kirk');
     */
    public function getset(string $key, mixed $value): Redis|string|false {}

    /**
     * Retrieve any set connection timeout
     * @return float|false The currently set timeout or false on failure (e.g. we aren't connected).
     */
    public function getTimeout(): float|false {}

    /**
     * Get the number of bytes sent and received on the socket.
     * @return array An array in the form [$sent_bytes, $received_bytes]
     */
    public function getTransferredBytes(): array {}

    /**
     * Reset the number of bytes sent and received on the socket.
     * @return void
     */
    public function clearTransferredBytes(): void {}

    /**
     * Remove one or more fields from a hash.
     * @param string $key The hash key in question.
     * @param string $field The first field to remove
     * @param string ...$other_fields One or more additional fields to remove.
     * @return Redis|int|false     The number of fields actually removed.
     * @see https://redis.io/commands/hdel
     * @example $redis->hDel('communication', 'Alice', 'Bob');
     */
    public function hDel(string $key, string $field, string ...$other_fields): Redis|int|false {}

    /**
     * Checks whether a field exists in a hash.
     * @param string $key The hash to query.
     * @param string $field The field to check
     * @return Redis|bool   True if it exists, false if not.
     * @see https://redis.io/commands/hexists
     * @example $redis->hExists('communication', 'Alice');
     */
    public function hExists(string $key, string $field): Redis|bool {}

    public function hGet(string $key, string $member): mixed {}

    /**
     * Read every field and value from a hash.
     * @param string $key The hash to query.
     * @return Redis|array|false All fields and values or false if the key didn't exist.
     * @see https://redis.io/commands/hgetall
     * @example $redis->hgetall('myhash');
     */
    public function hGetAll(string $key): Redis|array|false {}

    /**
     * Increment a hash field's value by an integer
     * @param string $key The hash to modify
     * @param string $field The field to increment
     * @param int $value How much to increment the value.
     * @return Redis|int|false The new value of the field.
     * @see https://redis.io/commands/hincrby
     * @example
     * $redis->hMSet('player:1', ['name' => 'Alice', 'score' => 0]);
     * $redis->hincrby('player:1', 'score', 10);
     */
    public function hIncrBy(string $key, string $field, int $value): Redis|int|false {}

    /**
     * Increment a hash field by a floating point value
     * @param string $key The hash with the field to increment.
     * @param string $field The field to increment.
     * @return Redis|float|false The field value after incremented.
     * @see https://redis.io/commands/hincrbyfloat
     * @example
     * $redis->hincrbyfloat('numbers', 'tau', 2 * 3.1415926);
     */
    public function hIncrByFloat(string $key, string $field, float $value): Redis|float|false {}

    /**
     * Retrieve all of the fields of a hash.
     * @param string $key The hash to query.
     * @return Redis|array|false The fields in the hash or false if the hash doesn't exist.
     * @see https://redis.io/commands/hkeys
     * @example $redis->hkeys('myhash');
     */
    public function hKeys(string $key): Redis|array|false {}

    /**
     * Get the number of fields in a hash.
     * @see https://redis.io/commands/hlen
     * @param string $key The hash to check.
     * @return Redis|int|false The number of fields or false if the key didn't exist.
     * @example $redis->hlen('myhash');
     */
    public function hLen(string $key): Redis|int|false {}

    /**
     * Get one or more fields from a hash.
     * @param string $key The hash to query.
     * @param array $fields One or more fields to query in the hash.
     * @return Redis|array|false The fields and values or false if the key didn't exist.
     * @see https://redis.io/commands/hmget
     * @example $redis->hMGet('player:1', ['name', 'score']);
     */
    public function hMget(string $key, array $fields): Redis|array|false {}

    /**
     * Add or update one or more hash fields and values
     * @param string $key The hash to create/update
     * @param array $fieldvals An associative array with fields and their values.
     * @return Redis|bool True if the operation was successful
     * @see https://redis.io/commands/hmset
     * @example $redis->hmset('updates', ['status' => 'starting', 'elapsed' => 0]);
     */
    public function hMset(string $key, array $fieldvals): Redis|bool {}

    /**
     * Get one or more random field from a hash.
     * @param string $key The hash to query.
     * @param array|null $options An array of options to modify how the command behaves.
     *                        
     *                        $options = [
     *                            'COUNT'      => int  # An optional number of fields to return.
     *                            'WITHVALUES' => bool # Also return the field values.
     *                        ];
     *                        
     * @return Redis|array|string One or more random fields (and possibly values).
     * @see https://redis.io/commands/hrandfield
     * @example $redis->hrandfield('settings');
     * @example $redis->hrandfield('settings', ['count' => 2, 'withvalues' => true]);
     */
    public function hRandField(string $key, ?array $options = null): Redis|string|array {}

    public function hSet(string $key, string $member, mixed $value): Redis|int|false {}

    /**
     * Set a hash field and value, but only if that field does not exist
     * @param string $key The hash to update.
     * @param string $field The value to set.
     * @return Redis|bool True if the field was set and false if not.
     * @see https://redis.io/commands/hsetnx
     * @example
     * $redis->hsetnx('player:1', 'lock', 'enabled');
     * $redis->hsetnx('player:1', 'lock', 'enabled');
     */
    public function hSetNx(string $key, string $field, string $value): Redis|bool {}

    /**
     * Get the string length of a hash field
     * @param string $key The hash to query.
     * @param string $field The field to query.
     * @return Redis|int|false The string length of the field or false.
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->del('hash');
     * $redis->hmset('hash', ['50bytes' => str_repeat('a', 50)]);
     * $redis->hstrlen('hash', '50bytes');
     * @see https://redis.io/commands/hstrlen
     */
    public function hStrLen(string $key, string $field): Redis|int|false {}

    /**
     * Get all of the values from a hash.
     * @param string $key The hash to query.
     * @return Redis|array|false The values from the hash.
     * @see https://redis.io/commands/hvals
     * @example $redis->hvals('player:1');
     */
    public function hVals(string $key): Redis|array|false {}

    /**
     * Iterate over the fields and values of a hash in an incremental fashion.
     * @see https://redis.io/commands/hscan
     * @see https://redis.io/commands/scan
     * @param string $key The hash to query.
     * @param int|null $iterator The scan iterator, which should be initialized to NULL before the first call.
     *                          This value will be updated after every call to hscan, until it reaches zero
     *                          meaning the scan is complete.
     * @param string|null $pattern An optional glob-style pattern to filter fields with.
     * @param int $count An optional hint to Redis about how many fields and values to return per HSCAN.
     * @return Redis|array|bool An array with a subset of fields and values.
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->del('big-hash');
     * for ($i = 0; $i < 1000; $i++) {
     *     $fields["field:$i"] = "value:$i";
     * }
     * $redis->hmset('big-hash', $fields);
     * $it = null;
     * do {
     *     // Scan the hash but limit it to fields that match '*:1?3'
     *     $fields = $redis->hscan('big-hash', $it, '*:1?3');
     *     foreach ($fields as $field => $value) {
     *         echo "[$field] => $value\n";
     *     }
     * } while ($it != 0);
     */
    public function hscan(string $key, ?int &$iterator, ?string $pattern = null, int $count = 0): Redis|array|bool {}

    /**
     * Increment a key's value, optionally by a specifc amount.
     * @see https://redis.io/commands/incr
     * @see https://redis.io/commands/incrby
     * @param string $key The key to increment
     * @param int $by An optional amount to increment by.
     * @return Redis|int|false  The new value of the key after incremented.
     * @example $redis->incr('mycounter');
     * @example $redis->incr('mycounter', 10);
     */
    public function incr(string $key, int $by = 1): Redis|int|false {}

    /**
     * Increment a key by a specific integer value
     * @see https://redis.io/commands/incrby
     * @param string $key The key to increment.
     * @param int $value The amount to increment.
     * @example
     * $redis->set('primes', 2);
     * $redis->incrby('primes', 1);
     * $redis->incrby('primes', 2);
     * $redis->incrby('primes', 2);
     * $redis->incrby('primes', 4);
     */
    public function incrBy(string $key, int $value): Redis|int|false {}

    /**
     * Increment a numeric key by a floating point value.
     * @param string $key The key to increment
     * @param float $value How much to increment (or decrement) the value.
     * @return Redis|float|false The new value of the key or false if the key didn't contain a string.
     * @example
     * $redis->incrbyfloat('tau', 3.1415926);
     * $redis->incrbyfloat('tau', 3.1415926);
     */
    public function incrByFloat(string $key, float $value): Redis|float|false {}

    /**
     * Retrieve information about the connected redis-server.  If no arguments are passed to
     * this function, redis will return every info field.  Alternatively you may pass a specific
     * section you want returned (e.g. 'server', or 'memory') to receive only information pertaining
     * to that section.
     * If connected to Redis server >= 7.0.0 you may pass multiple optional sections.
     * @see https://redis.io/commands/info/
     * @param string ...$sections Optional section(s) you wish Redis server to return.
     * @return Redis|array|false
     */
    public function info(string ...$sections): Redis|array|false {}

    /**
     * Check if we are currently connected to a Redis instance.
     * @return bool True if we are, false if not
     */
    public function isConnected(): bool {}

    /** @return Redis|array|false */
    public function keys(string $pattern) {}

    public function lInsert(string $key, string $pos, mixed $pivot, mixed $value) {}

    /**
     * Retrieve the lenght of a list.
     * @param string $key The list
     * @return Redis|int|false The number of elements in the list or false on failure.
     */
    public function lLen(string $key): Redis|int|false {}

    /**
     * Move an element from one list into another.
     * @param string $src The source list.
     * @param string $dst The destination list
     * @param string $wherefrom Where in the source list to retrieve the element.  This can be either
     *                          - `Redis::LEFT`, or `Redis::RIGHT`.
     * @param string $whereto Where in the destination list to put the element.  This can be either
     *                          - `Redis::LEFT`, or `Redis::RIGHT`.
     * @return Redis|string|false The element removed from the source list.
     * @example
     * $redis->rPush('numbers', 'one', 'two', 'three');
     * $redis->lMove('numbers', 'odds', Redis::LEFT, Redis::LEFT);
     */
    public function lMove(string $src, string $dst, string $wherefrom, string $whereto): Redis|string|false {}

    /**
     * Move an element from one list to another, blocking up to a timeout until an element is available.
     * @param string $src The source list
     * @param string $dst The destination list
     * @param string $wherefrom Where in the source list to extract the element.
     *                          - `Redis::LEFT`, or `Redis::RIGHT`.
     * @param string $whereto Where in the destination list to put the element.
     *                          - `Redis::LEFT`, or `Redis::RIGHT`.
     * @param float $timeout How long to block for an element.
     * @return Redis|string|false
     * @example
     * $redis->lPush('numbers', 'one');
     * $redis->blmove('numbers', 'odds', Redis::LEFT, Redis::LEFT 1.0);
     * // This call will block, if no additional elements are in 'numbers'
     * $redis->blmove('numbers', 'odds', Redis::LEFT, Redis::LEFT, 1.0);
     */
    public function blmove(string $src, string $dst, string $wherefrom, string $whereto, float $timeout): Redis|string|false {}

    /**
     * Pop one or more elements off a list.
     * @param string $key The list to pop from.
     * @param int $count Optional number of elements to remove.  By default one element is popped.
     * @return Redis|bool|string|array Will return the element(s) popped from the list or false/NULL
     *                                   if none was removed.
     * @see https://redis.io/commands/lpop
     * @example $redis->lpop('mylist');
     * @example $redis->lpop('mylist', 4);
     */
    public function lPop(string $key, int $count = 0): Redis|bool|string|array {}

    /**
     * Retrieve the index of an element in a list.
     * @param string $key The list to query.
     * @param mixed $value The value to search for.
     * @param array|null $options Options to configure how the command operates
     *                        
     *                        $options = [
     *                            # How many matches to return.  By default a single match is returned.
     *                            # If count is set to zero, it means unlimited.
     *                            'COUNT' => 
     *                            # Specify which match you want returned.  `RANK` 1 means "the first match"
     *                            # 2 means the second, and so on.  If passed as a negative number the
     *                            # RANK is computed right to left, so a `RANK` of -1 means "the last match".
     *                            'RANK'  => 
     *                            # This argument allows you to limit how many elements Redis will search before
     *                            # returning.  This is useful to prevent Redis searching very long lists while
     *                            # blocking the client.
     *                            'MAXLEN => 
     *                        ];
     *                        
     * @return Redis|null|bool|int|array Returns one or more of the matching indexes, or null/false if none were found.
     */
    public function lPos(string $key, mixed $value, ?array $options = null): Redis|null|bool|int|array {}

    /**
     * Prepend one or more elements to a list.
     * @param string $key The list to prepend.
     * @param mixed $elements One or more elements to prepend.
     * @return Redis|int|false The new length of the list after prepending.
     * @see https://redis.io/commands/lpush
     * @example $redis->lPush('mylist', 'cat', 'bear', 'aligator');
     */
    public function lPush(string $key, mixed ...$elements): Redis|int|false {}

    /**
     * Append one or more elements to a list.
     * @param string $key The list to append to.
     * @param mixed $elements one or more elements to append.
     * @return Redis|int|false The new length of the list
     * @see https://redis.io/commands/rpush
     * @example $redis->rPush('mylist', 'xray', 'yankee', 'zebra');
     */
    public function rPush(string $key, mixed ...$elements): Redis|int|false {}

    /**
     * Prepend an element to a list but only if the list exists
     * @param string $key The key to prepend to.
     * @param mixed $value The value to prepend.
     * @return Redis|int|false The new length of the list.
     */
    public function lPushx(string $key, mixed $value): Redis|int|false {}

    /**
     * Append an element to a list but only if the list exists
     * @param string $key The key to prepend to.
     * @param mixed $value The value to prepend.
     * @return Redis|int|false The new length of the list.
     */
    public function rPushx(string $key, mixed $value): Redis|int|false {}

    /**
     * Set a list element at an index to a specific value.
     * @param string $key The list to modify.
     * @param int $index The position of the element to change.
     * @param mixed $value The new value.
     * @return Redis|bool True if the list was modified.
     * @see https://redis.io/commands/lset
     */
    public function lSet(string $key, int $index, mixed $value): Redis|bool {}

    /**
     * Retrieve the last time Redis' database was persisted to disk.
     * @return int The unix timestamp of the last save time
     * @see https://redis.io/commands/lastsave
     */
    public function lastSave(): int {}

    /**
     * Get the element of a list by its index.
     * @param string $key The key to query
     * @param int $index The index to check.
     * @return mixed The index or NULL/false if the element was not found.
     */
    public function lindex(string $key, int $index): mixed {}

    /**
     * Retrieve elements from a list.
     * @param string $key The list to query.
     * @param int $start The beginning index to retrieve.  This number can be negative
     *                      meaning start from the end of the list.
     * @param int $end The end index to retrieve.  This can also be negative to start
     *                      from the end of the list.
     * @return Redis|array|false The range of elements between the indexes.
     * @example $redis->lrange('mylist', 0, -1);  // the whole list
     * @example $redis->lrange('mylist', -2, -1); // the last two elements in the list.
     */
    public function lrange(string $key, int $start, int $end): Redis|array|false {}

    /**
     * Remove one or more matching elements from a list.
     * @param string $key The list to truncate.
     * @param mixed $value The value to remove.
     * @param int $count How many elements matching the value to remove.
     * @return Redis|int|false The number of elements removed.
     * @see https://redis.io/commands/lrem
     */
    public function lrem(string $key, mixed $value, int $count = 0): Redis|int|false {}

    /**
     * Trim a list to a subrange of elements.
     * @param string $key The list to trim
     * @param int $start The starting index to keep
     * @param int $end The ending index to keep.
     * @return Redis|bool true if the list was trimmed.
     * @example $redis->ltrim('mylist', 0, 3);  // Keep the first four elements
     */
    public function ltrim(string $key, int $start, int $end): Redis|bool {}

    /**
     * Get one ore more string keys.
     * @param array $keys The keys to retrieve
     * @return Redis|array an array of keys with their values.
     * @example $redis->mget(['key1', 'key2']);
     */
    public function mget(array $keys): Redis|array {}

    public function migrate(
        string $host,
        int $port,
        string|array $key,
        int $dstdb,
        int $timeout,
        bool $copy = false,
        bool $replace = false,
        #[\SensitiveParameter] mixed $credentials = null
    ): Redis|bool {}

    /**
     * Move a key to a different database on the same redis instance.
     * @param string $key The key to move
     * @return Redis|bool True if the key was moved
     */
    public function move(string $key, int $index): Redis|bool {}

    /**
     * Set one ore more string keys.
     * @param array $key_values An array with keys and their values.
     * @return Redis|bool True if the keys could be set.
     * @see https://redis.io/commands/mset
     * @example $redis->mSet(['foo' => 'bar', 'baz' => 'bop']);
     */
    public function mset(array $key_values): Redis|bool {}

    /**
     * Set one ore more string keys but only if none of the key exist.
     * @param array $key_values An array of keys with their values.
     * @return Redis|bool True if the keys were set and false if not.
     * @see https://redis.io/commands/msetnx
     * @example $redis->msetnx(['foo' => 'bar', 'baz' => 'bop']);
     */
    public function msetnx(array $key_values): Redis|bool {}

    /**
     * Begin a transaction.
     * @param int $value The type of transaction to start.  This can either be `Redis::MULTI` or
     *                    `Redis::PIPELINE'.
     * @return Redis|bool True if the transaction could be started.
     * @see https://redis.io/commands/multi
     * @example
     * $redis->multi();
     * $redis->set('foo', 'bar');
     * $redis->get('foo');
     * $redis->exec();
     */
    public function multi(int $value = Redis::MULTI): bool|Redis {}

    public function object(string $subcommand, string $key): Redis|int|string|false {}

    /**
     * @deprecated
     */
    public function open(string $host, int $port = 6379, float $timeout = 0, ?string $persistent_id = null, int $retry_interval = 0, float $read_timeout = 0, ?array $context = null): bool {}

    public function pconnect(string $host, int $port = 6379, float $timeout = 0, ?string $persistent_id = null, int $retry_interval = 0, float $read_timeout = 0, ?array $context = null): bool {}

    /**
     * Remove the expiration from a key.
     * @param string $key The key to operate against.
     * @return Redis|bool True if a timeout was removed and false if it was not or the key didn't exist.
     */
    public function persist(string $key): Redis|bool {}

    /**
     *  Sets an expiration in milliseconds on a given key.  If connected to Redis >= 7.0.0
     *  you can pass an optional mode argument that modifies how the command will execute.
     * @param string $key The key to set an expiration on.
     * @param int $timeout The number of milliseconds after which key will be automatically deleted.
     * @param string|null $mode A two character modifier that changes how the
     *                       command works.
     * @return bool   True if an expiry was set on the key, and false otherwise.
     * @see Redis::expire() for a description of the mode argument.
     */
    public function pexpire(string $key, int $timeout, ?string $mode = null): bool {}

    /**
     * Set a key's expiration to a specific Unix Timestamp in milliseconds.  If connected to
     * Redis >= 7.0.0 you can pass an optional 'mode' argument.
     * @param string $key The key to set an expiration on.
     * @param int $timestamp The unix timestamp to expire at.
     * @param string|null $mode A two character modifier that changes how the
     *                       command works.
     * @return Redis|bool   True if an expiration was set on the key, false otherwise.
     * @see Redis::expire() For a description of the mode argument.
     */
    public function pexpireAt(string $key, int $timestamp, ?string $mode = null): Redis|bool {}

    /**
     * Add one or more elements to a Redis HyperLogLog key
     * @see https://redis.io/commands/pfadd
     * @param string $key The key in question.
     * @param array $elements One or more elements to add.
     * @return Redis|int Returns 1 if the set was altered, and zero if not.
     */
    public function pfadd(string $key, array $elements): Redis|int {}

    /**
     * Retrieve the cardinality of a Redis HyperLogLog key.
     * @see https://redis.io/commands/pfcount
     * @param array|string $key_or_keys Either one key or an array of keys
     * @return Redis|int|false The estimated cardinality of the set.
     */
    public function pfcount(array|string $key_or_keys): Redis|int|false {}

    /**
     * Merge one or more source HyperLogLog sets into a destination set.
     * @see https://redis.io/commands/pfmerge
     * @param string $dst The destination key.
     * @param array $srckeys One or more source keys.
     * @return Redis|bool Always returns true.
     */
    public function pfmerge(string $dst, array $srckeys): Redis|bool {}

    /**
     * PING the redis server with an optional string argument.
     * @see https://redis.io/commands/ping
     * @param string|null $message An optional string message that Redis will reply with, if passed.
     * @return Redis|string|false If passed no message, this command will simply return `true`.
     *                            If a message is passed, it will return the message.
     * @example $redis->ping();
     * @example $redis->ping('beep boop');
     */
    public function ping(?string $message = null): Redis|string|bool {}

    /**
     * Enter into pipeline mode.
     * Pipeline mode is the highest performance way to send many commands to Redis
     * as they are aggregated into one stream of commands and then all sent at once
     * when the user calls Redis::exec().
     * NOTE:  That this is shorthand for Redis::multi(Redis::PIPELINE)
     * @return Redis|bool The redis object is returned, to facilitate method chaining.
     * @example
     * $redis->pipeline()
     *       ->set('foo', 'bar')
     *       ->del('mylist')
     *       ->rpush('mylist', 'a', 'b', 'c')
     *       ->exec();
     */
    public function pipeline(): bool|Redis {}

    /**
     * @deprecated
     */
    public function popen(string $host, int $port = 6379, float $timeout = 0, ?string $persistent_id = null, int $retry_interval = 0, float $read_timeout = 0, ?array $context = null): bool {}

    /**
     * Set a key with an expiration time in milliseconds
     * @param string $key The key to set
     * @param int $expire The TTL to set, in milliseconds.
     * @param mixed $value The value to set the key to.
     * @return Redis|bool True if the key could be set.
     * @example $redis->psetex('mykey', 1000, 'myval');
     */
    public function psetex(string $key, int $expire, mixed $value): Redis|bool {}

    /**
     * Subscribe to one or more glob-style patterns
     * @param array $patterns One or more patterns to subscribe to.
     * @param callable $cb A callback with the following prototype:
     *                            
     *                            function ($redis, $channel, $message) { }
     *                            
     * @return bool True if we were subscribed.
     * @see https://redis.io/commands/psubscribe
     */
    public function psubscribe(array $patterns, callable $cb): bool {}

    /**
     * Get a keys time to live in milliseconds.
     * @param string $key The key to check.
     * @return Redis|int|false The key's TTL or one of two special values if it has none.
     *                         
     *                         -1 - The key has no TTL.
     *                         -2 - The key did not exist.
     *                         
     * @see https://redis.io/commands/pttl
     * @example $redis->pttl('ttl-key');
     */
    public function pttl(string $key): Redis|int|false {}

    /**
     * Publish a message to a pubsub channel
     * @see https://redis.io/commands/publish
     * @param string $channel The channel to publish to.
     * @param string $message The message itself.
     * @return Redis|int|false The number of subscribed clients to the given channel.
     */
    public function publish(string $channel, string $message): Redis|int|false {}

    public function pubsub(string $command, mixed $arg = null): mixed {}

    /**
     * Unsubscribe from one or more channels by pattern
     * @see https://redis.io/commands/punsubscribe
     * @see https://redis.io/commands/subscribe
     * @see Redis::subscribe()
     * @param array $patterns One or more glob-style patterns of channel names.
     * @return Redis|array|bool  The array of subscribed patterns or false on failure.
     */
    public function punsubscribe(array $patterns): Redis|array|bool {}

    /**
     * Pop one or more elements from the end of a list.
     * @param string $key A redis LIST key name.
     * @param int $count The maximum number of elements to pop at once.
     *                      NOTE:  The `count` argument requires Redis >= 6.2.0
     * @return Redis|array|string|bool One ore more popped elements or false if all were empty.
     * @see https://redis.io/commands/rpop
     * @example $redis->rPop('mylist');
     * @example $redis->rPop('mylist', 4);
     */
    public function rPop(string $key, int $count = 0): Redis|array|string|bool {}

    /**
     * Return a random key from the current database
     * @see https://redis.io/commands/randomkey
     * @return Redis|string|false A random key name or false if no keys exist
     */
    public function randomKey(): Redis|string|false {}

    /**
     * Execute any arbitrary Redis command by name.
     * @param string $command The command to execute
     * @param mixed $args One or more arguments to pass to the command.
     * @return mixed Can return any number of things depending on command executed.
     * @example $redis->rawCommand('del', 'mystring', 'mylist');
     * @example $redis->rawCommand('set', 'mystring', 'myvalue');
     * @example $redis->rawCommand('rpush', 'mylist', 'one', 'two', 'three');
     */
    public function rawcommand(string $command, mixed ...$args): mixed {}

    /**
     * Unconditionally rename a key from $old_name to $new_name
     * @see https://redis.io/commands/rename
     * @param string $old_name The original name of the key
     * @param string $new_name The new name for the key
     * @return Redis|bool True if the key was renamed or false if not.
     */
    public function rename(string $old_name, string $new_name): Redis|bool {}

    /**
     * Renames $key_src to $key_dst but only if newkey does not exist.
     * @see https://redis.io/commands/renamenx
     * @param string $key_src The source key name
     * @param string $key_dst The destination key name.
     * @return Redis|bool True if the key was renamed, false if not.
     * @example
     * $redis->set('src', 'src_key');
     * $redis->set('existing-dst', 'i_exist');
     * $redis->renamenx('src', 'dst');
     * $redis->renamenx('dst', 'existing-dst');
     */
    public function renameNx(string $key_src, string $key_dst): Redis|bool {}

    /**
     * Reset the state of the connection.
     * @return Redis|bool Should always return true unless there is an error.
     */
    public function reset(): Redis|bool {}

    /**
     * Restore a key by the binary payload generated by the DUMP command.
     * @param string $key The name of the key you wish to create.
     * @param int $ttl What Redis should set the key's TTL (in milliseconds) to once it is created.
     *                        Zero means no TTL at all.
     * @param string $value The serialized binary value of the string (generated by DUMP).
     * @param array|null $options An array of additional options that modifies how the command operates.
     *                        
     *                        $options = [
     *                            'ABSTTL'          # If this is present, the `$ttl` provided by the user should
     *                                              # be an absolute timestamp, in milliseconds()
     *                            'REPLACE'         # This flag instructs Redis to store the key even if a key with
     *                                              # that name already exists.
     *                            'IDLETIME' => int # Tells Redis to set the keys internal 'idletime' value to a
     *                                              # specific number (see the Redis command OBJECT for more info).
     *                            'FREQ'     => int # Tells Redis to set the keys internal 'FREQ' value to a specific
     *                                              # number (this relates to Redis' LFU eviction algorithm).
     *                        ];
     *                        
     * @return Redis|bool     True if the key was stored, false if not.
     * @see https://redis.io/commands/restore
     * @see https://redis.io/commands/dump
     * @see Redis::dump()
     * @example
     * $redis->sAdd('captains', 'Janeway', 'Picard', 'Sisko', 'Kirk', 'Archer');
     * $serialized = $redis->dump('captains');
     * $redis->restore('captains-backup', 0, $serialized);
     */
    public function restore(string $key, int $ttl, string $value, ?array $options = null): Redis|bool {}

    /**
     * Query whether the connected instance is a primary or replica
     * @return mixed Will return an array with the role of the connected instance unless there is
     *               an error.
     */
    public function role(): mixed {}

    /**
     * Atomically pop an element off the end of a Redis LIST and push it to the beginning of
     * another.
     * @param string $srckey The source key to pop from.
     * @param string $dstkey The destination key to push to.
     * @return Redis|string|false The popped element or false if the source key was empty.
     * @see https://redis.io/commands/rpoplpush
     * @example
     * $redis->pipeline()
     *       ->del('list1', 'list2')
     *       ->rpush('list1', 'list1-1', 'list1-2')
     *       ->rpush('list2', 'list2-1', 'list2-2')
     *       ->exec();
     * $redis->rpoplpush('list2', 'list1');
     */
    public function rpoplpush(string $srckey, string $dstkey): Redis|string|false {}

    /**
     * Add one or more values to a Redis SET key.
     * @param string $key The key name
     * @param mixed $value A value to add to the set.
     * @param mixed ...$other_values One or more additional values to add
     * @return Redis|int|false The number of values added to the set.
     * @see https://redis.io/commands/sadd
     * @example
     * $redis->del('myset');
     * $redis->sadd('myset', 'foo', 'bar', 'baz');
     * $redis->sadd('myset', 'foo', 'new');
     */
    public function sAdd(string $key, mixed $value, mixed ...$other_values): Redis|int|false {}

    /**
     * Add one ore more values to a Redis SET key.  This is an alternative to Redis::sadd() but
     * instead of being variadic, takes a single array of values.
     * @see https://redis.io/commands/sadd
     * @see Redis::sadd()
     * @param string $key The set to add values to.
     * @param array $values One or more members to add to the set.
     * @return int  The number of members added to the set.
     * @example
     * $redis->del('myset');
     * $redis->sAddArray('myset', ['foo', 'bar', 'baz']);
     * $redis->sAddArray('myset', ['foo', 'new']);
     */
    public function sAddArray(string $key, array $values): int {}

    /**
     * Given one or more Redis SETS, this command returns all of the members from the first
     * set that are not in any subsequent set.
     * @param string $key The first set
     * @param string ...$other_keys One or more additional sets
     * @return Redis|array|false Returns the elements from keys 2..N that don't exist in the
     *                           first sorted set, or false on failure.
     * @see https://redis.io/commands/sdiff
     * @example
     * $redis->pipeline()
     *       ->del('set1', 'set2', 'set3')
     *       ->sadd('set1', 'apple', 'banana', 'carrot', 'date')
     *       ->sadd('set2', 'carrot')
     *       ->sadd('set3', 'apple', 'carrot', 'eggplant')
     *       ->exec();
     * $redis->sdiff('set1', 'set2', 'set3');
     */
    public function sDiff(string $key, string ...$other_keys): Redis|array|false {}

    /**
     * This method performs the same operation as SDIFF except it stores the resulting diff
     * values in a specified destination key.
     * @see https://redis.io/commands/sdiffstore
     * @see Redis::sdiff()
     * @param string $dst The key where to store the result
     * @param string $key The first key to perform the DIFF on
     * @param string ...$other_keys One or more additional keys.
     * @return Redis|int|false The number of values stored in the destination set or false on failure.
     */
    public function sDiffStore(string $dst, string $key, string ...$other_keys): Redis|int|false {}

    /**
     * Given one or more Redis SET keys, this command will return all of the elements that are
     * in every one.
     * @see https://redis.io/commands/sinter
     * @param array|string $key The first SET key to intersect.
     * @param string ...$other_keys One or more Redis SET keys.
     * @example
     * $redis->pipeline()
     *       ->del('alice_likes', 'bob_likes', 'bill_likes')
     *       ->sadd('alice_likes', 'asparagus', 'broccoli', 'carrot', 'potato')
     *       ->sadd('bob_likes', 'asparagus', 'carrot', 'potato')
     *       ->sadd('bill_likes', 'broccoli', 'potato')
     *       ->exec();
     * var_dump($redis->sinter('alice_likes', 'bob_likes', 'bill_likes'));
     * 
     */
    public function sInter(array|string $key, string ...$other_keys): Redis|array|false {}

    /**
     * Compute the intersection of one or more sets and return the cardinality of the result.
     * @param array $keys One or more set key names.
     * @param int $limit A maximum cardinality to return.  This is useful to put an upper bound
     *                     on the amount of work Redis will do.
     * @return Redis|int|false The
     * @see https://redis.io/commands/sintercard
     * @example
     * $redis->sAdd('set1', 'apple', 'pear', 'banana', 'carrot');
     * $redis->sAdd('set2', 'apple',         'banana');
     * $redis->sAdd('set3',          'pear', 'banana');
     * $redis->sInterCard(['set1', 'set2', 'set3']);
     * ?>
     * 
     */
    public function sintercard(array $keys, int $limit = -1): Redis|int|false {}

    /**
     * Perform the intersection of one or more Redis SETs, storing the result in a destination
     * key, rather than returning them.
     * @param array|string $key Either a string key, or an array of keys (with at least two
     *                                  elements, consisting of the destination key name and one
     *                                  or more source keys names.
     * @param string ...$other_keys If the first argument was a string, subsequent arguments should
     *                                  be source key names.
     * @return Redis|int|false          The number of values stored in the destination key or false on failure.
     * @see https://redis.io/commands/sinterstore
     * @see Redis::sinter()
     * @example $redis->sInterStore(['dst', 'src1', 'src2', 'src3']);
     * @example $redis->sInterStore('dst', 'src1', 'src'2', 'src3');
     * ?>
     * 
     */
    public function sInterStore(array|string $key, string ...$other_keys): Redis|int|false {}

    /**
     * Retrieve every member from a set key.
     * @param string $key The set name.
     * @return Redis|array|false Every element in the set or false on failure.
     * @see https://redis.io/commands/smembers
     * @example
     * $redis->sAdd('tng-crew', ...['Picard', 'Riker', 'Data', 'Worf', 'La Forge', 'Troi', 'Crusher', 'Broccoli']);
     * $redis->sMembers('tng-crew');
     */
    public function sMembers(string $key): Redis|array|false {}

    /**
     * Check if one or more values are members of a set.
     * @see https://redis.io/commands/smismember
     * @see https://redis.io/commands/smember
     * @see Redis::smember()
     * @param string $key The set to query.
     * @param string $member The first value to test if exists in the set.
     * @param string ...$other_members Any number of additional values to check.
     * @return Redis|array|false An array of integers representing whether each passed value
     *                           was a member of the set.
     * @example
     * $redis->sAdd('ds9-crew', ...["Sisko", "Kira", "Dax", "Worf", "Bashir", "O'Brien"]);
     * $members = $redis->sMIsMember('ds9-crew', ...['Sisko', 'Picard', 'Data', 'Worf']);
     */
    public function sMisMember(string $key, string $member, string ...$other_members): Redis|array|false {}

    /**
     * Pop a member from one set and push it onto another.  This command will create the
     * destination set if it does not currently exist.
     * @see https://redis.io/commands/smove
     * @param string $src The source set.
     * @param string $dst The destination set.
     * @param mixed $value The member you wish to move.
     * @return Redis|bool   True if the member was moved, and false if it wasn't in the set.
     * @example
     * $redis->sAdd('numbers', 'zero', 'one', 'two', 'three', 'four');
     * $redis->sMove('numbers', 'evens', 'zero');
     * $redis->sMove('numbers', 'evens', 'two');
     * $redis->sMove('numbers', 'evens', 'four');
     */
    public function sMove(string $src, string $dst, mixed $value): Redis|bool {}

    /**
     * Remove one or more elements from a set.
     * @see https://redis.io/commands/spop
     * @param string $key The set in question.
     * @param int $count An optional number of members to pop.   This defaults to
     *                       removing one element.
     * @example
     * $redis->del('numbers', 'evens');
     * $redis->sAdd('numbers', 'zero', 'one', 'two', 'three', 'four');
     * $redis->sPop('numbers');
     */
    public function sPop(string $key, int $count = 0): Redis|string|array|false {}

    /**
     * Retrieve one or more random members of a set.
     * @param string $key The set to query.
     * @param int $count An optional count of members to return.
     *                      If this value is positive, Redis will return *up to* the requested
     *                      number but with unique elements that will never repeat.  This means
     *                      you may recieve fewer then `$count` replies.
     *                      If the number is negative, Redis will return the exact number requested
     *                      but the result may contain duplicate elements.
     * @return Redis|array|string|false One or more random members or false on failure.
     * @see https://redis.io/commands/srandmember
     * @example $redis->sRandMember('myset');
     * @example $redis->sRandMember('myset', 10);
     * @example $redis->sRandMember('myset', -10);
     */
    public function sRandMember(string $key, int $count = 0): Redis|string|array|false {}

    /**
     * Returns the union of one or more Redis SET keys.
     * @see https://redis.io/commands/sunion
     * @param string $key The first SET to do a union with
     * @param string ...$other_keys One or more subsequent keys
     * @return Redis|array|false  The union of the one or more input sets or false on failure.
     * @example $redis->sunion('set1', 'set2');
     */
    public function sUnion(string $key, string ...$other_keys): Redis|array|false {}

    /**
     * Perform a union of one or more Redis SET keys and store the result in a new set
     * @see https://redis.io/commands/sunionstore
     * @see Redis::sunion()
     * @param string $dst The destination key
     * @param string $key The first source key
     * @param string ...$other_keys One or more additional source keys
     * @return Redis|int|false   The number of elements stored in the destination SET or
     *                           false on failure.
     */
    public function sUnionStore(string $dst, string $key, string ...$other_keys): Redis|int|false {}

    /**
     * Persist the Redis database to disk.  This command will block the server until the save is
     * completed.  For a nonblocking alternative, see Redis::bgsave().
     * @see https://redis.io/commands/save
     * @see Redis::bgsave()
     * @return Redis|bool Returns true unless an error occurs.
     */
    public function save(): Redis|bool {}

    /**
     * Incrementally scan the Redis keyspace, with optional pattern and type matching.
     * A note about Redis::SCAN_NORETRY and Redis::SCAN_RETRY.
     * For convenience, PhpRedis can retry SCAN commands itself when Redis returns an empty array of
     * keys with a nonzero iterator.  This can happen when matching against a pattern that very few
     * keys match inside a key space with a great many keys.  The following example demonstrates how
     * to use Redis::scan() with the option disabled and enabled.
     * @param int|null $iterator The cursor returned by Redis for every subsequent call to SCAN.  On
     *                         the initial invocation of the call, it should be initialized by the
     *                         caller to NULL.  Each time SCAN is invoked, the iterator will be
     *                         updated to a new number, until finally Redis will set the value to
     *                         zero, indicating that the scan is complete.
     * @param string|null $pattern An optional glob-style pattern for matching key names.  If passed as
     *                         NULL, it is the equivalent of sending '*' (match every key).
     * @param int $count A hint to redis that tells it how many keys to return in a single
     *                         call to SCAN.  The larger the number, the longer Redis may block
     *                         clients while iterating the key space.
     * @param string|null $type An optional argument to specify which key types to scan (e.g.
     *                         'STRING', 'LIST', 'SET')
     * @return array|false     An array of keys, or false if no keys were returned for this
     *                         invocation of scan.  Note that it is possible for Redis to return
     *                         zero keys before having scanned the entire key space, so the caller
     *                         should instead continue to SCAN until the iterator reference is
     *                         returned to zero.
     * @see https://redis.io/commands/scan
     * @see Redis::setOption()
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
     * $it = null;
     * do {
     *     $keys = $redis->scan($it, '*zorg*');
     *     foreach ($keys as $key) {
     *         echo "KEY: $key\n";
     *     }
     * } while ($it != 0);
     * $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
     * $it = null;
     * // When Redis::SCAN_RETRY is enabled, we can use simpler logic, as we will never receive an
     * // empty array of keys when the iterator is nonzero.
     * while ($keys = $redis->scan($it, '*zorg*')) {
     *     foreach ($keys as $key) {
     *         echo "KEY: $key\n";
     *     }
     * }
     */
    public function scan(?int &$iterator, ?string $pattern = null, int $count = 0, ?string $type = null): array|false {}

    /**
     * Retrieve the number of members in a Redis set.
     * @param string $key The set to get the cardinality of.
     * @return Redis|int|false The cardinality of the set or false on failure.
     * @see https://redis.io/commands/scard
     * @example $redis->scard('set');
     * 
     */
    public function scard(string $key): Redis|int|false {}

    /**
     * An administrative command used to interact with LUA scripts stored on the server.
     * @see https://redis.io/commands/script
     * @param string $command The script suboperation to execute.
     * @param mixed $args One ore more additional argument
     * @return mixed This command returns various things depending on the specific operation executed.
     * @example $redis->script('load', 'return 1');
     * @example $redis->script('exists', sha1('return 1'));
     */
    public function script(string $command, mixed ...$args): mixed {}

    /**
     * Select a specific Redis database.
     * @param int $db The database to select.  Note that by default Redis has 16 databases (0-15).
     * @return Redis|bool true on success and false on failure
     * @see https://redis.io/commands/select
     * @example $redis->select(1);
     */
    public function select(int $db): Redis|bool {}

    /**
     * Create or set a Redis STRING key to a value.
     * @param string $key The key name to set.
     * @param mixed $value The value to set the key to.
     * @param array|int $options Either an array with options for how to perform the set or an
     *                           integer with an expiration.  If an expiration is set PhpRedis
     *                           will actually send the `SETEX` command.
     * OPTION                         DESCRIPTION
     * ------------                   --------------------------------------------------------------
     * ['EX' => 60]                   expire 60 seconds.
     * ['PX' => 6000]                 expire in 6000 milliseconds.
     * ['EXAT' => time() + 10]        expire in 10 seconds.
     * ['PXAT' => time()*1000 + 1000] expire in 1 second.
     * ['KEEPTTL' => true]            Redis will not update the key's current TTL.
     * ['XX']                         Only set the key if it already exists.
     * ['NX']                         Only set the key if it doesn't exist.
     * ['GET']                        Instead of returning `+OK` return the previous value of the
     *                                key or NULL if the key didn't exist.
     * @return Redis|string|bool True if the key was set or false on failure.
     * @see https://redis.io/commands/set
     * @see https://redis.io/commands/setex
     * @example $redis->set('key', 'value');
     * @example $redis->set('key', 'expires_in_60_seconds', 60);
     */
    public function set(string $key, mixed $value, mixed $options = null): Redis|string|bool {}

    /**
     * Set a specific bit in a Redis string to zero or one
     * @see https://redis.io/commands/setbit
     * @param string $key The Redis STRING key to modify
     * @param bool $value Whether to set the bit to zero or one.
     * @return Redis|int|false The original value of the bit or false on failure.
     * @example
     * $redis->set('foo', 'bar');
     * $redis->setbit('foo', 7, 1);
     */
    public function setBit(string $key, int $idx, bool $value): Redis|int|false {}

    /**
     * Update or append to a Redis string at a specific starting index
     * @see https://redis.io/commands/setrange
     * @param string $key The key to update
     * @param int $index Where to insert the provided value
     * @param string $value The value to copy into the string.
     * @return Redis|int|false The new length of the string or false on failure
     * @example
     * $redis->set('message', 'Hello World');
     * $redis->setRange('message', 6, 'Redis');
     */
    public function setRange(string $key, int $index, string $value): Redis|int|false {}

    /**
     * Set a configurable option on the Redis object.
     * Following are a list of options you can set:
     * | OPTION          | TYPE | DESCRIPTION |
     * | --------------- | ---- | ----------- |
     * | OPT_MAX_RETRIES | int  | The maximum number of times Redis will attempt to reconnect if it gets disconnected, before throwing an exception. |
     * | OPT_SCAN        | enum | Redis::OPT_SCAN_RETRY, or Redis::OPT_SCAN_NORETRY.  Whether PhpRedis should automatically SCAN again when zero keys but a nonzero iterator are returned. |
     * | OPT_SERIALIZER  | enum | Set the automatic data serializer.
`Redis::SERIALIZER_NONE`
`Redis::SERIALIZER_PHP`
`Redis::SERIALIZER_IGBINARY`
`Redis::SERIALIZER_MSGPACK`, `Redis::SERIALIZER_JSON`|
     * | OPT_PREFIX | string | A string PhpRedis will use to prefix every key we read or write. |
     * | OPT_READ_TIMEOUT | float | How long PhpRedis will block for a response from Redis before throwing a 'read error on connection' exception. |
     * | OPT_TCP_KEEPALIVE | bool |   Set or disable TCP_KEEPALIVE on the connection. |
     * | OPT_COMPRESSION | enum | Set the compression algorithm
`Redis::COMPRESSION_NONE`
`Redis::COMPRESSION_LZF`
`Redis::COMPRESSION_LZ4`
 `Redis::COMPRESSION_ZSTD` |
     * | OPT_REPLY_LITERAL | bool | If set to true, PhpRedis will return the literal string Redis returns for LINE replies (e.g. '+OK'), rather than `true`. |
     * | OPT_COMPRESSION_LEVEL | int | Set a specific compression level if Redis is compressing data. |
     * | OPT_NULL_MULTIBULK_AS_NULL | bool | Causes PhpRedis to return `NULL` rather than `false` for NULL MULTIBULK replies |
     * | OPT_BACKOFF_ALGORITHM | enum | The exponential backoff strategy to use. |
     * | OPT_BACKOFF_BASE | int | The minimum delay between retries when backing off. |
     * | OPT_BACKOFF_CAP  | int | The maximum delay between replies when backing off. |
     * @param int $option The option constant.
     * @param mixed $value The option value.
     * @return bool  true if the setting was updated, false if not.
     * @see Redis::__construct() for details about backoff strategies.
     * @see Redis::getOption()
     */
    public function setOption(int $option, mixed $value): bool {}

    /**
     * Set a Redis STRING key with a specific expiration in seconds.
     * @param string $key The name of the key to set.
     * @param int $expire The key's expiration in seconds.
     * @param mixed $value The value to set the key.
     * @return Redis|bool True on success or false on failure.
     * @example $redis->setex('60s-ttl', 60, 'some-value');
     */
    public function setex(string $key, int $expire, mixed $value) {}

    /**
     * Set a key to a value, but only if that key does not already exist.
     * @see https://redis.io/commands/setnx
     * @param string $key The key name to set.
     * @param mixed $value What to set the key to.
     * @return Redis|bool Returns true if the key was set and false otherwise.
     * @example $redis->setnx('existing-key', 'existing-value');
     * @example $redis->setnx('new-key', 'new-value');
     */
    public function setnx(string $key, mixed $value): Redis|bool {}

    /**
     * Check whether a given value is the member of a Redis SET.
     * @param string $key The redis set to check.
     * @param mixed $value The value to test.
     * @return Redis|bool True if the member exists and false if not.
     * @example $redis->sismember('myset', 'mem1', 'mem2');
     */
    public function sismember(string $key, mixed $value): Redis|bool {}

    /**
     * Turn a redis instance into a replica of another or promote a replica
     * to a primary.
     * This method and the corresponding command in Redis has been marked deprecated
     * and users should instead use Redis::replicaof() if connecting to redis-server
     * >= 5.0.0.
     * @deprecated
     * @see https://redis.io/commands/slaveof
     * @see https://redis.io/commands/replicaof
     * @see Redis::replicaof()
     */
    public function slaveof(?string $host = null, int $port = 6379): Redis|bool {}

    /**
     * Used to turn a Redis instance into a replica of another, or to remove
     * replica status promoting the instance to a primary.
     * @see https://redis.io/commands/replicaof
     * @see https://redis.io/commands/slaveof
     * @see Redis::slaveof()
     * @param string|null $host The host of the primary to start replicating.
     * @param int $port The port of the primary to start replicating.
     * @return Redis|bool Success if we were successfully able to start replicating a primary or
     *                    were able to promote teh replicat to a primary.
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * // Attempt to become a replica of a Redis instance at 127.0.0.1:9999
     * $redis->replicaof('127.0.0.1', 9999);
     * // When passed no arguments, PhpRedis will deliver the command `REPLICAOF NO ONE`
     * // attempting to promote the instance to a primary.
     * $redis->replicaof();
     */
    public function replicaof(?string $host = null, int $port = 6379): Redis|bool {}

    /**
     * Update one or more keys last modified metadata.
     * @see https://redis.io/commands/touch/
     * @param array|string $key_or_array
     * @param string ...$more_keys One or more keys to send to the command.
     * @return Redis|int|false     This command returns the number of keys that exist and
     *                             had their last modified time reset
     */
    public function touch(array|string $key_or_array, string ...$more_keys): Redis|int|false {}

    /**
     * Interact with Redis' slowlog functionality in various ways, depending
     * on the value of 'operation'.
     * @param string $operation The operation you wish to perform.  This can
     *                           be one of the following values:
     *                           'GET'   - Retrieve the Redis slowlog as an array.
     *                           'LEN'   - Retrieve the length of the slowlog.
     *                           'RESET' - Remove all slowlog entries.
     * @param int $length This optional argument can be passed when operation
     *                           is 'get' and will specify how many elements to retrieve.
     *                           If omitted Redis will send up to a default number of
     *                           entries, which is configurable.
     *                           Note:  With Redis >= 7.0.0 you can send -1 to mean "all".
     * @return mixed
     * @see https://redis.io/commands/slowlog/
     * @example $redis->slowlog('get', -1);   // Retrieve all slowlog entries.
     * @example $redis->slowlog('len');       // Retrieve slowlog length.
     * @example $redis->slowlog('reset');     // Reset the slowlog.
     */
    public function slowlog(string $operation, int $length = 0): mixed {}

    /**
     * Sort the contents of a Redis key in various ways.
     * @see https://redis.io/commands/sort/
     * @param string $key The key you wish to sort
     * @param array|null $options Various options controlling how you would like the
     *                        data sorted.  See blow for a detailed description
     *                        of this options array.
     * @return mixed This command can either return an array with the sorted data
     *               or the number of elements placed in a destination set when
     *               using the STORE option.
     * @example
     * $options = [
     *     'SORT'  => 'ASC'|| 'DESC' // Sort in descending or descending order.
     *     'ALPHA' => true || false  // Whether to sort alphanumerically.
     *     'LIMIT' => [0, 10]        // Return a subset of the data at offset, count
     *     'BY'    => 'weight_*'     // For each element in the key, read data from the
     *                                  external key weight_* and sort based on that value.
     *     'GET'   => 'weight_*'     // For each element in the source key, retrieve the
     *                                  data from key weight_* and return that in the result
     *                                  rather than the source keys' element.  This can
     *                                  be used in combination with 'BY'
     * ];
     */
    public function sort(string $key, ?array $options = null): mixed {}

    /**
     * This is simply a read-only variant of the sort command
     * @see Redis::sort()
     */
    public function sort_ro(string $key, ?array $options = null): mixed {}

    /**
     * @deprecated
     */
    public function sortAsc(string $key, ?string $pattern = null, mixed $get = null, int $offset = -1, int $count = -1, ?string $store = null): array {}

    /**
     * @deprecated
     */
    public function sortAscAlpha(string $key, ?string $pattern = null, mixed $get = null, int $offset = -1, int $count = -1, ?string $store = null): array {}

    /**
     * @deprecated
     */
    public function sortDesc(string $key, ?string $pattern = null, mixed $get = null, int $offset = -1, int $count = -1, ?string $store = null): array {}

    /**
     * @deprecated
     */
    public function sortDescAlpha(string $key, ?string $pattern = null, mixed $get = null, int $offset = -1, int $count = -1, ?string $store = null): array {}

    /**
     * Remove one or more values from a Redis SET key.
     * @see https://redis.io/commands/srem
     * @param string $key The Redis SET key in question.
     * @param mixed $value The first value to remove.
     * @param mixed ...$other_values One or more additional values to remove.
     * @return Redis|int|false    The number of values removed from the set or false on failure.
     * @example $redis->sRem('set1', 'mem1', 'mem2', 'not-in-set');
     */
    public function srem(string $key, mixed $value, mixed ...$other_values): Redis|int|false {}

    /**
     * Scan the members of a redis SET key.
     * @see https://redis.io/commands/sscan
     * @see https://redis.io/commands/scan
     * @see Redis::setOption()
     * @param string $key The Redis SET key in question.
     * @param int|null $iterator A reference to an iterator which should be initialized to NULL that
     *                          PhpRedis will update with the value returned from Redis after each
     *                          subsequent call to SSCAN.  Once this cursor is zero you know all
     *                          members have been traversed.
     * @param string|null $pattern An optional glob style pattern to match against, so Redis only
     *                          returns the subset of members matching this pattern.
     * @param int $count A hint to Redis as to how many members it should scan in one command
     *                          before returning members for that iteration.
     * @return array|false
     * @example
     * $redis->del('myset');
     * for ($i = 0; $i < 10000; $i++) {
     *     $redis->sAdd('myset', "member:$i");
     * }
     * $redis->sadd('myset', 'foofoo');
     * $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
     * $scanned = 0;
     * $it = null;
     * // Without Redis::SCAN_RETRY we may receive empty results and
     * // a nonzero iterator.
     * do {
     *     // Scan members containing '5'
     *     $members = $redis->sscan('myset', $it, '*5*');
     *     foreach ($members as $member) {
     *          echo "NORETRY: $member\n";
     *          $scanned++;
     *     }
     * } while ($it != 0);
     * echo "TOTAL: $scanned\n";
     * $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
     * $scanned = 0;
     * $it = null;
     * // With Redis::SCAN_RETRY PhpRedis will never return an empty array
     * // when the cursor is non-zero
     * while (($members = $redis->sscan('myset', $it, '*5*'))) {
     *     foreach ($members as $member) {
     *         echo "RETRY: $member\n";
     *         $scanned++;
     *     }
     * }
     */
    public function sscan(string $key, ?int &$iterator, ?string $pattern = null, int $count = 0): array|false {}

    /**
     * Subscribes the client to the specified shard channels.
     * @param array $channels One or more channel names.
     * @param callable $cb The callback PhpRedis will invoke when we receive a message
     *                           from one of the subscribed channels.
     * @return bool True on success, false on faiilure.  Note that this command will block the
     *              client in a subscribe loop, waiting for messages to arrive.
     * @see https://redis.io/commands/ssubscribe
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->ssubscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
     *     echo "[$channel]: $message\n";
     *     // Unsubscribe from the message channel when we read 'quit'
     *     if ($message == 'quit') {
     *         echo "Unsubscribing from '$channel'\n";
     *         $redis->sunsubscribe([$channel]);
     *     }
     * });
     * // Once we read 'quit' from both channel-1 and channel-2 the subscribe loop will be
     * // broken and this command will execute.
     * echo "Subscribe loop ended\n";
     */
    public function ssubscribe(array $channels, callable $cb): bool {}

    /**
     * Retrieve the length of a Redis STRING key.
     * @param string $key The key we want the length of.
     * @return Redis|int|false The length of the string key if it exists, zero if it does not, and
     *                         false on failure.
     * @see https://redis.io/commands/strlen
     * @example $redis->strlen('mykey');
     */
    public function strlen(string $key): Redis|int|false {}

    /**
     * Subscribe to one or more Redis pubsub channels.
     * @param array $channels One or more channel names.
     * @param callable $cb The callback PhpRedis will invoke when we receive a message
     *                           from one of the subscribed channels.
     * @return bool True on success, false on faiilure.  Note that this command will block the
     *              client in a subscribe loop, waiting for messages to arrive.
     * @see https://redis.io/commands/subscribe
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->subscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
     *     echo "[$channel]: $message\n";
     *     // Unsubscribe from the message channel when we read 'quit'
     *     if ($message == 'quit') {
     *         echo "Unsubscribing from '$channel'\n";
     *         $redis->unsubscribe([$channel]);
     *     }
     * });
     * // Once we read 'quit' from both channel-1 and channel-2 the subscribe loop will be
     * // broken and this command will execute.
     * echo "Subscribe loop ended\n";
     */
    public function subscribe(array $channels, callable $cb): bool {}

    /**
     * Unsubscribes the client from the given shard channels,
     * or from all of them if none is given.
     * @param array $channels One or more channels to unsubscribe from.
     * @return Redis|array|bool The array of unsubscribed channels.
     * @see https://redis.io/commands/sunsubscribe
     * @see Redis::ssubscribe()
     * @example
     * $redis->ssubscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
     *     if ($message == 'quit') {
     *         echo "$channel => 'quit' detected, unsubscribing!\n";
     *         $redis->sunsubscribe([$channel]);
     *     } else {
     *         echo "$channel => $message\n";
     *     }
     * });
     * echo "We've unsubscribed from both channels, exiting\n";
     */
    public function sunsubscribe(array $channels): Redis|array|bool {}

    /**
     * Atomically swap two Redis databases so that all of the keys in the source database will
     * now be in the destination database and vice-versa.
     * Note: This command simply swaps Redis' internal pointer to the database and is therefore
     * very fast, regardless of the size of the underlying databases.
     * @param int $src The source database number
     * @param int $dst The destination database number
     * @return Redis|bool Success if the databases could be swapped and false on failure.
     * @see https://redis.io/commands/swapdb
     * @see Redis::del()
     * @example
     * $redis->select(0);
     * $redis->set('db0-key', 'db0-value');
     * $redis->swapdb(0, 1);
     * $redis->get('db0-key');
     */
    public function swapdb(int $src, int $dst): Redis|bool {}

    /**
     * Retrieve the server time from the connected Redis instance.
     * @see https://redis.io/commands/time
     * @return Redis|array A two element array consisting of a Unix Timestamp and the number of microseconds
     *         elapsed since the second.
     * @example $redis->time();
     */
    public function time(): Redis|array {}

    /**
     * Get the amount of time a Redis key has before it will expire, in seconds.
     * @param string $key The Key we want the TTL for.
     * @return Redis|int|false (a) The number of seconds until the key expires, or -1 if the key has
     *                         no expiration, and -2 if the key does not exist.  In the event of an
     *                         error, this command will return false.
     * @see https://redis.io/commands/ttl
     * @example $redis->ttl('mykey');
     */
    public function ttl(string $key): Redis|int|false {}

    /**
     * Get the type of a given Redis key.
     * @see https://redis.io/commands/type
     * @param string $key The key to check
     * @return Redis|int|false The Redis type constant or false on failure.
     * The Redis class defines several type constants that correspond with Redis key types.
     *     Redis::REDIS_NOT_FOUND
     *     Redis::REDIS_STRING
     *     Redis::REDIS_SET
     *     Redis::REDIS_LIST
     *     Redis::REDIS_ZSET
     *     Redis::REDIS_HASH
     *     Redis::REDIS_STREAM
     * @example
     * foreach ($redis->keys('*') as $key) {
     *     echo "$key => " . $redis->type($key) . "\n";
     * }
     */
    public function type(string $key): Redis|int|false {}

    /**
     * Delete one or more keys from the Redis database.  Unlike this operation, the actual
     * deletion is asynchronous, meaning it is safe to delete large keys without fear of
     * Redis blocking for a long period of time.
     * @param array|string $key Either an array with one or more keys or a string with
     *                                  the first key to delete.
     * @param string ...$other_keys If the first argument passed to this method was a string
     *                                  you may pass any number of additional key names.
     * @return Redis|int|false The number of keys deleted or false on failure.
     * @see https://redis.io/commands/unlink
     * @see https://redis.io/commands/del
     * @see Redis::del()
     * @example $redis->unlink('key1', 'key2', 'key3');
     * @example $redis->unlink(['key1', 'key2', 'key3']);
     */
    public function unlink(array|string $key, string ...$other_keys): Redis|int|false {}

    /**
     * Unsubscribe from one or more subscribed channels.
     * @param array $channels One or more channels to unsubscribe from.
     * @return Redis|array|bool The array of unsubscribed channels.
     * @see https://redis.io/commands/unsubscribe
     * @see Redis::subscribe()
     * @example
     * $redis->subscribe(['channel-1', 'channel-2'], function ($redis, $channel, $message) {
     *     if ($message == 'quit') {
     *         echo "$channel => 'quit' detected, unsubscribing!\n";
     *         $redis->unsubscribe([$channel]);
     *     } else {
     *         echo "$channel => $message\n";
     *     }
     * });
     * echo "We've unsubscribed from both channels, exiting\n";
     */
    public function unsubscribe(array $channels): Redis|array|bool {}

    /**
     * Remove any previously WATCH'ed keys in a transaction.
     * @see https://redis.io/commands/unwatch
     * @see https://redis.io/commands/unwatch
     * @see Redis::watch()
     * @return Redis|bool on success and false on failure.
     */
    public function unwatch(): Redis|bool {}

    /**
     * Watch one or more keys for conditional execution of a transaction.
     * @param array|string $key Either an array with one or more key names, or a string key name
     * @param string ...$other_keys If the first argument was passed as a string, any number of additional
     *                                   string key names may be passed variadically.
     * @return Redis|bool
     * @see https://redis.io/commands/watch
     * @see https://redis.io/commands/unwatch
     * @example
     * $redis1 = new Redis(['host' => 'localhost']);
     * $redis2 = new Redis(['host' => 'localhost']);
     * // Start watching 'incr-key'
     * $redis1->watch('incr-key');
     * // Retrieve its value.
     * $val = $redis1->get('incr-key');
     * // A second client modifies 'incr-key' after we read it.
     * $redis2->set('incr-key', 0);
     * // Because another client changed the value of 'incr-key' after we read it, this
     * // is no longer a proper increment operation, but because we are `WATCH`ing the
     * // key, this transaction will fail and we can try again.
     * //
     * // If were to comment out the above `$redis2->set('incr-key', 0)` line the
     * // transaction would succeed.
     * $redis1->multi();
     * $redis1->set('incr-key', $val + 1);
     * $res = $redis1->exec();
     * // bool(false)
     * var_dump($res);
     */
    public function watch(array|string $key, string ...$other_keys): Redis|bool {}

    /**
     * Block the client up to the provided timeout until a certain number of replicas have confirmed
     * recieving them.
     * @see https://redis.io/commands/wait
     * @param int $numreplicas The number of replicas we want to confirm write operaions
     * @param int $timeout How long to wait (zero meaning forever).
     * @return int|false The number of replicas that have confirmed or false on failure.
     */
    public function wait(int $numreplicas, int $timeout): int|false {}

    /**
     * Acknowledge one ore more messages that are pending (have been consumed using XREADGROUP but
     * not yet acknowledged by XACK.)
     * @param string $key The stream to query.
     * @param string $group The consumer group to use.
     * @param array $ids An array of stream entry IDs.
     * @return int|false The number of acknowledged messages
     * @see https://redis.io/commands/xack
     * @see https://redis.io/commands/xreadgroup
     * @see Redis::xack()
     * @example
     * $redis->xAdd('ships', '*', ['name' => 'Enterprise']);
     * $redis->xAdd('ships', '*', ['name' => 'Defiant']);
     * $redis->xGroup('CREATE', 'ships', 'Federation', '0-0');
     * // Consume a single message with the consumer group 'Federation'
     * $ship = $redis->xReadGroup('Federation', 'Picard', ['ships' => '>'], 1);
     * /* Retrieve the ID of the message we read.
     * assert(isset($ship['ships']));
     * $id = key($ship['ships']);
     * // The message we just read is now pending.
     * $res = $redis->xPending('ships', 'Federation'));
     * var_dump($res);
     * // We can tell Redis we were able to process the message by using XACK
     * $res = $redis->xAck('ships', 'Federation', [$id]);
     * assert($res === 1);
     * // The message should no longer be pending.
     * $res = $redis->xPending('ships', 'Federation');
     * var_dump($res);
     */
    public function xack(string $key, string $group, array $ids): int|false {}

    /**
     * Append a message to a stream.
     * @param string $key The stream name.
     * @param string $id The ID for the message we want to add.  This can be the special value '*'
     *                           which means Redis will generate the ID that appends the message to the
     *                           end of the stream.  It can also be a value in the form -* which will
     *                           generate an ID that appends to the end ot entries with the same  value
     *                           (if any exist).
     * @param int $maxlen If specified Redis will append the new message but trim any number of the
     *                           oldest messages in the stream until the length is <= $maxlen.
     * @param bool $approx Used in conjunction with `$maxlen`, this flag tells Redis to trim the stream
     *                           but in a more efficient way, meaning the trimming may not be exactly to
     *                           `$maxlen` values.
     * @param bool $nomkstream If passed as `TRUE`, the stream must exist for Redis to append the message.
     * @see https://redis.io/commands/xadd
     * @example $redis->xAdd('ds9-season-1', '1-1', ['title' => 'Emissary Part 1']);
     * @example $redis->xAdd('ds9-season-1', '1-2', ['title' => 'A Man Alone']);
     */
    public function xadd(string $key, string $id, array $values, int $maxlen = 0, bool $approx = false, bool $nomkstream = false): Redis|string|false {}

    /**
     * This command allows a consumer to claim pending messages that have been idle for a specified period of time.
     * Its purpose is to provide a mechanism for picking up messages that may have had a failed consumer.
     * @see https://redis.io/commands/xautoclaim
     * @see https://redis.io/commands/xclaim
     * @see https://redis.io/docs/data-types/streams-tutorial/
     * @param string $key The stream to check.
     * @param string $group The consumer group to query.
     * @param string $consumer Which consumer to check.
     * @param int $min_idle The minimum time in milliseconds for the message to have been pending.
     * @param string $start The minimum message id to check.
     * @param int $count An optional limit on how many messages are returned.
     * @param bool $justid If the client only wants message IDs and not all of their data.
     * @return Redis|array|bool An array of pending IDs or false if there are none, or on failure.
     * @example
     * $redis->xGroup('CREATE', 'ships', 'combatants', '0-0', true);
     * $redis->xAdd('ships', '1424-74205', ['name' => 'Defiant']);
     * // Consume the ['name' => 'Defiant'] message
     * $msgs = $redis->xReadGroup('combatants', "Jem'Hadar", ['ships' => '>'], 1);
     * // The "Jem'Hadar" consumer has the message presently
     * $pending = $redis->xPending('ships', 'combatants');
     * var_dump($pending);
     * // Asssume control of the pending message with a different consumer.
     * $res = $redis->xAutoClaim('ships', 'combatants', 'Sisko', 0, '0-0');
     * // Now the 'Sisko' consumer owns the message
     * $pending = $redis->xPending('ships', 'combatants');
     * var_dump($pending);
     */
    public function xautoclaim(string $key, string $group, string $consumer, int $min_idle, string $start, int $count = -1, bool $justid = false): Redis|bool|array {}

    /**
     * This method allows a consumer to take ownership of pending stream entries, by ID.  Another
     * command that does much the same thing but does not require passing specific IDs is `Redis::xAutoClaim`.
     * @see https://redis.io/commands/xclaim
     * @see https://redis.io/commands/xautoclaim.
     * @param string $key The stream we wish to claim messages for.
     * @param string $group Our consumer group.
     * @param string $consumer Our consumer.
     * @param int $min_idle The minimum idle-time in milliseconds a message must have for ownership to be transferred.
     * @param array $options An options array that modifies how the command operates.
     *                               
     *                               # Following is an options array describing every option you can pass.  Note that
     *                               # 'IDLE', and 'TIME' are mutually exclusive.
     *                               $options = [
     *                                   'IDLE'       => 3            # Set the idle time of the message to a 3.  By default
     *                                                                # the idle time is set to zero.
     *                                   'TIME'       => 1000*time()  # Same as IDLE except it takes a unix timestamp in
     *                                                                # milliseconds.
     *                                   'RETRYCOUNT' => 0            # Set the retry counter to zero.  By default XCLAIM
     *                                                                # doesn't modify the counter.
     *                                   'FORCE'                      # Creates the pending message entry even if IDs are
     *                                                                # not already
     *                                                                # in the PEL with another client.
     *                                   'JUSTID'                     # Return only an array of IDs rather than the messages
     *                                                                # themselves.
     *                               ];
     *                               
     * @return Redis|array|bool      An array of claimed messags or false on failure.
     * @example
     * $redis->xGroup('CREATE', 'ships', 'combatants', '0-0', true);
     * $redis->xAdd('ships', '1424-74205', ['name' => 'Defiant']);
     * // Consume the ['name' => 'Defiant'] message
     * $msgs = $redis->xReadGroup('combatants', "Jem'Hadar", ['ships' => '>'], 1);
     * // The "Jem'Hadar" consumer has the message presently
     * $pending = $redis->xPending('ships', 'combatants');
     * var_dump($pending);
     * assert($pending && isset($pending[1]));
     * // Claim the message by ID.
     * $claimed = $redis->xClaim('ships', 'combatants', 'Sisko', 0, [$pending[1]], ['JUSTID']);
     * var_dump($claimed);
     * // Now the 'Sisko' consumer owns the message
     * $pending = $redis->xPending('ships', 'combatants');
     * var_dump($pending);
     */
    public function xclaim(string $key, string $group, string $consumer, int $min_idle, array $ids, array $options): Redis|array|bool {}

    /**
     * Remove one or more specific IDs from a stream.
     * @param string $key The stream to modify.
     * @param array $ids One or more message IDs to remove.
     * @return Redis|int|false The number of messages removed or false on failure.
     * @example $redis->xDel('stream', ['1-1', '2-1', '3-1']);
     */
    public function xdel(string $key, array $ids): Redis|int|false {}

    /**
     * XGROUP
     * Perform various operation on consumer groups for a particular Redis STREAM.  What the command does
     * is primarily based on which operation is passed.
     * @see https://redis.io/commands/xgroup/
     * @param string $operation The subcommand you intend to execute.  Valid options are as follows
     *                               'HELP'           - Redis will return information about the command
     *                                                  Requires: none
     *                               'CREATE'         - Create a consumer group.
     *                                                  Requires:  Key, group, consumer.
     *                               'SETID'          - Set the ID of an existing consumer group for the stream.
     *                                                  Requires:  Key, group, id.
     *                               'CREATECONSUMER' - Create a new consumer group for the stream.  You must
     *                                                  also pass key, group, and the consumer name you wish to
     *                                                  create.
     *                                                  Requires:  Key, group, consumer.
     *                               'DELCONSUMER'    - Delete a consumer from group attached to the stream.
     *                                                  Requires:  Key, group, consumer.
     *                               'DESTROY'        - Delete a consumer group from a stream.
     *                                                  Requires:  Key, group.
     * @param string|null $key The STREAM we're operating on.
     * @param string|null $group The consumer group we want to create/modify/delete.
     * @param string|null $id_or_consumer The STREAM id (e.g. '$') or consumer group.  See the operation section
     *                               for information about which to send.
     * @param bool $mkstream This flag may be sent in combination with the 'CREATE' operation, and
     *                               cause Redis to also create the STREAM if it doesn't currently exist.
     * @param int $entries_read
     * @return mixed                 This command return various results depending on the operation performed.
     */
    public function xgroup(
        string $operation,
        ?string $key = null,
        ?string $group = null,
        ?string $id_or_consumer = null,
        bool $mkstream = false,
        int $entries_read = -2
    ): mixed {}

    /**
     * Retrieve information about a stream key.
     * @param string $operation The specific info operation to perform.
     * @param string|null $arg1 The first argument (depends on operation)
     * @param string|null $arg2 The second argument
     * @param int $count The COUNT argument to `XINFO STREAM`
     * @return mixed This command can return different things depending on the operation being called.
     * @see https://redis.io/commands/xinfo
     * @example $redis->xInfo('CONSUMERS', 'stream');
     * @example $redis->xInfo('GROUPS', 'stream');
     * @example $redis->xInfo('STREAM', 'stream');
     */
    public function xinfo(string $operation, ?string $arg1 = null, ?string $arg2 = null, int $count = -1): mixed {}

    /**
     * Get the number of messages in a Redis STREAM key.
     * @param string $key The Stream to check.
     * @return Redis|int|false The number of messages or false on failure.
     * @see https://redis.io/commands/xlen
     * @example $redis->xLen('stream');
     */
    public function xlen(string $key): Redis|int|false {}

    /**
     * Interact with stream messages that have been consumed by a consumer group but not yet
     * acknowledged with XACK.
     * @see https://redis.io/commands/xpending
     * @see https://redis.io/commands/xreadgroup
     * @param string $key The stream to inspect.
     * @param string $group The user group we want to see pending messages from.
     * @param string|null $start The minimum ID to consider.
     * @param string|null $end The maximum ID to consider.
     * @param int $count Optional maximum number of messages to return.
     * @param string|null $consumer If provided, limit the returned messages to a specific consumer.
     * @return Redis|array|false The pending messages belonging to the stream or false on failure.
     */
    public function xpending(string $key, string $group, ?string $start = null, ?string $end = null, int $count = -1, ?string $consumer = null): Redis|array|false {}

    /**
     * Get a range of entries from a STREAM key.
     * @param string $key The stream key name to list.
     * @param string $start The minimum ID to return.
     * @param string $end The maximum ID to return.
     * @param int $count An optional maximum number of entries to return.
     * @return Redis|array|bool The entries in the stream within the requested range or false on failure.
     * @see https://redis.io/commands/xrange
     * @example $redis->xRange('stream', '0-1', '0-2');
     * @example $redis->xRange('stream', '-', '+');
     */
    public function xrange(string $key, string $start, string $end, int $count = -1): Redis|array|bool {}

    /**
     * Consume one or more unconsumed elements in one or more streams.
     * @param array $streams An associative array with stream name keys and minimum id values.
     * @param int $count An optional limit to how many entries are returnd *per stream*
     * @param int $block An optional maximum number of milliseconds to block the caller if no
     *                       data is available on any of the provided streams.
     * @return Redis|array|bool An array of read elements or false if there aren't any.
     * @see https://redis.io/commands/xread
     * @example
     * $redis->xAdd('s03', '3-1', ['title' => 'The Search, Part I']);
     * $redis->xAdd('s03', '3-2', ['title' => 'The Search, Part II']);
     * $redis->xAdd('s03', '3-3', ['title' => 'The House Of Quark']);
     * $redis->xAdd('s04', '4-1', ['title' => 'The Way of the Warrior']);
     * $redis->xAdd('s04', '4-3', ['title' => 'The Visitor']);
     * $redis->xAdd('s04', '4-4', ['title' => 'Hippocratic Oath']);
     * $redis->xRead(['s03' => '3-2', 's04' => '4-1']);
     */
    public function xread(array $streams, int $count = -1, int $block = -1): Redis|array|bool {}

    /**
     * Read one or more messages using a consumer group.
     * @param string $group The consumer group to use.
     * @param string $consumer The consumer to use.
     * @param array $streams An array of stream names and message IDs
     * @param int $count Optional maximum number of messages to return
     * @param int $block How long to block if there are no messages available.
     * @return Redis|array|bool Zero or more unread messages or false on failure.
     * @see https://redis.io/commands/xreadgroup
     * @example
     * $redis->xGroup('CREATE', 'episodes', 'ds9', '0-0', true);
     * $redis->xAdd('episodes', '1-1', ['title' => 'Emissary: Part 1']);
     * $redis->xAdd('episodes', '1-2', ['title' => 'A Man Alone']);
     * $messages = $redis->xReadGroup('ds9', 'sisko', ['episodes' => '>']);
     * // After having read the two messages, add another
     * $redis->xAdd('episodes', '1-3', ['title' => 'Emissary: Part 2']);
     * // Acknowledge the first two read messages
     * foreach ($messages as $stream => $stream_messages) {
     *     $ids = array_keys($stream_messages);
     *     $redis->xAck('stream', 'ds9', $ids);
     * }
     * // We can now pick up where we left off, and will only get the final message
     * $msgs = $redis->xReadGroup('ds9', 'sisko', ['episodes' => '>']);
     */
    public function xreadgroup(string $group, string $consumer, array $streams, int $count = 1, int $block = 1): Redis|array|bool {}

    /**
     * Get a range of entries from a STREAM ke in reverse cronological order.
     * @param string $key The stream key to query.
     * @param string $end The maximum message ID to include.
     * @param string $start The minimum message ID to include.
     * @param int $count An optional maximum number of messages to include.
     * @return Redis|array|bool The entries within the requested range, from newest to oldest.
     * @see https://redis.io/commands/xrevrange
     * @see https://redis.io/commands/xrange
     * @example $redis->xRevRange('stream', '0-2', '0-1');
     * @example $redis->xRevRange('stream', '+', '-');
     */
    public function xrevrange(string $key, string $end, string $start, int $count = -1): Redis|array|bool {}

    /**
     * Truncate a STREAM key in various ways.
     * @param string $key The STREAM key to trim.
     * @param string $threshold This can either be a maximum length, or a minimum id.
     *                          MAXLEN - An integer describing the maximum desired length of the stream after the command.
     *                          MINID  - An ID that will become the new minimum ID in the stream, as Redis will trim all
     *                                   messages older than this ID.
     * @param bool $approx Whether redis is allowed to do an approximate trimming of the stream.  This is
     *                          more efficient for Redis given how streams are stored internally.
     * @param bool $minid When set to `true`, users should pass a minimum ID to the `$threshold` argument.
     * @param int $limit An optional upper bound on how many entries to trim during the command.
     * @return Redis|int|false  The number of entries deleted from the stream.
     * @see https://redis.io/commands/xtrim
     * @example $redis->xTrim('stream', 3);
     * @example $redis->xTrim('stream', '2-1', false, true);
     */
    public function xtrim(string $key, string $threshold, bool $approx = false, bool $minid = false, int $limit = -1): Redis|int|false {}

    /**
     * Add one or more elements and scores to a Redis sorted set.
     * @param string $key The sorted set in question.
     * @param array|float $score_or_options Either the score for the first element, or an array of options.
     *                                           
     *                                            $options = [
     *                                                'NX',       # Only update elements that already exist
     *                                                'NX',       # Only add new elements but don't update existing ones.
     *                                                'LT'        # Only update existing elements if the new score is
     *                                                            # less than the existing one.
     *                                                'GT'        # Only update existing elements if the new score is
     *                                                            # greater than the existing one.
     *                                                'CH'        # Instead of returning the number of elements added,
     *                                                            # Redis will return the number Of elements that were
     *                                                            # changed in the operation.
     *                                                'INCR'      # Instead of setting each element to the provide score,
     *                                                            # increment the element by the
     *                                                            # provided score, much like ZINCRBY.  When this option
     *                                                            # is passed, you may only send a single score and member.
     *                                            ];
     *                                            Note:  'GX', 'LT', and 'NX' cannot be passed together, and PhpRedis
     *                                                   will send whichever one is last in the options array.
     * @param mixed $more_scores_and_mems A variadic number of additional scores and members.
     * @return Redis|int|float|false The return value varies depending on the options passed.
     * Following is information about the options that may be passed as the second argument:
     * @see https://redis.io/commands/zadd
     * @example $redis->zadd('zs', 1, 'first', 2, 'second', 3, 'third');
     * @example $redis->zAdd('zs', ['XX'], 8, 'second', 99, 'new-element');
     */
    public function zAdd(string $key, array|float $score_or_options, mixed ...$more_scores_and_mems): Redis|int|float|false {}

    /**
     * Return the number of elements in a sorted set.
     * @param string $key The sorted set to retreive cardinality from.
     * @return Redis|int|false The number of elements in the set or false on failure
     * @see https://redis.io/commands/zcard
     * @example $redis->zCard('zs');
     */
    public function zCard(string $key): Redis|int|false {}

    /**
     * Count the number of members in a sorted set with scores inside a provided range.
     * @param string $key The sorted set to check.
     * @param string $start The minimum score to include in the count
     * @param string $end The maximum score to include in the count
     * NOTE:  In addition to a floating point score you may pass the special values of '-inf' and
     *        '+inf' meaning negative and positive infinity, respectively.
     * @see https://redis.io/commands/zcount
     * @example $redis->zCount('fruit-rankings', '0', '+inf');
     * @example $redis->zCount('fruit-rankings', 50, 60);
     * @example $redis->zCount('fruit-rankings', '-inf', 0);
     */
    public function zCount(string $key, string $start, string $end): Redis|int|false {}

    /**
     * Create or increment the score of a member in a Redis sorted set
     * @param string $key The sorted set in question.
     * @param float $value How much to increment the score.
     * @return Redis|float|false The new score of the member or false on failure.
     * @see https://redis.io/commands/zincrby
     * @example $redis->zIncrBy('zs', 5.0, 'bananas');
     * @example $redis->zIncrBy('zs', 2.0, 'eggplants');
     */
    public function zIncrBy(string $key, float $value, mixed $member): Redis|float|false {}

    /**
     * Count the number of elements in a sorted set whos members fall within the provided
     * lexographical range.
     * @param string $key The sorted set to check.
     * @param string $min The minimum matching lexographical string
     * @param string $max The maximum matching lexographical string
     * @return Redis|int|false The number of members that fall within the range or false on failure.
     * @see https://redis.io/commands/zlexcount
     * @example
     * $redis->zAdd('captains', 0, 'Janeway', 0, 'Kirk', 0, 'Picard', 0, 'Sisko', 0, 'Archer');
     * $redis->zLexCount('captains', '[A', '[S');
     */
    public function zLexCount(string $key, string $min, string $max): Redis|int|false {}

    /**
     * Retrieve the score of one or more members in a sorted set.
     * @see https://redis.io/commands/zmscore
     * @param string $key The sorted set
     * @param mixed $member The first member to return the score from
     * @param mixed $other_members One or more additional members to return the scores of.
     * @return Redis|array|false An array of the scores of the requested elements.
     * @example
     * $redis->zAdd('zs', 0, 'zero', 1, 'one', 2, 'two', 3, 'three');
     * $redis->zMScore('zs', 'zero', 'two');
     * $redis->zMScore('zs', 'one', 'not-a-member');
     */
    public function zMscore(string $key, mixed $member, mixed ...$other_members): Redis|array|false {}

    /**
     * Pop one or more of the highest scoring elements from a sorted set.
     * @param string $key The sorted set to pop elements from.
     * @param int|null $count An optional count of elements to pop.
     * @return Redis|array|false All of the popped elements with scores or false on fialure.
     * @see https://redis.io/commands/zpopmax
     * @example
     * $redis->zAdd('zs', 0, 'zero', 1, 'one', 2, 'two', 3, 'three');
     * $redis->zPopMax('zs');
     * $redis->zPopMax('zs', 2);.
     */
    public function zPopMax(string $key, ?int $count = null): Redis|array|false {}

    /**
     * Pop one or more of the lowest scoring elements from a sorted set.
     * @param string $key The sorted set to pop elements from.
     * @param int|null $count An optional count of elements to pop.
     * @return Redis|array|false The popped elements with their scores or false on failure.
     * @see https://redis.io/commands/zpopmin
     * @example
     * $redis->zAdd('zs', 0, 'zero', 1, 'one', 2, 'two', 3, 'three');
     * $redis->zPopMin('zs');
     * $redis->zPopMin('zs', 2);
     */
    public function zPopMin(string $key, ?int $count = null): Redis|array|false {}

    /**
     * Retrieve a range of elements of a sorted set between a start and end point.
     * How the command works in particular is greatly affected by the options that
     * are passed in.
     * @param string $key The sorted set in question.
     * @param mixed $start The starting index we want to return.
     * @param mixed $end The final index we want to return.
     * @param array|bool|null $options This value may either be an array of options to pass to
     *                                 the command, or for historical purposes a boolean which
     *                                 controls just the 'WITHSCORES' option.
     *                                 
     *                                 $options = [
     *                                     'WITHSCORES' => true,     # Return both scores and members.
     *                                     'LIMIT'      => [10, 10], # Start at offset 10 and return 10 elements.
     *                                     'REV'                     # Return the elements in reverse order
     *                                     'BYSCORE',                # Treat `start` and `end` as scores instead
     *                                     'BYLEX'                   # Treat `start` and `end` as lexicographical values.
     *                                 ];
     *                                 
     *                                 Note:  'BYLEX' and 'BYSCORE' are mutually exclusive.
     * @return Redis|array|false  An array with matching elements or false on failure.
     * @see https://redis.io/commands/zrange/
     * @example $redis->zRange('zset', 0, -1);
     * @example $redis->zRange('zset', '-inf', 'inf', ['byscore']);
     */
    public function zRange(string $key, string|int $start, string|int $end, array|bool|null $options = null): Redis|array|false {}

    /**
     * Retrieve a range of elements from a sorted set by legographical range.
     * @param string $key The sorted set to retreive elements from
     * @param string $min The minimum legographical value to return
     * @param string $max The maximum legographical value to return
     * @param int $offset An optional offset within the matching values to return
     * @param int $count An optional count to limit the replies to (used in conjunction with offset)
     * @return Redis|array|false An array of matching elements or false on failure.
     * @see https://redis.io/commands/zrangebylex
     * @example
     * $redis = new Redis(['host' => 'localhost']);
     * $redis->zAdd('captains', 0, 'Janeway', 0, 'Kirk', 0, 'Picard', 0, 'Sisko', 0, 'Archer');
     * $redis->zRangeByLex('captains', '[A', '[S');
     * $redis->zRangeByLex('captains', '[A', '[S', 2, 2);
     */
    public function zRangeByLex(string $key, string $min, string $max, int $offset = -1, int $count = -1): Redis|array|false {}

    /**
     * Retrieve a range of members from a sorted set by their score.
     * @param string $key The sorted set to query.
     * @param string $start The minimum score of elements that Redis should return.
     * @param string $end The maximum score of elements that Redis should return.
     * @param array $options Options that change how Redis will execute the command.
     *                        OPTION       TYPE            MEANING
     *                        'WITHSCORES' bool            Whether to also return scores.
     *                        'LIMIT'      [offset, count] Limit the reply to a subset of elements.
     * @return Redis|array|false The number of matching elements or false on failure.
     * @see https://redis.io/commands/zrangebyscore
     * @example $redis->zRangeByScore('zs', 20, 30, ['WITHSCORES' => true]);
     * @example $redis->zRangeByScore('zs', 20, 30, ['WITHSCORES' => true, 'LIMIT' => [5, 5]]);
     */
    public function zRangeByScore(string $key, string $start, string $end, array $options = []): Redis|array|false {}

    /**
     * This command is similar to ZRANGE except that instead of returning the values directly
     * it will store them in a destination key provided by the user
     * @param string $dstkey The key to store the resulting element(s)
     * @param string $srckey The source key with element(s) to retrieve
     * @param string $start The starting index to store
     * @param string $end The ending index to store
     * @param array|bool|null $options Our options array that controls how the command will function.
     * @return Redis|int|false The number of elements stored in $dstkey or false on failure.
     * @see https://redis.io/commands/zrange/
     * @see Redis::zRange
     * See {@link Redis::zRange} for a full description of the possible options.
     */
    public function zrangestore(
        string $dstkey,
        string $srckey,
        string $start,
        string $end,
        array|bool|null $options = null
    ): Redis|int|false {}

    /**
     * Retrieve one or more random members from a Redis sorted set.
     * @param string $key The sorted set to pull random members from.
     * @param array|null $options One or more options that determine exactly how the command operates.
     *                        OPTION       TYPE     MEANING
     *                        'COUNT'      int      The number of random members to return.
     *                        'WITHSCORES' bool     Whether to return scores and members instead of
     * @return Redis|string|array One ore more random elements.
     * @see https://redis.io/commands/zrandmember
     * @example $redis->zRandMember('zs', ['COUNT' => 2, 'WITHSCORES' => true]);
     */
    public function zRandMember(string $key, ?array $options = null): Redis|string|array {}

    /**
     * Get the rank of a member of a sorted set, by score.
     * @param string $key The sorted set to check.
     * @param mixed $member The member to test.
     * @return Redis|int|false The rank of the requested member.
     * @see https://redis.io/commands/zrank
     * @example $redis->zRank('zs', 'zero');
     * @example $redis->zRank('zs', 'three');
     */
    public function zRank(string $key, mixed $member): Redis|int|false {}

    /**
     * Remove one or more members from a Redis sorted set.
     * @param mixed $key The sorted set in question.
     * @param mixed $member The first member to remove.
     * @param mixed $other_members One or more members to remove passed in a variadic fashion.
     * @return Redis|int|false The number of members that were actually removed or false on failure.
     * @see https://redis.io/commands/zrem
     * @example $redis->zRem('zs', 'mem:0', 'mem:1', 'mem:2', 'mem:6', 'mem:7', 'mem:8', 'mem:9');
     */
    public function zRem(mixed $key, mixed $member, mixed ...$other_members): Redis|int|false {}

    /**
     * Remove zero or more elements from a Redis sorted set by legographical range.
     * @param string $key The sorted set to remove elements from.
     * @param string $min The start of the lexographical range to remove.
     * @param string $max The end of the lexographical range to remove
     * @return Redis|int|false The number of elements removed from the set or false on failure.
     * @see https://redis.io/commands/zremrangebylex
     * @see Redis::zrangebylex()
     * @example $redis->zRemRangeByLex('zs', '[a', '(b');
     * @example $redis->zRemRangeByLex('zs', '(banana', '(eggplant');
     */
    public function zRemRangeByLex(string $key, string $min, string $max): Redis|int|false {}

    /**
     * Remove one or more members of a sorted set by their rank.
     * @param string $key The sorted set where we wnat to remove members.
     * @param int $start The rank when we want to start removing members
     * @param int $end The rank we want to stop removing membersk.
     * @return Redis|int|false The number of members removed from the set or false on failure.
     * @see https://redis.io/commands/zremrangebyrank
     * @example $redis->zRemRangeByRank('zs', 0, 3);
     */
    public function zRemRangeByRank(string $key, int $start, int $end): Redis|int|false {}

    /**
     * Remove one or more members of a sorted set by their score.
     * @param string $key The sorted set where we wnat to remove members.
     * @param string $start The lowest score to remove.
     * @param string $end The highest score to remove.
     * @return Redis|int|false The number of members removed from the set or false on failure.
     * @see https://redis.io/commands/zremrangebyrank
     * @example
     * $redis->zAdd('zs', 2, 'two', 4, 'four', 6, 'six');
     * $redis->zRemRangeByScore('zs', 2, 4);
     */
    public function zRemRangeByScore(string $key, string $start, string $end): Redis|int|false {}

    /**
     * List the members of a Redis sorted set in reverse order
     * @param string $key The sorted set in question.
     * @param int $start The index to start listing elements
     * @param int $end The index to stop listing elements.
     * @param mixed $scores Whether or not Redis should also return each members score.  See
     *                           the example below demonstrating how it may be used.
     * @return Redis|array|false The members (and possibly scores) of the matching elements or false
     *                           on failure.
     * @see https://redis.io/commands/zrevrange
     * @example $redis->zRevRange('zs', 0, -1);
     * @example $redis->zRevRange('zs', 2, 3);
     * @example $redis->zRevRange('zs', 0, -1, true);
     * @example $redis->zRevRange('zs', 0, -1, ['withscores' => true]);
     */
    public function zRevRange(string $key, int $start, int $end, mixed $scores = null): Redis|array|false {}

    /**
     * List members of a Redis sorted set within a legographical range, in reverse order.
     * @param string $key The sorted set to list
     * @param string $max The maximum legographical element to include in the result.
     * @param string $min The minimum lexographical element to include in the result.
     * @param int $offset An option offset within the matching elements to start at.
     * @param int $count An optional count to limit the replies to.
     * @return Redis|array|false The matching members or false on failure.
     * @see https://redis.io/commands/zrevrangebylex
     * @see Redis::zrangebylex()
     * @example $redis->zRevRangeByLex('captains', '[Q', '[J');
     * @example $redis->zRevRangeByLex('captains', '[Q', '[J', 1, 2);
     */
    public function zRevRangeByLex(string $key, string $max, string $min, int $offset = -1, int $count = -1): Redis|array|false {}

    /**
     * List elements from a Redis sorted set by score, highest to lowest
     * @param string $key The sorted set to query.
     * @param string $max The highest score to include in the results.
     * @param string $min The lowest score to include in the results.
     * @param array|bool $options An options array that modifies how the command executes.
     *                        
     *                        $options = [
     *                            'WITHSCORES' => true|false # Whether or not to return scores
     *                            'LIMIT' => [offset, count] # Return a subset of the matching members
     *                        ];
     *                        
     *                        NOTE:  For legacy reason, you may also simply pass `true` for the
     *                               options argument, to mean `WITHSCORES`.
     * @return Redis|array|false The matching members in reverse order of score or false on failure.
     * @see https://redis.io/commands/zrevrangebyscore
     * @example
     * $redis->zadd('oldest-people', 122.4493, 'Jeanne Calment', 119.2932, 'Kane Tanaka',
     *                               119.2658, 'Sarah Knauss',   118.7205, 'Lucile Randon',
     *                               117.7123, 'Nabi Tajima',    117.6301, 'Marie-Louise Meilleur',
     *                               117.5178, 'Violet Brown',   117.3753, 'Emma Morano',
     *                               117.2219, 'Chiyo Miyako',   117.0740, 'Misao Okawa');
     * $redis->zRevRangeByScore('oldest-people', 122, 119);
     * $redis->zRevRangeByScore('oldest-people', 'inf', 118);
     * $redis->zRevRangeByScore('oldest-people', '117.5', '-inf', ['LIMIT' => [0, 1]]);
     */
    public function zRevRangeByScore(string $key, string $max, string $min, array|bool $options = []): Redis|array|false {}

    /**
     * Retrieve a member of a sorted set by reverse rank.
     * @param string $key The sorted set to query.
     * @param mixed $member The member to look up.
     * @return Redis|int|false The reverse rank (the rank if counted high to low) of the member or
     *                         false on failure.
     * @see https://redis.io/commands/zrevrank
     * @example
     * $redis->zAdd('ds9-characters', 10, 'Sisko', 9, 'Garak', 8, 'Dax', 7, 'Odo');
     * $redis->zrevrank('ds9-characters', 'Sisko');
     * $redis->zrevrank('ds9-characters', 'Garak');
     */
    public function zRevRank(string $key, mixed $member): Redis|int|false {}

    /**
     * Get the score of a member of a sorted set.
     * @param string $key The sorted set to query.
     * @param mixed $member The member we wish to query.
     * @return Redis|float|false The score of the requested element or false if it is not found.
     * @see https://redis.io/commands/zscore
     * @example
     * $redis->zAdd('telescopes', 11.9, 'LBT', 10.4, 'GTC', 10, 'HET');
     * $redis->zScore('telescopes', 'LBT');
     */
    public function zScore(string $key, mixed $member): Redis|float|false {}

    /**
     * Given one or more sorted set key names, return every element that is in the first
     * set but not any of the others.
     * @param array $keys One ore more sorted sets.
     * @param array|null $options An array which can contain ['WITHSCORES' => true] if you want Redis to
     *                       return members and scores.
     * @return Redis|array|false An array of members or false on failure.
     * @see https://redis.io/commands/zdiff
     * @example
     * $redis->zAdd('primes', 1, 'one', 3, 'three', 5, 'five');
     * $redis->zAdd('evens', 2, 'two', 4, 'four');
     * $redis->zAdd('mod3', 3, 'three', 6, 'six');
     * $redis->zDiff(['primes', 'evens', 'mod3']);
     */
    public function zdiff(array $keys, ?array $options = null): Redis|array|false {}

    /**
     * Store the difference of one or more sorted sets in a destination sorted set.
     * See {@link Redis::zdiff} for a more detailed description of how the diff operation works.
     * @param string $dst The destination set name.
     * @param array $keys One or more source key names
     * @return Redis|int|false The number of elements stored in the destination set or false on
     *                         failure.
     * @see https://redis.io/commands/zdiff
     * @see Redis::zdiff()
     */
    public function zdiffstore(string $dst, array $keys): Redis|int|false {}

    /**
     * Compute the intersection of one or more sorted sets and return the members
     * @param array $keys One ore more sorted sets.
     * @param array|null $weights An optional array of weights to be applied to each set when performing
     *                       the intersection.
     * @param array|null $options Options for how Redis should combine duplicate elements when performing the
     *                       intersection.  See Redis::zunion() for details.
     * @return Redis|array|false All of the members that exist in every set.
     * @see https://redis.io/commands/zinter
     * @example
     * $redis->zAdd('TNG', 2, 'Worf', 2.5, 'Data', 4.0, 'Picard');
     * $redis->zAdd('DS9', 2.5, 'Worf', 3.0, 'Kira', 4.0, 'Sisko');
     * $redis->zInter(['TNG', 'DS9']);
     * $redis->zInter(['TNG', 'DS9'], NULL, ['withscores' => true]);
     * $redis->zInter(['TNG', 'DS9'], NULL, ['withscores' => true, 'aggregate' => 'max']);
     */
    public function zinter(array $keys, ?array $weights = null, ?array $options = null): Redis|array|false {}

    /**
     * Similar to ZINTER but instead of returning the intersected values, this command returns the
     * cardinality of the intersected set.
     * @see https://redis.io/commands/zintercard
     * @see https://redis.io/commands/zinter
     * @see Redis::zinter()
     * @param array $keys One ore more sorted set key names.
     * @param int $limit An optional upper bound on the returned cardinality.  If set to a value
     *                      greater than zero, Redis will stop processing the intersection once the
     *                      resulting cardinality reaches this limit.
     * @return Redis|int|false The cardinality of the intersection or false on failure.
     * @example
     * $redis->zAdd('zs1', 1, 'one', 2, 'two', 3, 'three', 4, 'four');
     * $redis->zAdd('zs2', 2, 'two', 4, 'four');
     * $redis->zInterCard(['zs1', 'zs2']);
     */
    public function zintercard(array $keys, int $limit = -1): Redis|int|false {}

    /**
     * Compute the intersection of one ore more sorted sets storing the result in a new sorted set.
     * @param string $dst The destination sorted set to store the intersected values.
     * @param array $keys One ore more sorted set key names.
     * @param array|null $weights An optional array of floats to weight each passed input set.
     * @param string|null $aggregate An optional aggregation method to use.
     *                          'SUM' - Store sum of all intersected members (this is the default).
     *                          'MIN' - Store minimum value for each intersected member.
     *                          'MAX' - Store maximum value for each intersected member.
     * @return Redis|int|false  The total number of members writtern to the destination set or false on failure.
     * @see https://redis.io/commands/zinterstore
     * @see https://redis.io/commands/zinter
     * @example
     * $redis->zAdd('zs1', 3, 'apples', 2, 'pears');
     * $redis->zAdd('zs2', 4, 'pears', 3, 'bananas');
     * $redis->zAdd('zs3', 2, 'figs', 3, 'pears');
     * $redis->zInterStore('fruit-sum', ['zs1', 'zs2', 'zs3']);
     * $redis->zInterStore('fruit-max', ['zs1', 'zs2', 'zs3'], NULL, 'MAX');
     */
    public function zinterstore(string $dst, array $keys, ?array $weights = null, ?string $aggregate = null): Redis|int|false {}

    /**
     * Scan the members of a sorted set incrementally, using a cursor
     * @param string $key The sorted set to scan.
     * @param int|null $iterator A reference to an iterator that should be initialized to NULL initially, that
     *                           will be updated after each subsequent call to ZSCAN.  Once the iterator
     *                           has returned to zero the scan is complete
     * @param string|null $pattern An optional glob-style pattern that limits which members are returned during
     *                           the scanning process.
     * @param int $count A hint for Redis that tells it how many elements it should test before returning
     *                           from the call.  The higher the more work Redis may do in any one given call to
     *                           ZSCAN potentially blocking for longer periods of time.
     * @return Redis|array|false An array of elements or false on failure.
     * @see https://redis.io/commands/zscan
     * @see https://redis.io/commands/scan
     * @see Redis::scan()
     * NOTE:  See Redis::scan() for detailed example code on how to call SCAN like commands.
     */
    public function zscan(string $key, ?int &$iterator, ?string $pattern = null, int $count = 0): Redis|array|false {}

    /**
     * Retrieve the union of one or more sorted sets
     * @param array $keys One ore more sorted set key names
     * @param array|null $weights An optional array with floating point weights used when performing the union.
     *                        Note that if this argument is passed, it must contain the same number of
     *                        elements as the $keys array.
     * @param array|null $options An array that modifies how this command functions.
     *                        
     *                        $options = [
     *                            # By default when members exist in more than one set Redis will SUM
     *                            # total score for each match.  Instead, it can return the AVG, MIN,
     *                            # or MAX value based on this option.
     *                            'AGGREGATE' => 'sum' | 'min' | 'max'
     *                            # Whether Redis should also return each members aggregated score.
     *                            'WITHSCORES' => true | false
     *                        ]
     *                        
     * @return Redis|array|false The union of each sorted set or false on failure
     * @example
     * $redis->del('store1', 'store2', 'store3');
     * $redis->zAdd('store1', 1, 'apples', 3, 'pears', 6, 'bananas');
     * $redis->zAdd('store2', 3, 'apples', 5, 'coconuts', 2, 'bananas');
     * $redis->zAdd('store3', 2, 'bananas', 6, 'apples', 4, 'figs');
     * $redis->zUnion(['store1', 'store2', 'store3'], NULL, ['withscores' => true]);
     * $redis->zUnion(['store1', 'store3'], [2, .5], ['withscores' => true]);
     * $redis->zUnion(['store1', 'store3'], [2, .5], ['withscores' => true, 'aggregate' => 'MIN']);
     */
    public function zunion(array $keys, ?array $weights = null, ?array $options = null): Redis|array|false {}

    /**
     * Perform a union on one or more Redis sets and store the result in a destination sorted set.
     * @param string $dst The destination set to store the union.
     * @param array $keys One or more input keys on which to perform our union.
     * @param array|null $weights An optional weights array used to weight each input set.
     * @param string|null $aggregate An optional modifier in how Redis will combine duplicate members.
     *                          Valid:  'MIN', 'MAX', 'SUM'.
     * @return Redis|int|false The number of members stored in the destination set or false on failure.
     * @see https://redis.io/commands/zunionstore
     * @see Redis::zunion()
     * @example
     * $redis->zAdd('zs1', 1, 'one', 3, 'three');
     * $redis->zAdd('zs1', 2, 'two', 4, 'four');
     * $redis->zadd('zs3', 1, 'one', 7, 'five');
     * $redis->zUnionStore('dst', ['zs1', 'zs2', 'zs3']);
     */
    public function zunionstore(string $dst, array $keys, ?array $weights = null, ?string $aggregate = null): Redis|int|false {}
}

class RedisException extends RuntimeException {}

 */
interface Traversable extends iterable {}

/**
 * Interface to create an external Iterator.
 * @link https://php.net/manual/en/class.iteratoraggregate.php
 * @template TKey
 * @template-covariant TValue
 * @template-extends Traversable
 */
interface IteratorAggregate extends Traversable
{
    /**
     * Retrieve an external iterator
     * @link https://php.net/manual/en/iteratoraggregate.getiterator.php
     * @return Traversable|TValue[] An instance of an object implementing Iterator or
     * Traversable
     * @throws Exception on failure.
     */
    #[TentativeType]
    public function getIterator(): Traversable;
}

/**
 * Interface for external iterators or objects that can be iterated
 * themselves internally.
 * @link https://php.net/manual/en/class.iterator.php
 * @template TKey
 * @template-covariant TValue
 * @template-extends Traversable
 */
interface Iterator extends Traversable
{
    /**
     * Return the current element
     * @link https://php.net/manual/en/iterator.current.php
     * @return TValue Can return any type.
     */
    #[TentativeType]
    public function current(): mixed;

    /**
     * Move forward to next element
     * @link https://php.net/manual/en/iterator.next.php
     * @return void Any returned value is ignored.
     */
    #[TentativeType]
    public function next(): void;

    /**
     * Return the key of the current element
     * @link https://php.net/manual/en/iterator.key.php
     * @return TKey|null TKey on success, or null on failure.
     */
    #[TentativeType]
    public function key(): mixed;

    /**
     * Checks if current position is valid
     * @link https://php.net/manual/en/iterator.valid.php
     * @return bool The return value will be casted to boolean and then evaluated.
     * Returns true on success or false on failure.
     */
    #[TentativeType]
    public function valid(): bool;

    /**
     * Rewind the Iterator to the first element
     * @link https://php.net/manual/en/iterator.rewind.php
     * @return void Any returned value is ignored.
     */
    #[TentativeType]
    public function rewind(): void;
}

/**
 * Interface to provide accessing objects as arrays.
 * @link https://php.net/manual/en/class.arrayaccess.php
 * @template TKey
 * @template TValue
 */
interface ArrayAccess
{
    /**
     * Whether a offset exists
     * @link https://php.net/manual/en/arrayaccess.offsetexists.php
     * @param TKey $offset 

     * An offset to check for.
     * 
     * @return bool true on success or false on failure.
     * 

     * 

     * The return value will be casted to boolean if non-boolean was returned.
     */
    #[TentativeType]
    public function offsetExists(#[LanguageLevelTypeAware(['8.0' => 'mixed'], default: '')] $offset): bool;

    /**
     * Offset to retrieve
     * @link https://php.net/manual/en/arrayaccess.offsetget.php
     * @param TKey $offset 

     * The offset to retrieve.
     * 
     * @return TValue Can return all value types.
     */
    #[TentativeType]
    public function offsetGet(#[LanguageLevelTypeAware(['8.0' => 'mixed'], default: '')] $offset): mixed;

    /**
     * Offset to set
     * @link https://php.net/manual/en/arrayaccess.offsetset.php
     * @param TKey $offset 

     * The offset to assign the value to.
     * 
     * @param TValue $value 

     * The value to set.
     * 
     * @return void
     */
    #[TentativeType]
    public function offsetSet(
        #[LanguageLevelTypeAware(['8.0' => 'mixed'], default: '')] $offset,
        #[LanguageLevelTypeAware(['8.0' => 'mixed'], default: '')] $value
    ): void;

    /**
     * Offset to unset
     * @link https://php.net/manual/en/arrayaccess.offsetunset.php
     * @param TKey $offset 

     * The offset to unset.
     * 
     * @return void
     */
    #[TentativeType]
    public function offsetUnset(#[LanguageLevelTypeAware(['8.0' => 'mixed'], default: '')] $offset): void;
}

/**
 * Interface for customized serializing.

 * As of PHP 8.1.0, a class which implements Serializable without also implementing `__serialize()` and `__unserialize()`
 * will generate a deprecation warning.
 * @link https://php.net/manual/en/class.serializable.php
 */
interface Serializable
{
    /**
     * String representation of object.
     * @link https://php.net/manual/en/serializable.serialize.php
     * @return string|null The string representation of the object or null
     * @throws Exception Returning other type than string or null
     */
    public function serialize();

    /**
     * Constructs the object.
     * @link https://php.net/manual/en/serializable.unserialize.php
     * @param string $data The string representation of the object.
     * @return void
     */
    public function unserialize(#[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $data);
}

/**
 * Throwable is the base interface for any object that can be thrown via a throw statement in PHP 7,
 * including Error and Exception.
 * @link https://php.net/manual/en/class.throwable.php
 * @since 7.0
 */
interface Throwable extends Stringable
{
    /**
     * Gets the message
     * @link https://php.net/manual/en/throwable.getmessage.php
     * @return string
     * @since 7.0
     */
    public function getMessage(): string;

    /**
     * Gets the exception code
     * @link https://php.net/manual/en/throwable.getcode.php
     * @return int 

     * Returns the exception code as integer in
     * {@see Exception} but possibly as other type in
     * {@see Exception} descendants (for example as
     * string in {@see PDOException}).
     * 
     * @since 7.0
     */
    public function getCode();

    /**
     * Gets the file in which the exception occurred
     * @link https://php.net/manual/en/throwable.getfile.php
     * @return string Returns the name of the file from which the object was thrown.
     * @since 7.0
     */
    public function getFile(): string;

    /**
     * Gets the line on which the object was instantiated
     * @link https://php.net/manual/en/throwable.getline.php
     * @return int Returns the line number where the thrown object was instantiated.
     * @since 7.0
     */
    public function getLine(): int;

    /**
     * Gets the stack trace
     * @link https://php.net/manual/en/throwable.gettrace.php
     * @return array 

     * Returns the stack trace as an array in the same format as
     * {@see debug_backtrace()}.
     * 
     * @since 7.0
     */
    public function getTrace(): array;

    /**
     * Gets the stack trace as a string
     * @link https://php.net/manual/en/throwable.gettraceasstring.php
     * @return string Returns the stack trace as a string.
     * @since 7.0
     */
    public function getTraceAsString(): string;

    /**
     * Returns the previous Throwable
     * @link https://php.net/manual/en/throwable.getprevious.php
     * @return null|Throwable Returns the previous {@see Throwable} if available, or NULL otherwise.
     * @since 7.0
     */
    #[LanguageLevelTypeAware(['8.0' => 'Throwable|null'], default: '')]
    public function getPrevious();

    /**
     * Gets a string representation of the thrown object
     * @link https://php.net/manual/en/throwable.tostring.php
     * @return string 
Returns the string representation of the thrown object.
     * @since 7.0
     */
    public function __toString();
}

/**
 * Exception is the base class for
 * all Exceptions.
 * @link https://php.net/manual/en/class.exception.php
 */
class Exception implements Throwable
{
    /** The error message */
    protected $message;

    /** The error code */
    protected $code;

    /** The filename where the error happened  */
    #[LanguageLevelTypeAware(['8.1' => 'string'], default: '')]
    protected $file;

    /** The line where the error happened */
    #[LanguageLevelTypeAware(['8.1' => 'int'], default: '')]
    protected $line;

    /**
     * Clone the exception
     * Tries to clone the Exception, which results in Fatal error.
     * @link https://php.net/manual/en/exception.clone.php
     * @return void
     */
    #[PhpStormStubsElementAvailable(from: "5.4", to: "8.0")]
    final private function __clone(): void {}

    /**
     * Clone the exception
     * Tries to clone the Exception, which results in Fatal error.
     * @link https://php.net/manual/en/exception.clone.php
     * @return void
     */
    #[PhpStormStubsElementAvailable("8.1")]
    private function __clone(): void {}

    /**
     * Construct the exception. Note: The message is NOT binary safe.
     * @link https://php.net/manual/en/exception.construct.php
     * @param string $message [optional] The Exception message to throw.
     * @param int $code [optional] The Exception code.
     * @param null|Throwable $previous [optional] The previous throwable used for the exception chaining.
     */
    #[Pure]
    public function __construct(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $message = "",
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $code = 0,
        #[LanguageLevelTypeAware(['8.0' => 'Throwable|null'], default: 'Throwable')] $previous = null
    ) {}

    /**
     * Gets the Exception message
     * @link https://php.net/manual/en/exception.getmessage.php
     * @return string the Exception message as a string.
     */
    #[Pure]
    final public function getMessage(): string {}

    /**
     * Gets the Exception code
     * @link https://php.net/manual/en/exception.getcode.php
     * @return mixed|int the exception code as integer in
     * Exception but possibly as other type in
     * Exception descendants (for example as
     * string in PDOException).
     */
    #[Pure]
    final public function getCode() {}

    /**
     * Gets the file in which the exception occurred
     * @link https://php.net/manual/en/exception.getfile.php
     * @return string the filename in which the exception was created.
     */
    #[Pure]
    final public function getFile(): string {}

    /**
     * Gets the line in which the exception occurred
     * @link https://php.net/manual/en/exception.getline.php
     * @return int the line number where the exception was created.
     */
    #[Pure]
    final public function getLine(): int {}

    /**
     * Gets the stack trace
     * @link https://php.net/manual/en/exception.gettrace.php
     * @return array the Exception stack trace as an array.
     */
    #[Pure]
    final public function getTrace(): array {}

    /**
     * Returns previous Exception
     * @link https://php.net/manual/en/exception.getprevious.php
     * @return null|Throwable Returns the previous {@see Throwable} if available, or NULL otherwise.
     * or null otherwise.
     */
    #[Pure]
    final public function getPrevious(): ?Throwable {}

    /**
     * Gets the stack trace as a string
     * @link https://php.net/manual/en/exception.gettraceasstring.php
     * @return string the Exception stack trace as a string.
     */
    #[Pure]
    final public function getTraceAsString(): string {}

    /**
     * String representation of the exception
     * @link https://php.net/manual/en/exception.tostring.php
     * @return string the string representation of the exception.
     */
    #[TentativeType]
    public function __toString(): string {}

    #[TentativeType]
    public function __wakeup(): void {}
}

/**
 * Error is the base class for all internal PHP error exceptions.
 * @link https://php.net/manual/en/class.error.php
 * @since 7.0
 */
class Error implements Throwable
{
    /** The error message */
    protected $message;

    /** The error code */
    protected $code;

    /** The filename where the error happened  */
    #[LanguageLevelTypeAware(['8.1' => 'string'], default: '')]
    protected $file;

    /** The line where the error happened */
    #[LanguageLevelTypeAware(['8.1' => 'int'], default: '')]
    protected $line;

    /**
     * Construct the error object.
     * @link https://php.net/manual/en/error.construct.php
     * @param string $message [optional] The Error message to throw.
     * @param int $code [optional] The Error code.
     * @param null|Throwable $previous [optional] The previous throwable used for the exception chaining.
     */
    #[Pure]
    public function __construct(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $message = "",
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $code = 0,
        #[LanguageLevelTypeAware(['8.0' => 'Throwable|null'], default: 'Throwable')] $previous = null
    ) {}

    /***
     * Gets the message
     * @link https://php.net/manual/en/throwable.getmessage.php
     * @return string
     * @since 7.0
     */
    final public function getMessage(): string {}

    /**
     * Gets the exception code
     * @link https://php.net/manual/en/throwable.getcode.php
     * @return int 

     * Returns the exception code as integer in
     * {@see Exception} but possibly as other type in
     * {@see Exception} descendants (for example as
     * string in {@see PDOException}).
     * 
     * @since 7.0
     */
    final public function getCode() {}

    /**
     * Gets the file in which the exception occurred
     * @link https://php.net/manual/en/throwable.getfile.php
     * @return string Returns the name of the file from which the object was thrown.
     * @since 7.0
     */
    final public function getFile(): string {}

    /**
     * Gets the line on which the object was instantiated
     * @link https://php.net/manual/en/throwable.getline.php
     * @return int Returns the line number where the thrown object was instantiated.
     * @since 7.0
     */
    final public function getLine(): int {}

    /**
     * Gets the stack trace
     * @link https://php.net/manual/en/throwable.gettrace.php
     * @return array 

     * Returns the stack trace as an array in the same format as
     * {@see debug_backtrace()}.
     * 
     * @since 7.0
     */
    final public function getTrace(): array {}

    /**
     * Gets the stack trace as a string
     * @link https://php.net/manual/en/throwable.gettraceasstring.php
     * @return string Returns the stack trace as a string.
     * @since 7.0
     */
    final public function getTraceAsString(): string {}

    /**
     * Returns the previous Throwable
     * @link https://php.net/manual/en/throwable.getprevious.php
     * @return null|Throwable Returns the previous {@see Throwable} if available, or NULL otherwise.
     * @since 7.0
     */
    final public function getPrevious(): ?Throwable {}

    /**
     * Gets a string representation of the thrown object
     * @link https://php.net/manual/en/throwable.tostring.php
     * @return string 
Returns the string representation of the thrown object.
     * @since 7.0
     */
    public function __toString(): string {}

    /**
     * Clone the error
     * Error can not be clone, so this method results in fatal error.
     * @return void
     * @link https://php.net/manual/en/error.clone.php
     */
    #[PhpStormStubsElementAvailable(from: "7.0", to: "8.0")]
    final private function __clone(): void {}

    /**
     * Clone the error
     * Error can not be clone, so this method results in fatal error.
     * @return void
     * @link https://php.net/manual/en/error.clone.php
     */
    #[PhpStormStubsElementAvailable('8.1')]
    private function __clone(): void {}

    #[TentativeType]
    public function __wakeup(): void {}
}

class ValueError extends Error {}

/**
 * There are three scenarios where a TypeError may be thrown.
 * The first is where the argument type being passed to a function does not match its corresponding declared
 * parameter type. The second is where a value being returned from a function does not match the declared function return type. The third is where an
 * invalid number of arguments are passed to a built-in PHP function (strict mode only).
 * @link https://php.net/manual/en/class.typeerror.php
 * @since 7.0
 */
class TypeError extends Error {}

/**
 * ParseError is thrown when an error occurs while parsing PHP code, such as when {@see eval()} is called.
 * @link https://php.net/manual/en/class.parseerror.php
 * @since 7.0
 */
class ParseError extends CompileError {}

/**
 * ArgumentCountError is thrown when too few arguments are passed to a user
 * defined routine.
 *
 * @since 7.1
 * @see https://php.net/migration71.incompatible#migration71.incompatible.too-few-arguments-exception
 */
class ArgumentCountError extends TypeError {}

/**
 * ArithmeticError is thrown when an error occurs while performing mathematical operations.
 * In PHP 7.0, these errors include attempting to perform a bitshift by a negative amount,
 * and any call to {@see intdiv()} that would result in a value outside the possible bounds of an integer.
 * @link https://php.net/manual/en/class.arithmeticerror.php
 * @since 7.0
 */
class ArithmeticError extends Error {}

/**
 * Class CompileError
 * @link https://secure.php.net/manual/en/class.compileerror.php
 * @since 7.3
 */
class CompileError extends Error {}

/**
 * DivisionByZeroError is thrown when an attempt is made to divide a number by zero.
 * @link https://php.net/manual/en/class.divisionbyzeroerror.php
 * @since 7.0
 */
class DivisionByZeroError extends ArithmeticError {}

/**
 * @since 8.0
 */
class UnhandledMatchError extends Error {}

/**
 * @since 8.4
 */
class RequestParseBodyException extends Exception {}

/**
 * An Error Exception.
 * @link https://php.net/manual/en/class.errorexception.php
 */
class ErrorException extends Exception
{
    #[LanguageLevelTypeAware(['8.1' => 'int'], default: '')]
    protected $severity;

    /**
     * Constructs the exception
     * @link https://php.net/manual/en/errorexception.construct.php
     * @param string $message [optional] The Exception message to throw.
     * @param int $code [optional] The Exception code.
     * @param int $severity [optional] The severity level of the exception.
     * @param string $filename [optional] The filename where the exception is thrown.
     * @param int $line [optional] The line number where the exception is thrown.
     * @param Exception $previous [optional] The previous exception used for the exception chaining.
     */
    #[Pure]
    public function __construct(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $message = "",
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $code = 0,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $severity = 1,
        #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: '')] $filename = null,
        #[LanguageLevelTypeAware(['8.0' => 'int|null'], default: '')] $line = null,
        #[LanguageLevelTypeAware(['8.0' => 'Throwable|null'], default: 'Throwable')] $previous = null
    ) {}

    /**
     * Gets the exception severity
     * @link https://php.net/manual/en/errorexception.getseverity.php
     * @return int the severity level of the exception.
     */
    final public function getSeverity(): int {}
}

/**
 * Class used to represent anonymous functions.
 * 
Anonymous functions, implemented in PHP 5.3, yield objects of this type.
 * This fact used to be considered an implementation detail, but it can now be relied upon.
 * Starting with PHP 5.4, this class has methods that allow further control of the anonymous function after it has been created.
 * 
Besides the methods listed here, this class also has an __invoke method.
 * This is for consistency with other classes that implement calling magic, as this method is not used for calling the function.
 * @link https://secure.php.net/manual/en/class.closure.php
 */
final class Closure
{
    /**
     * This method exists only to disallow instantiation of the Closure class.
     * Objects of this class are created in the fashion described on the anonymous functions page.
     * @link https://secure.php.net/manual/en/closure.construct.php
     */
    private function __construct() {}

    /**
     * This is for consistency with other classes that implement calling magic,
     * as this method is not used for calling the function.
     * @param mixed ...$_ [optional]
     * @return mixed
     * @link https://secure.php.net/manual/en/class.closure.php
     */
    public function __invoke(...$_) {}

    /**
     * Duplicates the closure with a new bound object and class scope
     * @link https://secure.php.net/manual/en/closure.bindto.php
     * @param object|null $newThis The object to which the given anonymous function should be bound, or NULL for the closure to be unbound.
     * @param object|class-string|null $newScope The class scope to which associate the closure is to be associated, or 'static' to keep the current one.
     * If an object is given, the type of the object will be used instead.
     * This determines the visibility of protected and private methods of the bound object.
     * @return Closure|null Returns the newly created Closure object or null on failure
     */
    #[Pure]
    public function bindTo(?object $newThis, object|string|null $newScope = 'static'): ?Closure {}

    /**
     * This method is a static version of Closure::bindTo().
     * See the documentation of that method for more information.
     * @link https://secure.php.net/manual/en/closure.bind.php
     * @param Closure $closure The anonymous functions to bind.
     * @param object|null $newThis The object to which the given anonymous function should be bound, or NULL for the closure to be unbound.
     * @param object|class-string|null $newScope The class scope to which associate the closure is to be associated, or 'static' to keep the current one.
     * If an object is given, the type of the object will be used instead.
     * This determines the visibility of protected and private methods of the bound object.
     * @return Closure|null Returns the newly created Closure object or null on failure
     */
    #[Pure]
    public static function bind(Closure $closure, ?object $newThis, object|string|null $newScope = 'static'): ?Closure {}

    /**
     * Temporarily binds the closure to newthis, and calls it with any given parameters.
     * @link https://php.net/manual/en/closure.call.php
     * @param object $newThis The object to bind the closure to for the duration of the call.
     * @param mixed $args [optional] Zero or more parameters, which will be given as parameters to the closure.
     * @return mixed
     * @since 7.0
     */
    public function call(object $newThis, mixed ...$args): mixed {}

    /**
     * @param callable $callback
     * @return Closure
     * @since 7.1
     */
    public static function fromCallable(callable $callback): Closure {}
}

/**
 * Classes implementing Countable can be used with the
 * count function.
 * @link https://php.net/manual/en/class.countable.php
 */
interface Countable
{
    /**
     * Count elements of an object
     * @link https://php.net/manual/en/countable.count.php
     * @return int<0,max> The custom count as an integer.
     * 

     * The return value is cast to an integer.
     * 
     */
    #[TentativeType]
    public function count(): int;
}

/**
 * Weak references allow the programmer to retain a reference to an
 * object which does not prevent the object from being destroyed.
 * They are useful for implementing cache like structures.
 * @template T of object
 * @link https://www.php.net/manual/en/class.weakreference.php
 * @since 7.4
 */
final class WeakReference
{
    /**
     * This method exists only to disallow instantiation of the WeakReference
     * class. Weak references are to be instantiated with the factory method
     * WeakReference::create().
     */
    public function __construct() {}

    /**
     * Create a new weak reference.
     * @link https://www.php.net/manual/en/weakreference.create.php
     * @template TIn of object
     * @param TIn $object Any object.
     * @return WeakReference The freshly instantiated object.
     * @since 7.4
     */
    #[Pure]
    public static function create(object $object): WeakReference {}

    /**
     * Gets a weakly referenced object. If the object has already been
     * destroyed, NULL is returned.
     * @link https://www.php.net/manual/en/weakreference.get.php
     * @return T|null
     * @since 7.4
     */
    #[Pure]
    public function get(): ?object {}
}

/**
 * Weak maps allow creating a map from objects to arbitrary values
 * (similar to SplObjectStorage) without preventing the objects that are used
 * as keys from being garbage collected. If an object key is garbage collected,
 * it will simply be removed from the map.
 *
 * @since 8.0
 *
 * @template TKey of object
 * @template TValue
 * @template-implements IteratorAggregate
 */
final class WeakMap implements ArrayAccess, Countable, IteratorAggregate
{
    /**
     * Returns {@see true} if the value for the object is contained in
     * the {@see WeakMap} and {@see false} instead.
     *
     * @param TKey $object Any object
     * @return bool
     */
    #[Pure]
    public function offsetExists($object): bool {}

    /**
     * Returns the existsing value by an object.
     *
     * @param TKey $object Any object
     * @return TValue Value associated with the key object
     */
    #[Pure]
    public function offsetGet($object): mixed {}

    /**
     * Sets a new value for an object.
     *
     * @param TKey $object Any object
     * @param TValue $value Any value
     * @return void
     */
    public function offsetSet($object, mixed $value): void {}

    /**
     * Force removes an object value from the {@see WeakMap} instance.
     *
     * @param TKey $object Any object
     * @return void
     */
    public function offsetUnset($object): void {}

    /**
     * Returns an iterator in the "[object => mixed]" format.
     *
     * @return Iterator
     */
    #[Pure]
    public function getIterator(): Iterator {}

    /**
     * Returns the number of items in the {@see WeakMap} instance.
     *
     * @return int<0,max>
     */
    #[Pure]
    public function count(): int {}
}

/**
 * Stringable interface denotes a class as having a __toString() method.
 *
 * @since 8.0
 */
interface Stringable
{
    /**
     * Magic method {@see https://www.php.net/manual/en/language.oop5.magic.php#object.tostring}
     * allows a class to decide how it will react when it is treated like a string.
     *
     * @return string Returns string representation of the object that
     * implements this interface (and/or "__toString" magic method).
     */
    public function __toString(): string;
}

/**
 * @since 8.0
 */
#[Attribute(Attribute::TARGET_CLASS)]
final class Attribute
{
    public int $flags;

    /**
     * Marks that attribute declaration is allowed only in classes.
     */
    public const TARGET_CLASS = 1;

    /**
     * Marks that attribute declaration is allowed only in functions.
     */
    public const TARGET_FUNCTION = 2;

    /**
     * Marks that attribute declaration is allowed only in class methods.
     */
    public const TARGET_METHOD = 4;

    /**
     * Marks that attribute declaration is allowed only in class properties.
     */
    public const TARGET_PROPERTY = 8;

    /**
     * Marks that attribute declaration is allowed only in class constants.
     */
    public const TARGET_CLASS_CONSTANT = 16;

    /**
     * Marks that attribute declaration is allowed only in function or method parameters.
     */
    public const TARGET_PARAMETER = 32;

    /**
     * Marks that attribute declaration is allowed anywhere.
     */
    public const TARGET_ALL = 63;

    /**
     * Notes that an attribute declaration in the same place is
     * allowed multiple times.
     */
    public const IS_REPEATABLE = 64;

    /**
     * @param int $flags A value in the form of a bitmask indicating the places
     * where attributes can be defined.
     */
    public function __construct(#[ExpectedValues(flagsFromClass: Attribute::class)] int $flags = self::TARGET_ALL) {}
}

/**
 * @since 8.0
 */
final class InternalIterator implements Iterator
{
    private function __construct() {}

    public function current(): mixed {}

    public function next(): void {}

    public function key(): mixed {}

    public function valid(): bool {}

    public function rewind(): void {}
}

/**
 * @since 8.1
 */
interface UnitEnum
{
    public readonly string $name;

    /**
     * @return static[]
     */
    #[Pure]
    public static function cases(): array;
}

/**
 * @since 8.1
 */
interface BackedEnum extends UnitEnum
{
    public readonly int|string $value;

    /**
     * Translates a string or int into the corresponding Enum
     * case, if any. If there is no matching case defined, it will throw a
     * ValueError.
     * @param int|string $value
     * @throws ValueError
     * @throws TypeError
     * @return static
     * @link https://www.php.net/manual/en/backedenum.from.php
     */
    #[Pure]
    public static function from(int|string $value): static;

    /**
     * Translates a string or int into the corresponding Enum
     * case, if any. If there is no matching case defined, it will return null.
     * @param int|string $value
     * @return static|null A case instance of this enumeration, or null if not
     * found.
     * @link https://www.php.net/manual/en/backedenum.tryfrom.php
     */
    #[Pure]
    public static function tryFrom(int|string $value): ?static;
}

/**
 * @since 8.1
 * @internal
 *
 * Internal interface to ensure precise type inference
 */
interface IntBackedEnum extends BackedEnum
{
    public readonly int $value;

    /**
     * @param int $value
     * @return static
     */
    #[Pure]
    public static function from(int $value): static;

    /**
     * @param int $value
     * @return static|null
     */
    #[Pure]
    public static function tryFrom(int $value): ?static;
}

/**
 * @since 8.1
 * @internal
 *
 * Internal interface to ensure precise type inference
 */
interface StringBackedEnum extends BackedEnum
{
    public readonly string $value;

    #[Pure]
    public static function from(string $value): static;

    #[Pure]
    public static function tryFrom(string $value): ?static;
}

/**
 * @since 8.1
 *
 * @template TStart
 * @template TResume
 * @template TReturn
 * @template TSuspend
 */
final class Fiber
{
    /**
     * @param callable $callback Function to invoke when starting the fiber.
     */
    public function __construct(callable $callback) {}

    /**
     * Starts execution of the fiber. Returns when the fiber suspends or terminates.
     *
     * @param TStart ...$args Arguments passed to fiber function.
     *
     * @return TSuspend|null Value from the first suspension point or NULL if the fiber returns.
     *
     * @throws FiberError If the fiber has already been started.
     * @throws Throwable If the fiber callable throws an uncaught exception.
     */
    public function start(mixed ...$args): mixed {}

    /**
     * Resumes the fiber, returning the given value from {@see Fiber::suspend()}.
     * Returns when the fiber suspends or terminates.
     *
     * @param TResume $value
     *
     * @return TSuspend|null Value from the next suspension point or NULL if the fiber returns.
     *
     * @throws FiberError If the fiber has not started, is running, or has terminated.
     * @throws Throwable If the fiber callable throws an uncaught exception.
     */
    public function resume(mixed $value = null): mixed {}

    /**
     * Throws the given exception into the fiber from {@see Fiber::suspend()}.
     * Returns when the fiber suspends or terminates.
     *
     * @param Throwable $exception
     *
     * @return TSuspend|null Value from the next suspension point or NULL if the fiber returns.
     *
     * @throws FiberError If the fiber has not started, is running, or has terminated.
     * @throws Throwable If the fiber callable throws an uncaught exception.
     */
    public function throw(Throwable $exception): mixed {}

    /**
     * @return bool True if the fiber has been started.
     */
    public function isStarted(): bool {}

    /**
     * @return bool True if the fiber is suspended.
     */
    public function isSuspended(): bool {}

    /**
     * @return bool True if the fiber is currently running.
     */
    public function isRunning(): bool {}

    /**
     * @return bool True if the fiber has completed execution (returned or threw).
     */
    public function isTerminated(): bool {}

    /**
     * @return TReturn Return value of the fiber callback. NULL is returned if the fiber does not have a return statement.
     *
     * @throws FiberError If the fiber has not terminated or the fiber threw an exception.
     */
    public function getReturn(): mixed {}

    /**
     * @return Fiber|null Returns the currently executing fiber instance or NULL if in {main}.
     */
    public static function getCurrent(): ?Fiber {}

    /**
     * Suspend execution of the fiber. The fiber may be resumed with {@see Fiber::resume()} or {@see Fiber::throw()}.
     *
     * Cannot be called from {main}.
     *
     * @param TSuspend $value Value to return from {@see Fiber::resume()} or {@see Fiber::throw()}.
     *
     * @return TResume Value provided to {@see Fiber::resume()}.
     *
     * @throws FiberError Thrown if not within a fiber (i.e., if called from {main}).
     * @throws Throwable Exception provided to {@see Fiber::throw()}.
     */
    public static function suspend(mixed $value = null): mixed {}
}

/**
 * @since 8.1
 */
final class FiberError extends Error
{
    public function __construct() {}
}

/**
 * @since 8.1
 */
#[Attribute(Attribute::TARGET_METHOD)]
final class ReturnTypeWillChange
{
    public function __construct() {}
}

/**
 * @since 8.2
 */
#[Attribute(Attribute::TARGET_CLASS)]
final class AllowDynamicProperties
{
    public function __construct() {}
}

/**
 * @since 8.2
 */
#[Attribute(Attribute::TARGET_PARAMETER)]
final class SensitiveParameter
{
    public function __construct() {}
}

/**
 * @since 8.2
 */
final class SensitiveParameterValue
{
    private readonly mixed $value;

    public function __construct(mixed $value) {}

    public function getValue(): mixed {}

    public function __debugInfo(): array {}
}

/**
 * @since 8.3
 */
#[Attribute(Attribute::TARGET_METHOD)]
final class Override
{
    public function __construct() {}
}

/**
 * @since 8.4
 */
#[Attribute(Attribute::TARGET_METHOD|Attribute::TARGET_FUNCTION|Attribute::TARGET_CLASS_CONSTANT)]
final class Deprecated
{
    public readonly ?string $message;
    public readonly ?string $since;

    public function __construct(?string $message = null, ?string $since = null) {}
}
set_error_handler), the application aborts as it
 * was an E_ERROR.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_RECOVERABLE_ERROR', 4096);

/**
 * Run-time warnings (non-fatal errors). Execution of the script is not
 * halted.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_WARNING', 2);

/**
 * Compile-time parse errors. Parse errors should only be generated by
 * the parser.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_PARSE', 4);

/**
 * Run-time notices. Indicate that the script encountered something that
 * could indicate an error, but could also happen in the normal course of
 * running a script.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_NOTICE', 8);

/**
 * Enable to have PHP suggest changes
 * to your code which will ensure the best interoperability
 * and forward compatibility of your code.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_STRICT', 2048);

/**
 * Run-time notices. Enable this to receive warnings about code
 * that will not work in future versions.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_DEPRECATED', 8192);

/**
 * Fatal errors that occur during PHP's initial startup. This is like an
 * E_ERROR, except it is generated by the core of PHP.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_CORE_ERROR', 16);

/**
 * Warnings (non-fatal errors) that occur during PHP's initial startup.
 * This is like an E_WARNING, except it is generated
 * by the core of PHP.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_CORE_WARNING', 32);

/**
 * Fatal compile-time errors. This is like an E_ERROR,
 * except it is generated by the Zend Scripting Engine.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_COMPILE_ERROR', 64);

/**
 * Compile-time warnings (non-fatal errors). This is like an
 * E_WARNING, except it is generated by the Zend
 * Scripting Engine.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_COMPILE_WARNING', 128);

/**
 * User-generated error message. This is like an
 * E_ERROR, except it is generated in PHP code by
 * using the PHP function trigger_error.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_USER_ERROR', 256);

/**
 * User-generated warning message. This is like an
 * E_WARNING, except it is generated in PHP code by
 * using the PHP function trigger_error.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_USER_WARNING', 512);

/**
 * User-generated notice message. This is like an
 * E_NOTICE, except it is generated in PHP code by
 * using the PHP function trigger_error.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_USER_NOTICE', 1024);

/**
 * User-generated warning message. This is like an
 * E_DEPRECATED, except it is generated in PHP code by
 * using the PHP function trigger_error.
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_USER_DEPRECATED', 16384);

/**
 * All errors and warnings, as supported, except of level
 * E_STRICT prior to PHP 5.4.0.
 * Value of E_ALL is 32767 since PHP 5.4.x,
 * 30719 in PHP 5.3.x, 6143 in PHP 5.2.x, 2047 previously
 * @link https://php.net/manual/en/errorfunc.constants.php
 */
define('E_ALL', 32767);
define('DEBUG_BACKTRACE_PROVIDE_OBJECT', 1);
define('DEBUG_BACKTRACE_IGNORE_ARGS', 2);
define('S_MEMORY', 1);
define('S_VARS', 4);
define('S_FILES', 8);
define('S_INCLUDE', 16);
define('S_SQL', 32);
define('S_EXECUTOR', 64);
define('S_MAIL', 128);
define('S_SESSION', 256);
define('S_MISC', 2);
define('S_INTERNAL', 536870912);
define('S_ALL', 511);

define('true', (bool)1, true);
define('false', (bool)0, true);
define('null', null, true);
define('ZEND_THREAD_SAFE', false);
define('ZEND_DEBUG_BUILD', false);
define('PHP_WINDOWS_VERSION_BUILD', 0);
define('PHP_WINDOWS_VERSION_MAJOR', 0);
define('PHP_WINDOWS_VERSION_MINOR', 0);
define('PHP_WINDOWS_VERSION_PLATFORM', 0);
define('PHP_WINDOWS_VERSION_PRODUCTTYPE', 0);
define('PHP_WINDOWS_VERSION_SP_MAJOR', 0);
define('PHP_WINDOWS_VERSION_SP_MINOR', 0);
define('PHP_WINDOWS_VERSION_SUITEMASK', 0);
define('PHP_WINDOWS_NT_DOMAIN_CONTROLLER', 2);
define('PHP_WINDOWS_NT_SERVER', 3);
define('PHP_WINDOWS_NT_WORKSTATION', 1);
/**
 * @since 7.4
 */
define('PHP_WINDOWS_EVENT_CTRL_C', 0);
/**
 * @since 7.4
 */
define('PHP_WINDOWS_EVENT_CTRL_BREAK', 1);
define('PHP_VERSION', "5.3.6-13ubuntu3.2");
define('PHP_MAJOR_VERSION', 5);
define('PHP_MINOR_VERSION', 3);
define('PHP_RELEASE_VERSION', 6);
define('PHP_EXTRA_VERSION', "-13ubuntu3.2");
define('PHP_VERSION_ID', 50306);
define('PHP_ZTS', 0);
define('PHP_DEBUG', 0);
define('PHP_OS', "Linux");
/**
 * The operating system family PHP was built for. Either of 'Windows', 'BSD', 'Darwin', 'Solaris', 'Linux' or 'Unknown'. Available as of PHP 7.2.0.
 * @since 7.2
 */
define('PHP_OS_FAMILY', "Linux");
define('PHP_SAPI', "cli");
/**
 * @since 7.4
 */
define('PHP_CLI_PROCESS_TITLE', 1);
define('DEFAULT_INCLUDE_PATH', ".:/usr/share/php:/usr/share/pear");
define('PEAR_INSTALL_DIR', "/usr/share/php");
define('PEAR_EXTENSION_DIR', "/usr/lib/php5/20090626");
define('PHP_EXTENSION_DIR', "/usr/lib/php5/20090626");
/**
 * Specifies where the binaries were installed into.
 * @link https://php.net/manual/en/reserved.constants.php
 */
define('PHP_BINARY', '/usr/local/php/bin/php');
define('PHP_PREFIX', "/usr");
define('PHP_BINDIR', "/usr/bin");
define('PHP_LIBDIR', "/usr/lib/php5");
define('PHP_DATADIR', "/usr/share");
define('PHP_SYSCONFDIR', "/etc");
define('PHP_LOCALSTATEDIR', "/var");
define('PHP_CONFIG_FILE_PATH', "/etc/php5/cli");
define('PHP_CONFIG_FILE_SCAN_DIR', "/etc/php5/cli/conf.d");
define('PHP_SHLIB_SUFFIX', "so");
define('PHP_EOL', "\n");
define('SUHOSIN_PATCH', 1);
define('SUHOSIN_PATCH_VERSION', "0.9.10");
define('PHP_MAXPATHLEN', 4096);
define('PHP_INT_MAX', 9223372036854775807);
define('PHP_INT_MIN', -9223372036854775808);
define('PHP_INT_SIZE', 8);
/**
 * Number of decimal digits that can be rounded into a float and back without precision loss. Available as of PHP 7.2.0.
 * @since 7.2
 */
define('PHP_FLOAT_DIG', 15);
/**
 * Smallest representable positive number x, so that x + 1.0 != 1.0. Available as of PHP 7.2.0.
 * @since 7.2
 */
define('PHP_FLOAT_EPSILON', 2.2204460492503e-16);

/**
 * Largest representable floating point number. Available as of PHP 7.2.0.
 * @since 7.2
 */
define('PHP_FLOAT_MAX', 1.7976931348623e+308);
/**
 * Smallest representable floating point number. Available as of PHP 7.2.0.
 * @since 7.2
 */
define('PHP_FLOAT_MIN', 2.2250738585072e-308);
define('ZEND_MULTIBYTE', 0);
define('PHP_OUTPUT_HANDLER_START', 1);
define('PHP_OUTPUT_HANDLER_CONT', 2);
define('PHP_OUTPUT_HANDLER_END', 4);
define('UPLOAD_ERR_OK', 0);
define('UPLOAD_ERR_INI_SIZE', 1);
define('UPLOAD_ERR_FORM_SIZE', 2);
define('UPLOAD_ERR_PARTIAL', 3);
define('UPLOAD_ERR_NO_FILE', 4);
define('UPLOAD_ERR_NO_TMP_DIR', 6);
define('UPLOAD_ERR_CANT_WRITE', 7);
define('UPLOAD_ERR_EXTENSION', 8);
define('STDIN', fopen('php://stdin', 'r'));
define('STDOUT', fopen('php://stdout', 'w'));
define('STDERR', fopen('php://stderr', 'w'));

define('PHP_FD_SETSIZE', 1024);

/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_WRITE', 0);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_FLUSH', 4);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_CLEAN', 2);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_FINAL', 8);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_CLEANABLE', 16);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_FLUSHABLE', 32);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_REMOVABLE', 64);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_STDFLAGS', 112);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_STARTED', 4096);
/** @link https://php.net/manual/en/outcontrol.constants.php */
define('PHP_OUTPUT_HANDLER_DISABLED', 8192);

/**
 * @since 8.4
 */
const PHP_SBINDIR = '/usr/local/sbin', PHP_OUTPUT_HANDLER_PROCESSED = 16384;

/**
 * Specifies where the manpages were installed into.
 * @since 5.3.7
 * @link https://php.net/manual/en/reserved.constants.php
 */
define('PHP_MANDIR', '/usr/local/php/php/man');

 * The argument offset. Function arguments are counted starting from
 * zero.
 * 

 * @return mixed|false the specified argument, or false on error.
 */
#[Pure]
function func_get_arg(int $position): mixed {}

/**
 * Returns an array comprising a function's argument list
 * @link https://php.net/manual/en/function.func-get-args.php
 * @return array an array in which each element is a copy of the corresponding
 * member of the current user-defined function's argument list.
 */
#[Pure]
function func_get_args(): array {}

/**
 * Get string length
 * @link https://php.net/manual/en/function.strlen.php
 * @param string $string 

 * The string being measured for length.
 * 
 * @return int<0,max> The length of the string on success,
 * and 0 if the string is empty.
 */
#[Pure]
function strlen(string $string): int {}

/**
 * Binary safe string comparison
 * @link https://php.net/manual/en/function.strcmp.php
 * @param string $string1 

 * The first string.
 * 
 * @param string $string2 

 * The second string.
 * 
 * @return int less 0 if str1 is less than
 * str2; > 0 if str1
 * is greater than str2, and 0 if they are
 * equal.
 */
#[Pure]
function strcmp(string $string1, string $string2): int {}

/**
 * Binary safe string comparison of the first n characters
 * @link https://php.net/manual/en/function.strncmp.php
 * @param string $string1 

 * The first string.
 * 
 * @param string $string2 

 * The second string.
 * 
 * @param int $length 

 * Number of characters to use in the comparison.
 * 
 * @return int less 0 if str1 is less than
 * str2; > 0 if str1
 * is greater than str2, and 0 if they are
 * equal.
 */
#[Pure]
function strncmp(string $string1, string $string2, int $length): int {}

/**
 * Binary safe case-insensitive string comparison
 * @link https://php.net/manual/en/function.strcasecmp.php
 * @param string $string1 

 * The first string
 * 
 * @param string $string2 

 * The second string
 * 
 * @return int less than 0 if str1 is less than
 * str2; > 0 if str1
 * is greater than str2, and 0 if they are
 * equal.
 */
#[Pure]
function strcasecmp(string $string1, string $string2): int {}

/**
 * Binary safe case-insensitive string comparison of the first n characters
 * @link https://php.net/manual/en/function.strncasecmp.php
 * @param string $string1 

 * The first string.
 * 
 * @param string $string2 

 * The second string.
 * 
 * @param int $length 

 * The length of strings to be used in the comparison.
 * 
 * @return int less than 0 if str1 is less than
 * str2; > 0 if str1 is
 * greater than str2, and 0 if they are equal.
 */
#[Pure]
function strncasecmp(string $string1, string $string2, int $length): int {}

/**
 * The function returns {@see true} if the passed $haystack starts from the
 * $needle string or {@see false} otherwise.
 *
 * @param string $haystack
 * @param string $needle
 * @return bool
 * @since 8.0
 */
#[Pure]
function str_starts_with(string $haystack, string $needle): bool {}

/**
 * The function returns {@see true} if the passed $haystack ends with the
 * $needle string or {@see false} otherwise.
 *
 * @param string $haystack
 * @param string $needle
 * @return bool
 * @since 8.0
 */
#[Pure]
function str_ends_with(string $haystack, string $needle): bool {}

/**
 * Checks if $needle is found in $haystack and returns a boolean value
 * (true/false) whether or not the $needle was found.
 *
 * @param string $haystack
 * @param string $needle
 * @return bool
 * @since 8.0
 */
#[Pure]
function str_contains(string $haystack, string $needle): bool {}

/**
 * @since 8.3
 */
function str_decrement(string $string): string {}

/**
 * @since 8.3
 */
function str_increment(string $string): string {}

/**
 * Return the current key and value pair from an array and advance the array cursor
 * @link https://php.net/manual/en/function.each.php
 * @param array|ArrayObject &$array 

 * The input array.
 * 
 * @return array the current key and value pair from the array
 * array. This pair is returned in a four-element
 * array, with the keys 0, 1,
 * key, and value. Elements
 * 0 and key contain the key name of
 * the array element, and 1 and value
 * contain the data.
 * 

 * 

 * If the internal pointer for the array points past the end of the
 * array contents, each returns
 * false.
 * @removed 8.0
 */
#[Deprecated(reason: "Use a foreach loop instead", since: "7.2")]
function each(&$array): array {}

/**
 * Sets which PHP errors are reported
 * @link https://php.net/manual/en/function.error-reporting.php
 * @param int|null $error_level [optional] 

 * The new error_reporting
 * level. It takes on either a bitmask, or named constants. Using named
 * constants is strongly encouraged to ensure compatibility for future
 * versions. As error levels are added, the range of integers increases,
 * so older integer-based error levels will not always behave as expected.
 * 
 * 

 * The available error level constants and the actual
 * meanings of these error levels are described in the
 * predefined constants.
 * 
 * error_reporting level constants and bit values
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
value
constant
1

 * E_ERROR
 * 
2

 * E_WARNING
 * 
4

 * E_PARSE
 * 
8

 * E_NOTICE
 * 
16

 * E_CORE_ERROR
 * 
32

 * E_CORE_WARNING
 * 
64

 * E_COMPILE_ERROR
 * 
128

 * E_COMPILE_WARNING
 * 
256

 * E_USER_ERROR
 * 
512

 * E_USER_WARNING
 * 
1024

 * E_USER_NOTICE
 * 
32767

 * E_ALL
 * 
2048

 * E_STRICT
 * 
4096

 * E_RECOVERABLE_ERROR
 * 
8192

 * E_DEPRECATED
 * 
16384

 * E_USER_DEPRECATED
 * 
 * 
 * @return int the old error_reporting
 * level or the current level if no level parameter is
 * given.
 */
function error_reporting(?int $error_level): int {}

/**
 * Defines a named constant
 * @link https://php.net/manual/en/function.define.php
 * @param string $constant_name 

 * The name of the constant.
 * 
 * @param null|array|bool|int|float|string $value 

 * The value of the constant.
 * In PHP 5, value must be a scalar value (integer, float, string, boolean, or null).
 * In PHP 7, array values are also accepted.
 * It is possible to define resource constants,
 * however it is not recommended and may cause unpredictable behavior.
 * 
 * @param bool $case_insensitive [optional] 

 * If set to true, the constant will be defined case-insensitive.
 * The default behavior is case-sensitive; i.e.
 * CONSTANT and Constant represent
 * different values.
 * Defining case-insensitive constants is deprecated as of PHP 7.3.0.
 * 
 * 

 * Case-insensitive constants are stored as lower-case.
 * 
 * @return bool true on success or false on failure.
 */
function define(
    string $constant_name,
    #[LanguageLevelTypeAware(['8.1' => 'mixed'], default: 'null|array|bool|int|float|string')] $value,
    #[Deprecated(since: "7.3")] bool $case_insensitive = false
): bool {}

/**
 * Checks whether a given named constant exists
 * @link https://php.net/manual/en/function.defined.php
 * @param string $constant_name 

 * The constant name.
 * 
 * @return bool true if the named constant given by name
 * has been defined, false otherwise.
 */
#[Pure(true)]
function defined(string $constant_name): bool {}

/**
 * Returns the name of the class of an object
 * @link https://php.net/manual/en/function.get-class.php
 * @param object $object [optional] 

 * The tested object. This parameter may be omitted when inside a class.
 * 
 * @return string 
The name of the class of which object is an
 * instance.
 * If object is omitted when inside a class, the
 * name of that class is returned.
 */
#[Pure]
function get_class(object $object): string {}

/**
 * the "Late Static Binding" class name
 * @link https://php.net/manual/en/function.get-called-class.php
 * @return string
 */
#[Pure]
function get_called_class(): string {}

/**
 * Retrieves the parent class name for object or class
 * @link https://php.net/manual/en/function.get-parent-class.php
 * @param object|string $object_or_class [optional] 

 * The tested object or class name
 * 
 * @return string|false 
The name of the parent class of the class of which
 * object is an instance or the name.
 * 
 * 

 * If the object does not have a parent false will be returned.
 * 
 * 

 * If called without parameter outside object, this function returns false.
 */
#[Pure]
function get_parent_class(object|string $object_or_class): string|false {}

/**
 * Checks if the class method exists
 * @link https://php.net/manual/en/function.method-exists.php
 * @param object|string $object_or_class 

 * An object instance or a class name
 * 
 * @param string $method 

 * The method name
 * 
 * @return bool true if the method given by method_name
 * has been defined for the given object, false
 * otherwise.
 */
#[Pure]
function method_exists($object_or_class, string $method): bool {}

/**
 * Checks if the object or class has a property
 * @link https://php.net/manual/en/function.property-exists.php
 * @param object|string $object_or_class 

 * The class name or an object of the class to test for
 * 
 * @param string $property 

 * The name of the property
 * 
 * @return bool true if the property exists, false if it doesn't exist or
 * null in case of an error.
 */
#[Pure]
function property_exists($object_or_class, string $property): bool {}

/**
 * Checks if the trait exists
 * @param string $trait Name of the trait to check
 * @param bool $autoload [optional] Whether to autoload if not already loaded.
 * @return bool Returns TRUE if trait exists, FALSE if not, NULL in case of an error.
 * @link https://secure.php.net/manual/en/function.trait-exists.php
 * @since 5.4
 */
function trait_exists(string $trait, bool $autoload = true): bool {}

/**
 * Checks if the class has been defined
 * @link https://php.net/manual/en/function.class-exists.php
 * @param string $class 

 * The class name. The name is matched in a case-insensitive manner.
 * 
 * @param bool $autoload [optional] 

 * Whether or not to call autoload by default.
 * 
 * @return bool true if class_name is a defined class,
 * false otherwise.
 */
function class_exists(string $class, bool $autoload = true): bool {}

/**
 * Checks if the interface has been defined
 * @link https://php.net/manual/en/function.interface-exists.php
 * @param string $interface 

 * The interface name
 * 
 * @param bool $autoload [optional] 

 * Whether to call autoload or not by default.
 * 
 * @return bool true if the interface given by
 * interface_name has been defined, false otherwise.
 * @since 5.0.2
 */
function interface_exists(string $interface, bool $autoload = true): bool {}

/**
 * Return true if the given function has been defined
 * @link https://php.net/manual/en/function.function-exists.php
 * @param string $function 

 * The function name, as a string.
 * 
 * @return bool true if function_name exists and is a
 * function, false otherwise.
 * 

 * 

 * This function will return false for constructs, such as
 * include_once and echo.
 */
#[Pure(true)]
function function_exists(string $function): bool {}

/**
 * Checks if the enum has been defined
 * @link https://php.net/manual/en/function.enum-exists.php
 * @param string $enum 

 * The enum name. The name is matched in a case-insensitive manner.
 * 
 * @param bool $autoload [optional] 

 * Whether or not to call autoload by default.
 * 
 * @return bool true if enum is a defined enum,
 * false otherwise.
 * @since 8.1
 */
function enum_exists(string $enum, bool $autoload = true): bool {}

/**
 * Creates an alias for a class
 * @link https://php.net/manual/en/function.class-alias.php
 * @param string $class The original class.
 * @param string $alias The alias name for the class.
 * @param bool $autoload [optional] Whether to autoload if the original class is not found.
 * @return bool true on success or false on failure.
 */
function class_alias(string $class, string $alias, bool $autoload = true): bool {}

/**
 * Returns an array with the names of included or required files
 * @link https://php.net/manual/en/function.get-included-files.php
 * @return string[] an array of the names of all files.
 * 

 * The script originally called is considered an "included file," so it will
 * be listed together with the files referenced by
 * include and family.
 * 
 * 

 * Files that are included or required multiple times only show up once in
 * the returned array.
 * 
 */
#[Pure(true)]
function get_included_files(): array {}

/**
 * Alias of get_included_files
 * @link https://php.net/manual/en/function.get-required-files.php
 * @return string[]
 */
#[Pure(true)]
function get_required_files(): array {}

/**
 * checks if the object has this class as one of its parents or implements it
 * @link https://php.net/manual/en/function.is-subclass-of.php
 * @param object|string $object_or_class 

 * A class name or an object instance
 * 
 * @param string $class 

 * The class name
 * 
 * @param bool $allow_string [optional] 

 * If this parameter set to false, string class name as object is not allowed.
 * This also prevents from calling autoloader if the class doesn't exist.
 * 
 * @return bool This function returns true if the object object,
 * belongs to a class which is a subclass of
 * class_name, false otherwise.
 */
#[Pure]
function is_subclass_of(mixed $object_or_class, string $class, bool $allow_string = true): bool {}

/**
 * Checks if the object is of this class or has this class as one of its parents
 * @link https://php.net/manual/en/function.is-a.php
 * @param object|string $object_or_class 

 * The tested object
 * 
 * @param string $class 

 * The class name
 * 
 * @param bool $allow_string [optional] 

 * If this parameter set to FALSE, string class name as object
 * is not allowed. This also prevents from calling autoloader if the class doesn't exist.
 * 
 * @return bool TRUE if the object is of this class or has this class as one of
 * its parents, FALSE otherwise.
 */
#[Pure]
function is_a(mixed $object_or_class, string $class, bool $allow_string = false): bool {}

/**
 * Get the default properties of the class
 * @link https://php.net/manual/en/function.get-class-vars.php
 * @param string $class 

 * The class name
 * 
 * @return array an associative array of declared properties visible from the
 * current scope, with their default value.
 * The resulting array elements are in the form of
 * varname => value.
 */
#[Pure]
function get_class_vars(string $class): array {}

/**
 * Gets the properties of the given object
 * @link https://php.net/manual/en/function.get-object-vars.php
 * @param object $object 

 * An object instance.
 * 
 * @return array an associative array of defined object accessible non-static properties
 * for the specified object in scope. If a property have
 * not been assigned a value, it will be returned with a null value.
 */
#[Pure]
function get_object_vars(object $object): array {}

/**
 * Gets the class methods' names
 * @link https://php.net/manual/en/function.get-class-methods.php
 * @param object|string $object_or_class 

 * The class name or an object instance
 * 
 * @return string[] an array of method names defined for the class specified by
 * class_name. In case of an error, it returns null.
 */
#[Pure]
function get_class_methods(object|string $object_or_class): array {}

/**
 * Generates a user-level error/warning/notice message
 * @link https://php.net/manual/en/function.trigger-error.php
 * @param string $message 

 * The designated error message for this error. It's limited to 1024
 * characters in length. Any additional characters beyond 1024 will be
 * truncated.
 * 
 * @param int $error_level [optional] 

 * The designated error type for this error. It only works with the E_USER
 * family of constants, and will default to E_USER_NOTICE.
 * 
 * @return bool This function returns false if wrong error_type is
 * specified, true otherwise.
 */
#[LanguageLevelTypeAware(['8.4' => 'true'], default: 'bool')]
function trigger_error(string $message, int $error_level = E_USER_NOTICE) {}

/**
 * Alias of trigger_error
 * @link https://php.net/manual/en/function.user-error.php
 * @param string $message
 * @param int $error_level [optional]
 * @return bool This function returns false if wrong error_type is
 * specified, true otherwise.
 */
#[LanguageLevelTypeAware(['8.4' => 'true'], default: 'bool')]
function user_error(string $message, int $error_level = E_USER_NOTICE) {}

/**
 * Sets a user-defined error handler function
 * @link https://php.net/manual/en/function.set-error-handler.php
 * @param callable|null $callback 

 * The user function needs to accept two parameters: the error code, and a
 * string describing the error. Then there are three optional parameters
 * that may be supplied: the filename in which the error occurred, the
 * line number in which the error occurred, and the context in which the
 * error occurred (an array that points to the active symbol table at the
 * point the error occurred). The function can be shown as:
 * 
 * 

 * handler
 * interrno
 * stringerrstr
 * stringerrfile
 * interrline
 * arrayerrcontext
 * errno
 * The first parameter, errno, contains the
 * level of the error raised, as an integer.
 * The user function should stop execution if necessary by calling `exit()`.
 * If the function returns a value other than false, script execution will
 * continue with the next statement after the one that caused an error.
 * If the function returns false, the standard PHP error handler is called.
 * @param int $error_levels [optional] 

 * Can be used to mask the triggering of the
 * error_handler function just like the error_reporting ini setting
 * controls which errors are shown. Without this mask set the
 * error_handler will be called for every error
 * regardless to the setting of the error_reporting setting.
 * 
 * @return callable|null a string containing the previously defined error handler (if any). If
 * the built-in error handler is used null is returned. null is also returned
 * in case of an error such as an invalid callback. If the previous error handler
 * was a class method, this function will return an indexed array with the class
 * and the method name.
 *
 * Note that error_handler chaining is possible by passing the output value as a reference:
 * ```
 * $previousErrorHandler = set_error_handler(
 *     static function (int $errNo, string $errstr, string $errFile, int $errLine) use (&$previousErrorHandler): bool {
 *         // Handle specific scenarios
 *
 *         return $previousErrorHandler !== null ? (bool) $previousErrorHandler(...func_get_args()) : false;
 *     }
 * );
 * ```
 */
function set_error_handler(?callable $callback, int $error_levels = E_ALL|E_STRICT) {}

/**
 * Restores the previous error handler function
 * @link https://php.net/manual/en/function.restore-error-handler.php
 * @return bool This function always returns true.
 */
#[LanguageLevelTypeAware(['8.2' => 'true'], default: 'bool')]
function restore_error_handler(): bool {}

/**
 * Sets a user-defined exception handler function
 * @link https://php.net/manual/en/function.set-exception-handler.php
 * @param callable|null $callback 

 * Name of the function to be called when an uncaught exception occurs.
 * This function must be defined before calling
 * set_exception_handler. This handler function
 * needs to accept one parameter, which will be the exception object that
 * was thrown.
 * NULL may be passed instead, to reset this handler to its default state.
 * 
 * @return callable|null the name of the previously defined exception handler, or null on error. If
 * no previous handler was defined, null is also returned.
 */
function set_exception_handler(?callable $callback) {}

/**
 * Restores the previously defined exception handler function
 * @link https://php.net/manual/en/function.restore-exception-handler.php
 * @return bool This function always returns true.
 */
#[LanguageLevelTypeAware(['8.2' => 'true'], default: 'bool')]
function restore_exception_handler(): bool {}

/**
 * Returns an array with the name of the defined classes
 * @link https://php.net/manual/en/function.get-declared-classes.php
 * @return string[] an array of the names of the declared classes in the current script.
 * 

 * Note that depending on what extensions you have compiled or
 * loaded into PHP, additional classes could be present. This means that
 * you will not be able to define your own classes using these
 * names. There is a list of predefined classes in the Predefined Classes section of
 * the appendices.
 * 
 */
#[Pure(true)]
function get_declared_classes(): array {}

/**
 * Returns an array of all declared interfaces
 * @link https://php.net/manual/en/function.get-declared-interfaces.php
 * @return string[] an array of the names of the declared interfaces in the current
 * script.
 */
#[Pure(true)]
function get_declared_interfaces(): array {}

/**
 * Returns an array of all declared traits
 * @return array with names of all declared traits in values. Returns NULL in case of a failure.
 * @link https://secure.php.net/manual/en/function.get-declared-traits.php
 * @see class_uses()
 * @since 5.4
 */
#[Pure(true)]
function get_declared_traits(): array {}

/**
 * Returns an array of all defined functions
 * @link https://php.net/manual/en/function.get-defined-functions.php
 * @param bool $exclude_disabled [optional] Whether disabled functions should be excluded from the return value.
 * @return array an multidimensional array containing a list of all defined
 * functions, both built-in (internal) and user-defined. The internal
 * functions will be accessible via $arr["internal"], and
 * the user defined ones using $arr["user"] (see example
 * below).
 */
#[Pure(true)]
function get_defined_functions(#[PhpStormStubsElementAvailable(from: '7.1')] bool $exclude_disabled = true): array {}

/**
 * Returns an array of all defined variables
 * @link https://php.net/manual/en/function.get-defined-vars.php
 * @return array A multidimensional array with all the variables.
 */
#[Pure(true)]
function get_defined_vars(): array {}

/**
 * Create an anonymous (lambda-style) function
 * @link https://php.net/manual/en/function.create-function.php
 * @param string $args 

 * The function arguments.
 * 
 * @param string $code 

 * The function code.
 * 
 * @return string|false a unique function name as a string, or false on error.
 * @removed 8.0
 */
#[Deprecated(reason: "Use anonymous functions instead", since: "7.2")]
function create_function(string $args, string $code): false|string {}

/**
 * Returns the resource type
 * @link https://php.net/manual/en/function.get-resource-type.php
 * @param resource $resource 

 * The evaluated resource handle.
 * 
 * @return string If the given handle is a resource, this function
 * will return a string representing its type. If the type is not identified
 * by this function, the return value will be the string
 * Unknown.
 */
function get_resource_type($resource): string {}

/**
 * Returns an array with the names of all modules compiled and loaded
 * @link https://php.net/manual/en/function.get-loaded-extensions.php
 * @param bool $zend_extensions [optional] 

 * Only return Zend extensions, if not then regular extensions, like
 * mysqli are listed. Defaults to false (return regular extensions).
 * 
 * @return string[] an indexed array of all the modules names.
 */
#[Pure]
function get_loaded_extensions(bool $zend_extensions = false): array {}

/**
 * Find out whether an extension is loaded
 * @link https://php.net/manual/en/function.extension-loaded.php
 * @param string $extension 

 * The extension name.
 * 
 * 

 * You can see the names of various extensions by using
 * phpinfo or if you're using the
 * CGI or CLI version of
 * PHP you can use the -m switch to
 * list all available extensions:
 * 
 * $ php -m
 * [PHP Modules]
 * xml
 * tokenizer
 * standard
 * sockets
 * session
 * posix
 * pcre
 * overload
 * mysql
 * mbstring
 * ctype
 * [Zend Modules]
 * 
 * 

 * @return bool true if the extension identified by name
 * is loaded, false otherwise.
 */
#[Pure]
function extension_loaded(string $extension): bool {}

/**
 * Returns an array with the names of the functions of a module
 * @link https://php.net/manual/en/function.get-extension-funcs.php
 * @param string $extension 

 * The module name.
 * 
 * 

 * This parameter must be in lowercase.
 * 
 * @return string[]|false an array with all the functions, or false if
 * module_name is not a valid extension.
 */
#[Pure]
function get_extension_funcs(string $extension): array|false {}

/**
 * Returns an associative array with the names of all the constants and their values
 * @link https://php.net/manual/en/function.get-defined-constants.php
 * @param bool $categorize [optional] 

 * Causing this function to return a multi-dimensional
 * array with categories in the keys of the first dimension and constants
 * and their values in the second dimension.
 * 
 * define("MY_CONSTANT", 1);
 * print_r(get_defined_constants(true));
 * 
 * The above example will output something similar to:
 * 
 * Array
 * (
 * [Core] => Array
 * (
 * [E_ERROR] => 1
 * [E_WARNING] => 2
 * [E_PARSE] => 4
 * [E_NOTICE] => 8
 * [E_CORE_ERROR] => 16
 * [E_CORE_WARNING] => 32
 * [E_COMPILE_ERROR] => 64
 * [E_COMPILE_WARNING] => 128
 * [E_USER_ERROR] => 256
 * [E_USER_WARNING] => 512
 * [E_USER_NOTICE] => 1024
 * [E_STRICT] => 2048
 * [E_RECOVERABLE_ERROR] => 4096
 * [E_DEPRECATED] => 8192
 * [E_USER_DEPRECATED] => 16384
 * [E_ALL] => 32767
 * [TRUE] => 1
 * )
 * [pcre] => Array
 * (
 * [PREG_PATTERN_ORDER] => 1
 * [PREG_SET_ORDER] => 2
 * [PREG_OFFSET_CAPTURE] => 256
 * [PREG_SPLIT_NO_EMPTY] => 1
 * [PREG_SPLIT_DELIM_CAPTURE] => 2
 * [PREG_SPLIT_OFFSET_CAPTURE] => 4
 * [PREG_GREP_INVERT] => 1
 * )
 * [user] => Array
 * (
 * [MY_CONSTANT] => 1
 * )
 * )
 * 
 * 

 * @return array
 */
#[Pure(true)]
function get_defined_constants(bool $categorize = false): array {}

/**
 * Generates a backtrace
 * @link https://php.net/manual/en/function.debug-backtrace.php
 * @param int $options [optional] 

 * As of 5.3.6, this parameter is a bitmask for the following options:
 * debug_backtrace options
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
DEBUG_BACKTRACE_PROVIDE_OBJECT

 * Whether or not to populate the "object" index.
 * 
DEBUG_BACKTRACE_IGNORE_ARGS

 * Whether or not to omit the "args" index, and thus all the function/method arguments,
 * to save memory.
 * 
 * 

 * Before 5.3.6, the only values recognized are true or false, which are the same as
 * setting or not setting the DEBUG_BACKTRACE_PROVIDE_OBJECT option respectively.
 * 
 * @param int $limit [optional] 

 * As of 5.4.0, this parameter can be used to limit the number of stack frames returned.
 * By default (limit=0) it returns all stack frames.
 * 
 * @return array 
an array of associative arrays. The possible returned elements
 * are as follows:
 * 
 * 

 * Possible returned elements from debug_backtrace
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Name
Type
Description
function
string

 * The current function name. See also
 * __FUNCTION__.
 * 
line
integer

 * The current line number. See also
 * __LINE__.
 * 
file
string

 * The current file name. See also
 * __FILE__.
 * 
class
string

 * The current class name. See also
 * __CLASS__
 * 
object
object

 * The current object.
 * 
type
string

 * The current call type. If a method call, "->" is returned. If a static
 * method call, "::" is returned. If a function call, nothing is returned.
 * 
args
array

 * If inside a function, this lists the functions arguments. If
 * inside an included file, this lists the included file name(s).
 * 
 */
function debug_backtrace(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT, int $limit = 0): array {}

/**
 * Prints a backtrace
 * @link https://php.net/manual/en/function.debug-print-backtrace.php
 * @param int $options [optional] 

 * As of 5.3.6, this parameter is a bitmask for the following options:
 * debug_print_backtrace options
 * 
 * 
 * 
 * 
 * 
 * 
DEBUG_BACKTRACE_IGNORE_ARGS

 * Whether or not to omit the "args" index, and thus all the function/method arguments,
 * to save memory.
 * 
 * 
 * @param int $limit [optional] 

 * As of 5.4.0, this parameter can be used to limit the number of stack frames printed.
 * By default (limit = 0) it prints all stack frames.
 * 
 * @return void
 */
function debug_print_backtrace(
    int $options = 0,
    #[PhpStormStubsElementAvailable(from: '7.0')] int $limit = 0
): void {}

/**
 * Forces collection of any existing garbage cycles
 * @link https://php.net/manual/en/function.gc-collect-cycles.php
 * @return int number of collected cycles.
 */
function gc_collect_cycles(): int {}

/**
 * Returns status of the circular reference collector
 * @link https://php.net/manual/en/function.gc-enabled.php
 * @return bool true if the garbage collector is enabled, false otherwise.
 */
#[Pure(true)]
function gc_enabled(): bool {}

/**
 * Activates the circular reference collector
 * @link https://php.net/manual/en/function.gc-enable.php
 * @return void
 */
function gc_enable(): void {}

/**
 * Deactivates the circular reference collector
 * @link https://php.net/manual/en/function.gc-disable.php
 * @return void
 */
function gc_disable(): void {}

/**
 * Gets information about the garbage collector
 * @link https://php.net/manual/en/function.gc-status.php
 * @return int[] associative array with the following elements:
 * 

 * 
"runs"
 * 
"collected"
 * 
"threshold"
 * 
"roots"
 * 
 * @since 7.3
 */
#[ArrayShape(["runs" => "int", "collected" => "int", "threshold" => "int", "roots" => "int"])]
#[Pure(true)]
function gc_status(): array {}

/**
 * Reclaims memory used by the Zend Engine memory manager
 * @link https://php.net/manual/en/function.gc-mem-caches.php
 * @return int Returns the number of bytes freed.
 * @since 7.0
 */
function gc_mem_caches(): int {}

/**
 * Returns active resources
 * @link https://php.net/manual/en/function.get-resources.php
 * @param string|null $type [optional]

 *
 * If defined, this will cause get_resources() to only return resources of the given type. A list of resource types is available.
 *
 * If the string Unknown is provided as the type, then only resources that are of an unknown type will be returned.
 *
 * If omitted, all resources will be returned.
 * 
 * @return resource[] Returns an array of currently active resources, indexed by resource number.
 * @since 7.0
 */
#[Pure(true)]
function get_resources(?string $type): array {}

 * You may specify a string with which to prompt the user.
 * 

 * @return string|false a single string from the user. The line returned has the ending newline removed.
 * If there is no more data to read, then FALSE is returned.
 */
function readline(?string $prompt): string|false {}

/**
 * Gets/sets various internal readline variables
 * @link https://php.net/manual/en/function.readline-info.php
 * @param string|null $var_name [optional] 

 * A variable name.
 * 
 * @param string $value [optional] 

 * If provided, this will be the new value of the setting.
 * 
 * @return mixed If called with no parameters, this function returns an array of
 * values for all the setting readline uses. The elements will
 * be indexed by the following values: done, end, erase_empty_line,
 * library_version, line_buffer, mark, pending_input, point, prompt,
 * readline_name, and terminal_name.
 * 

 * 

 * If called with one or two parameters, the old value is returned.
 */
#[ArrayShape([
    'line_buffer' => 'string',
    'point' => 'int',
    'end' => 'int',
    'mark' => 'int',
    'done' => 'int',
    'pending_input' => 'int',
    'prompt' => 'string',
    'terminal_name' => 'string',
    'completion_append_character' => 'string',
    'completion_suppress_append' => 'bool',
    'erase_empty_line' => 'int',
    'library_version' => 'string',
    'readline_name' => 'string',
    'attempted_completion_over' => 'int',
])]
function readline_info(?string $var_name, $value): mixed {}

/**
 * Adds a line to the history
 * @link https://php.net/manual/en/function.readline-add-history.php
 * @param string $prompt 

 * The line to be added in the history.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function readline_add_history(string $prompt): bool {}

/**
 * Clears the history
 * @link https://php.net/manual/en/function.readline-clear-history.php
 * @return bool TRUE on success or FALSE on failure.
 */
function readline_clear_history(): bool {}

/**
 * Lists the history
 * @link https://php.net/manual/en/function.readline-list-history.php
 * @return array an array of the entire command line history. The elements are
 * indexed by integers starting at zero.
 */
function readline_list_history(): array {}

/**
 * Reads the history
 * @link https://php.net/manual/en/function.readline-read-history.php
 * @param string|null $filename [optional] 

 * Path to the filename containing the command history.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function readline_read_history(?string $filename): bool {}

/**
 * Writes the history
 * @link https://php.net/manual/en/function.readline-write-history.php
 * @param string|null $filename [optional] 

 * Path to the saved file.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function readline_write_history(?string $filename): bool {}

/**
 * Registers a completion function
 * @link https://php.net/manual/en/function.readline-completion-function.php
 * @param callable $callback 

 * You must supply the name of an existing function which accepts a
 * partial command line and returns an array of possible matches.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function readline_completion_function(callable $callback): bool {}

/**
 * Initializes the readline callback interface and terminal, prints the prompt and returns immediately
 * @link https://php.net/manual/en/function.readline-callback-handler-install.php
 * @param string $prompt 

 * The prompt message.
 * 
 * @param callable $callback 

 * The callback function takes one parameter; the
 * user input returned.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function readline_callback_handler_install(string $prompt, callable $callback): bool {}

/**
 * Reads a character and informs the readline callback interface when a line is received
 * @link https://php.net/manual/en/function.readline-callback-read-char.php
 * @return void No value is returned.
 */
function readline_callback_read_char(): void {}

/**
 * Removes a previously installed callback handler and restores terminal settings
 * @link https://php.net/manual/en/function.readline-callback-handler-remove.php
 * @return bool TRUE if a previously installed callback handler was removed, or
 * FALSE if one could not be found.
 */
function readline_callback_handler_remove(): bool {}

/**
 * Redraws the display
 * @link https://php.net/manual/en/function.readline-redisplay.php
 * @return void No value is returned.
 */
function readline_redisplay(): void {}

/**
 * Inform readline that the cursor has moved to a new line
 * @link https://php.net/manual/en/function.readline-on-new-line.php
 * @return void No value is returned.
 */
function readline_on_new_line(): void {}

define('READLINE_LIB', "readline");

// End of readline v.5.5.3-1ubuntu2.1

 * The input charset.
 * 

 * @param string $to_encoding 

 * The output charset.
 * 
 * 

 * If you append the string //TRANSLIT to
 * out_charset transliteration is activated. This
 * means that when a character can't be represented in the target charset,
 * it can be approximated through one or several similarly looking
 * characters. If you append the string //IGNORE,
 * characters that cannot be represented in the target charset are silently
 * discarded. Otherwise, str is cut from the first
 * illegal character and an E_NOTICE is generated.
 * 
 * @param string $string 

 * The string to be converted.
 * 
 * @return string|false the converted string or FALSE on failure.
 */
#[Pure]
function iconv(string $from_encoding, string $to_encoding, string $string): string|false {}

/**
 * Convert character encoding as output buffer handler
 * @link https://php.net/manual/en/function.ob-iconv-handler.php
 * @param string $contents
 * @param int $status
 * @return string See ob_start for information about this handler
 * return values.
 */
#[Pure]
function ob_iconv_handler(string $contents, int $status): string {}

/**
 * Retrieve internal configuration variables of iconv extension
 * @link https://php.net/manual/en/function.iconv-get-encoding.php
 * @param string $type [optional] 

 * The value of the optional type can be:
 * all
 * input_encoding
 * output_encoding
 * internal_encoding
 * 
 * @return string|string[]|false the current value of the internal configuration variable if
 * successful or FALSE on failure.
 * 

 * If type is omitted or set to "all",
 * iconv_get_encoding returns an array that
 * stores all these variables.
 * 
 */
#[Pure]
#[ArrayShape(["input_encoding" => "string", "output_encoding" => "string", "internal_encoding" => "string"])]
function iconv_get_encoding(string $type = "all"): array|string|false {}

/**
 * Set current setting for character encoding conversion
 * @link https://php.net/manual/en/function.iconv-set-encoding.php
 * @param string $type 

 * The value of type can be any one of these:
 * input_encoding
 * output_encoding
 * internal_encoding
 * 
 * @param string $encoding 

 * The character set.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function iconv_set_encoding(string $type, string $encoding): bool {}

/**
 * Returns the character count of string
 * @link https://php.net/manual/en/function.iconv-strlen.php
 * @param string $string 

 * The string.
 * 
 * @param string|null $encoding 

 * If charset parameter is omitted,
 * str is assumed to be encoded in
 * iconv.internal_encoding.
 * 
 * @return int|false the character count of str, as an integer. False on error.
 */
#[Pure]
function iconv_strlen(string $string, ?string $encoding = null): int|false {}

/**
 * Cut out part of a string
 * @link https://php.net/manual/en/function.iconv-substr.php
 * @param string $string 

 * The original string.
 * 
 * @param int $offset 

 * If offset is non-negative,
 * iconv_substr cuts the portion out of
 * str beginning at offset'th
 * character, counting from zero.
 * 
 * 

 * If offset is negative,
 * iconv_substr cuts out the portion beginning
 * at the position, offset characters
 * away from the end of str.
 * 
 * @param int|null $length [optional] 

 * If length is given and is positive, the return
 * value will contain at most length characters
 * of the portion that begins at offset
 * (depending on the length of string).
 * 
 * 

 * If negative length is passed,
 * iconv_substr cuts the portion out of
 * str from the offset'th
 * character up to the character that is
 * length characters away from the end of the string.
 * In case offset is also negative, the start position
 * is calculated beforehand according to the rule explained above.
 * 
 * @param string|null $encoding 

 * If charset parameter is omitted,
 * string are assumed to be encoded in
 * iconv.internal_encoding.
 * 
 * 

 * Note that offset and length
 * parameters are always deemed to represent offsets that are
 * calculated on the basis of the character set determined by
 * charset, whilst the counterpart
 * substr always takes these for byte offsets.
 * 
 * @return string|false the portion of str specified by the
 * offset and length parameters.
 * 

 * If str is shorter than offset
 * characters long, FALSE will be returned.
 * 
 */
#[Pure]
function iconv_substr(string $string, int $offset, ?int $length, ?string $encoding = null): string|false {}

/**
 * Finds position of first occurrence of a needle within a haystack
 * @link https://php.net/manual/en/function.iconv-strpos.php
 * @param string $haystack 

 * The entire string.
 * 
 * @param string $needle 

 * The searched substring.
 * 
 * @param int $offset [optional] 

 * The optional offset parameter specifies
 * the position from which the search should be performed.
 * 
 * @param string|null $encoding 

 * If charset parameter is omitted,
 * string are assumed to be encoded in
 * iconv.internal_encoding.
 * 
 * @return int<0,max>|false the numeric position of the first occurrence of
 * needle in haystack.
 * 

 * If needle is not found,
 * iconv_strpos will return FALSE.
 * 
 */
#[Pure]
function iconv_strpos(string $haystack, string $needle, int $offset = 0, ?string $encoding = null): int|false {}

/**
 * Finds the last occurrence of a needle within a haystack
 * @link https://php.net/manual/en/function.iconv-strrpos.php
 * @param string $haystack 

 * The entire string.
 * 
 * @param string $needle 

 * The searched substring.
 * 
 * @param string|null $encoding 

 * If charset parameter is omitted,
 * string are assumed to be encoded in
 * iconv.internal_encoding.
 * 
 * @return int|false the numeric position of the last occurrence of
 * needle in haystack.
 * 

 * If needle is not found,
 * iconv_strrpos will return FALSE.
 * 
 */
#[Pure]
function iconv_strrpos(string $haystack, string $needle, ?string $encoding = null): int|false {}

/**
 * Composes a MIME header field
 * @link https://php.net/manual/en/function.iconv-mime-encode.php
 * @param string $field_name 

 * The field name.
 * 
 * @param string $field_value 

 * The field value.
 * 
 * @param array $options 

 * You can control the behaviour of iconv_mime_encode
 * by specifying an associative array that contains configuration items
 * to the optional third parameter preferences.
 * The items supported by iconv_mime_encode are
 * listed below. Note that item names are treated case-sensitive.
 * 
 * Configuration items supported by iconv_mime_encode
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Item
Type
Description
Default value
Example
scheme
string

 * Specifies the method to encode a field value by. The value of
 * this item may be either "B" or "Q", where "B" stands for
 * base64 encoding scheme and "Q" stands for
 * quoted-printable encoding scheme.
 * 
B
B
input-charset
string

 * Specifies the character set in which the first parameter
 * field_name and the second parameter
 * field_value are presented. If not given,
 * iconv_mime_encode assumes those parameters
 * are presented to it in the
 * iconv.internal_encoding
 * ini setting.
 * 

 * iconv.internal_encoding
 * 
ISO-8859-1
output-charset
string

 * Specifies the character set to use to compose the
 * MIME header.
 * 

 * iconv.internal_encoding
 * 
UTF-8
line-length
integer

 * Specifies the maximum length of the header lines. The resulting
 * header is "folded" to a set of multiple lines in case
 * the resulting header field would be longer than the value of this
 * parameter, according to
 * RFC2822 - Internet Message Format.
 * If not given, the length will be limited to 76 characters.
 * 
76
996
line-break-chars
string

 * Specifies the sequence of characters to append to each line
 * as an end-of-line sign when "folding" is performed on a long header
 * field. If not given, this defaults to "\r\n"
 * (CR LF). Note that
 * this parameter is always treated as an ASCII string regardless
 * of the value of input-charset.
 * 
\r\n
\n
 * 
 * @return string|false an encoded MIME field on success,
 * or FALSE if an error occurs during the encoding.
 */
#[Pure]
function iconv_mime_encode(string $field_name, string $field_value, array $options = []): string|false {}

/**
 * Decodes a MIME header field
 * @link https://php.net/manual/en/function.iconv-mime-decode.php
 * @param string $string 

 * The encoded header, as a string.
 * 
 * @param int $mode [optional] 

 * mode determines the behaviour in the event
 * iconv_mime_decode encounters a malformed
 * MIME header field. You can specify any combination
 * of the following bitmasks.
 * 
 * Bitmasks acceptable to iconv_mime_decode
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Value
Constant
Description
1
ICONV_MIME_DECODE_STRICT

 * If set, the given header is decoded in full conformance with the
 * standards defined in RFC2047.
 * This option is disabled by default because there are a lot of
 * broken mail user agents that don't follow the specification and don't
 * produce correct MIME headers.
 * 
2
ICONV_MIME_DECODE_CONTINUE_ON_ERROR

 * If set, iconv_mime_decode_headers
 * attempts to ignore any grammatical errors and continue to process
 * a given header.
 * 
 * 
 * @param string|null $encoding 

 * The optional charset parameter specifies the
 * character set to represent the result by. If omitted,
 * iconv.internal_encoding
 * will be used.
 * 
 * @return string|false a decoded MIME field on success,
 * or FALSE if an error occurs during the decoding.
 */
#[Pure]
function iconv_mime_decode(string $string, int $mode = 0, ?string $encoding = null): string|false {}

/**
 * Decodes multiple MIME header fields at once
 * @link https://php.net/manual/en/function.iconv-mime-decode-headers.php
 * @param string $headers 

 * The encoded headers, as a string.
 * 
 * @param int $mode [optional] 

 * mode determines the behaviour in the event
 * iconv_mime_decode_headers encounters a malformed
 * MIME header field. You can specify any combination
 * of the following bitmasks.
 * 

 * Bitmasks acceptable to iconv_mime_decode_headers
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Value
Constant
Description
1
ICONV_MIME_DECODE_STRICT

 * If set, the given header is decoded in full conformance with the
 * standards defined in RFC2047.
 * This option is disabled by default because there are a lot of
 * broken mail user agents that don't follow the specification and don't
 * produce correct MIME headers.
 * 
2
ICONV_MIME_DECODE_CONTINUE_ON_ERROR

 * If set, iconv_mime_decode_headers
 * attempts to ignore any grammatical errors and continue to process
 * a given header.
 * 
 * @param string|null $encoding 

 * The optional charset parameter specifies the
 * character set to represent the result by. If omitted,
 * iconv.internal_encoding
 * will be used.
 * 
 * @return array|false an associative array that holds a whole set of
 * MIME header fields specified by
 * encoded_headers on success, or FALSE
 * if an error occurs during the decoding.
 * 

 * Each key of the return value represents an individual
 * field name and the corresponding element represents a field value.
 * If more than one field of the same name are present,
 * iconv_mime_decode_headers automatically incorporates
 * them into a numerically indexed array in the order of occurrence.
 * 
 */
#[Pure]
function iconv_mime_decode_headers(string $headers, int $mode = 0, ?string $encoding = null): array|false {}

/**
 * string
 * @link https://php.net/manual/en/iconv.constants.php
 */
define('ICONV_IMPL', "libiconv");

/**
 * string
 * @link https://php.net/manual/en/iconv.constants.php
 */
define('ICONV_VERSION', 2.17);

/**
 * integer
 * @link https://php.net/manual/en/iconv.constants.php
 */
define('ICONV_MIME_DECODE_STRICT', 1);

/**
 * integer
 * @link https://php.net/manual/en/iconv.constants.php
 */
define('ICONV_MIME_DECODE_CONTINUE_ON_ERROR', 2);

// End of iconv v.
Create and initialize new event base

 *
 * 
Returns new event base, which can be used later in {@link event_base_set}(), {@link event_base_loop}() and other functions.
 *
 * @link https://php.net/event_base_new
 *
 * @return resource|false returns valid event base resource on success or FALSE on error.
 */
function event_base_new() {}

/**
 * 
Destroy event base
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Destroys the specified event_base and frees all the resources associated.
 * Note that it's not possible to destroy an event base with events attached to it.
 *
 * @link https://php.net/event_base_free
 *
 * @param resource $event_base Valid event base resource.
 *
 * @return void
 */
function event_base_free($event_base) {}

/**
 * 
Handle events
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Starts event loop for the specified event base.
 *
 * 
By default, the {@link event_base_loop}() function runs an event_base until
 * there are no more events registered in it. To run the loop, it repeatedly
 * checks whether any of the registered events has triggered (for example,
 * if a read event's file descriptor is ready to read, or if a timeout event's
 * timeout is ready to expire). Once this happens, it marks all triggered events
 * as "active", and starts to run them.
 * 
 *
 * 
You can change the behavior of event_base_loop() by setting one or more flags
 * in its flags argument. If EVLOOP_ONCE is set, then the loop will wait until some
 * events become active, then run active events until there are no more to run, then
 * return. If EVLOOP_NONBLOCK is set, then the loop will not wait for events to trigger:
 * it will only check whether any events are ready to trigger immediately,
 * and run their callbacks if so.
 * 
 *
 * @link https://php.net/event_base_loop
 *
 * @param resource $event_base Valid event base resource.
 * @param int $flags [optional] Optional parameter, which can take any combination of EVLOOP_ONCE and EVLOOP_NONBLOCK.
 *
 * @return int 

 * Returns 0 if it exited normally,
 * -1 if it exited because of some unhandled error in the backend
 * and 1 if no events were registered.
 * 
 */
function event_base_loop($event_base, $flags = null) {}

/**
 * 
Tells the event_base to exit its loop immediately.
 * 
(PECL libevent >= 0.0.1)
 *
 * 
It differs from {@link event_base_loopexit}() in that if the event_base is currently
 * running callbacks for any active events, it will exit immediately after finishing the
 * one it's currently processing. The behaviour is similar to break statement.
 *
 * @link https://php.net/event_base_loopbreak
 *
 * @param resource $event_base Valid event base resource.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_base_loopbreak($event_base) {}

/**
 * 
Tells an event_base to stop looping after a given time has elapsed
 * 
(PECL libevent >= 0.0.1)
 *
 * 
If the event_base is currently running callbacks for any active events,
 * it will continue running them, and not exit until they have all been run.
 *
 * 
If event loop isn't running {@link event_base_loopexit}() schedules the next instance
 * of the event loop to stop right after the next round of callbacks are run (as if it had
 * been invoked with EVLOOP_ONCE).
 *
 * @link https://php.net/event_base_loopexit
 *
 * @param resource $event_base 

 * Valid event base resource.
 * 
 * @param int $timeout [optional] 

 * Optional timeout parameter (in microseconds). If lower than 1,
 * the event_base stops looping without a delay.
 * 
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_base_loopexit($event_base, $timeout = -1) {}

/**
 * 
Associate event base with an event
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Associates the event_base with the event.
 *
 * @link https://php.net/event_base_set
 *
 * @param resource $event Valid event resource.
 * @param resource $base Valid event base resource.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_base_set($event, $base) {}

/**
 * 
Set the number of different event priority levels
 * 
(PECL libevent >= 0.0.2)
 *
 * 
By default all events are scheduled with the same priority (npriorities/2).
 * Using {@link event_base_priority_init}() you can change the number of event priority
 * levels and then set a desired priority for each event.
 *
 * @link https://php.net/event_base_priority_init
 *
 * @param resource $event_base Valid event base resource.
 * @param int $npriorities The number of event priority levels.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_base_priority_init($event_base, $npriorities) {}

/**
 * 
Creates and returns a new event resource.
 * 
(PECL libevent >= 0.0.1)
 *
 * @link https://php.net/event_new
 *
 * @return resource|false returns a new event resource on success or FALSE on error.
 */
function event_new() {}

/**
 * 
Free event resource.
 * 
(PECL libevent >= 0.0.1)
 *
 * @link https://php.net/event_free
 *
 * @param resource $event Valid event resource.
 *
 * @return void
 */
function event_free($event) {}

/**
 * 
Add an event to the set of monitored events
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Schedules the execution of the non-pending event (makes it pending in it's
 * configured base) when the event specified in {@link event_set}() occurs or in
 * at least the time specified by the timeout argument. If timeout was not specified,
 * not timeout is set. The event must be already initialized by
 * {@link event_set}() and {@link event_base_set}() functions.
 * If the event already has a timeout set,
 * it is replaced by the new one.
 *
 * 
If you call {@link event_add}() on an event that is already pending,
 * it will leave it pending, and reschedule it with the provided timeout.
 *
 * @link https://php.net/event_add
 *
 * @param resource $event 

 * Valid event resource.
 * 
 * @param int $timeout [optional] 

 * Optional timeout (in microseconds).
 * 
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_add($event, $timeout = -1) {}

/**
 * 
Prepares the event to be used in {@link event_add}().
 * 
(PECL libevent >= 0.0.1)
 *
 * 
The event is prepared to call the function specified by the callback
 * on the events specified in parameter events, which is a set of the following
 * flags: EV_TIMEOUT, EV_SIGNAL, EV_READ, EV_WRITE and EV_PERSIST.
 *
 * 
EV_SIGNAL support was added in version 0.0.4
 *
 * 
After initializing the event, use {@link event_base_set}() to associate the event with its event base.
 *
 * 
In case of matching event, these three arguments are passed to the callback function:
 * 
 * 	
 * 		
 * 		
 * 	
 * 	
 * 		
 * 		
 * 	
 * 	
 * 		
 * 		
 * 	
 * 
$fd
Signal number or resource indicating the stream.
$events
A flag indicating the event. Consists of the following flags: EV_TIMEOUT, EV_SIGNAL, EV_READ, EV_WRITE and EV_PERSIST.
$arg
Optional parameter, previously passed to {@link event_set}() as arg.
 * 
 *
 * @link https://php.net/event_set
 *
 * @param resource $event 

 * Valid event resource.
 * 
 * @param resource|int $fd 

 * Valid PHP stream resource. The stream must be castable to file descriptor,
 * so you most likely won't be able to use any of filtered streams.
 * 
 * @param int $events 

 * A set of flags indicating the desired event, can be EV_READ and/or EV_WRITE.
 * The additional flag EV_PERSIST makes the event to persist until {@link event_del}() is
 * called, otherwise the callback is invoked only once.
 * 
 * @param callable $callback 

 * Callback function to be called when the matching event occurs.
 * 
 * @param mixed $arg [optional] 

 * Optional callback parameter.
 * 
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_set($event, $fd, $events, $callback, $arg = null) {}

/**
 * 
Remove an event from the set of monitored events.
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Calling {@link event_del}() on an initialized event makes it non-pending
 * and non-active. If the event was not pending or active, there is no effect.
 *
 * @link https://php.net/event_del
 *
 * @param resource $event Valid event resource.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_del($event) {}

/**
 * 
Create new buffered event
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Libevent provides an abstraction layer on top of the regular event API.
 * Using buffered event you don't need to deal with the I/O manually, instead
 * it provides input and output buffers that get filled and drained automatically.
 *
 * 
Every bufferevent has two data-related callbacks: a read callback and a write
 * callback. By default, the read callback is called whenever any data is read from
 * the underlying transport, and the write callback is called whenever enough data
 * from the output buffer is emptied to the underlying transport. You can override
 * the behavior of these functions by adjusting the read and write "watermarks"
 * of the bufferevent (see {@link event_buffer_watermark_set}()).
 *
 * 
A bufferevent also has an "error" or "event" callback that gets invoked to tell
 * the application about non-data-oriented events, like when a connection is closed or
 * an error occurs.
 *
 * @link https://php.net/event_buffer_new
 *
 * @param resource      $stream  Valid PHP stream resource. Must be castable to file descriptor.
 * @param callable|null $readcb  Callback to invoke where there is data to read, or NULL if no callback is desired.
 * @param callable|null $writecb Callback to invoke where the descriptor is ready for writing, or NULL if no callback is desired.
 * @param callable      $errorcb Callback to invoke where there is an error on the descriptor, cannot be NULL.
 * @param mixed         $arg     An argument that will be passed to each of the callbacks (optional).
 *
 * @return resource|false returns new buffered event resource on success or FALSE on error.
 */
function event_buffer_new($stream, $readcb, $writecb, $errorcb, $arg = null) {}

/**
 * 
Destroys the specified buffered event and frees all the resources associated.
 * 
(PECL libevent >= 0.0.1)
 *
 * @link https://php.net/event_buffer_free
 *
 * @param resource $bevent Valid buffered event resource.
 *
 * @return void
 */
function event_buffer_free($bevent) {}

/**
 * 
Associate buffered event with an event base
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Assign the specified bevent to the event_base.
 *
 * @link https://php.net/event_buffer_base_set
 *
 * @param resource $bevent Valid buffered event resource.
 * @param resource $event_base Valid event base resource.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_buffer_base_set($bevent, $event_base) {}

/**
 * 
Assign a priority to a buffered event. Use it after
 * initializing event, but before adding an event to the event_base.
 * 
(PECL libevent >= 0.0.1)
 *
 * 
When multiple events trigger at the same time, Libevent
 * does not define any order with respect to when their callbacks
 * will be executed. You can define some events as more important
 * than others by using priorities.
 *
 * 
When multiple events of multiple priorities become active,
 * the low-priority events are not run. Instead, Libevent runs
 * the high priority events, then checks for events again. Only
 * when no high-priority events are active are the low-priority
 * events run.
 *
 * 
When you do not set the priority for an event, the default
 * is the number of queues in the event base, divided by 2.
 *
 * @link https://php.net/event_buffer_priority_set
 *
 * @see event_base_priority_init
 *
 * @param resource $bevent 

 * Valid buffered event resource.
 * 
 * @param int $priority 

 * Priority level. Cannot be less than 0 and cannot exceed
 * maximum priority level of the event base (see {@link event_base_priority_init}()).
 * 
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_buffer_priority_set($bevent, $priority) {}

/**
 * 
Writes data to the specified buffered event.
 * 
(PECL libevent >= 0.0.1)
 *
 * 
The data is appended to the output buffer and written
 * to the descriptor when it becomes available for writing.
 *
 * @link https://php.net/event_buffer_write
 *
 * @param resource $bevent Valid buffered event resource.
 * @param string $data The data to be written.
 * @param int $data_size Optional size parameter. {@link event_buffer_write}() writes all the data by default
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_buffer_write($bevent, $data, $data_size = -1) {}

/**
 * 
Reads data from the input buffer of the buffered event.
 * 
(PECL libevent >= 0.0.1)
 *
 * @link https://php.net/event_buffer_read
 *
 * @param resource $bevent Valid buffered event resource.
 * @param int $data_size Data size in bytes.
 *
 * @return string
 */
function event_buffer_read($bevent, $data_size) {}

/**
 * 
Enables the specified buffered event.
 * 
(PECL libevent >= 0.0.1)
 *
 * @link https://php.net/event_buffer_enable
 *
 * @param resource $bevent Valid buffered event resource.
 * @param int $events Any combination of EV_READ and EV_WRITE.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_buffer_enable($bevent, $events) {}

/**
 * 
Disable a buffered event
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Disables the specified buffered event.
 *
 * @link https://php.net/event_buffer_disable
 *
 * @param resource $bevent Valid buffered event resource.
 * @param int $events Any combination of EV_READ and EV_WRITE.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_buffer_disable($bevent, $events) {}

/**
 * 
Sets the read and write timeouts for the specified buffered event.
 * 
(PECL libevent >= 0.0.1)
 *
 * @link https://php.net/event_buffer_timeout_set
 *
 * @param resource $bevent Valid buffered event resource.
 * @param int $read_timeout Read timeout (in seconds).
 * @param int $write_timeout Write timeout (in seconds).
 *
 * @return void
 */
function event_buffer_timeout_set($bevent, $read_timeout, $write_timeout) {}

/**
 * 
Set the watermarks for read and write events.
 * 
(PECL libevent >= 0.0.1)
 *
 * 
Every bufferevent has four watermarks:
 *
 * 
Read low-water mark

 * Whenever a read occurs that leaves the bufferevent's input buffer at this
 * level or higher, the bufferevent's read callback is invoked. Defaults to 0,
 * so that every read results in the read callback being invoked.
 *
 * 
Read high-water mark

 * If the bufferevent's input buffer ever gets to this level, the bufferevent
 * stops reading until enough data is drained from the input buffer to take us
 * below it again. Defaults to unlimited, so that we never stop reading because
 * of the size of the input buffer.
 *
 * 
Write low-water mark

 * Whenever a write occurs that takes us to this level or below, we invoke the write
 * callback. Defaults to 0, so that a write callback is not invoked unless the output
 * buffer is emptied.
 *
 * 
Write high-water mark

 * Not used by a bufferevent directly, this watermark can have special meaning when
 * a bufferevent is used as the underlying transport of another bufferevent.
 *
 * 
Libevent does not invoke read callback unless there is at least lowmark
 * bytes in the input buffer; if the read buffer is beyond the highmark,
 * reading is stopped. On output, the write callback is invoked whenever
 * the buffered data falls below the lowmark.
 *
 * @link https://php.net/event_buffer_watermark_set
 *
 * @param resource $bevent   Valid buffered event resource.
 * @param int      $events   Any combination of EV_READ and EV_WRITE.
 * @param int      $lowmark  Low watermark.
 * @param int      $highmark High watermark.
 *
 * @return void
 */
function event_buffer_watermark_set($bevent, $events, $lowmark, $highmark) {}

/**
 * 
Changes the file descriptor on which the buffered event operates.
 * 
(PECL libevent >= 0.0.1)
 *
 * @link https://php.net/event_buffer_fd_set
 *
 * @param resource $bevent Valid buffered event resource.
 * @param resource $fd Valid PHP stream, must be castable to file descriptor.
 *
 * @return void
 */
function event_buffer_fd_set($bevent, $fd) {}

/**
 * 
Set or reset callbacks for a buffered event
 * 
(PECL libevent >= 0.0.4)
 *
 * 
Sets or changes existing callbacks for the buffered event.
 *
 * @link https://php.net/event_buffer_set_callback
 *
 * @param resource $bevent Valid buffered event resource.
 * @param callable|null $readcb Callback to invoke where there is data to read, or NULL if no callback is desired.
 * @param callable|null $writecb Callback to invoke where the descriptor is ready for writing, or NULL if no callback is desired.
 * @param callable $errorcb Callback to invoke where there is an error on the descriptor, cannot be NULL.
 * @param mixed $arg An argument that will be passed to each of the callbacks (optional).
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_buffer_set_callback($bevent, $readcb, $writecb, $errorcb, $arg = null) {}

/**
 * 
Alias of {@link event_new}().
 *
 * @return resource|false returns valid event base resource on success or FALSE on error.
 */
function event_timer_new() {}

/**
 * 
Prepares the timer event to be used in {@link event_add}().
 *
 * 
The event is prepared to call the function specified by the callback
 * on the timeout event (EV_TIMEOUT).
 *
 * 
After initializing the event, use {@link event_base_set}() to associate the event with its event base.
 *
 * 
In case of matching event, these three arguments are passed to the callback function:
 * 
 * 	
 * 		
 * 		
 * 	
 * 	
 * 		
 * 		
 * 	
 * 	
 * 		
 * 		
 * 	
 * 
$fd
null
$events
A flag indicating the event. EV_TIMEOUT.
$arg
Optional parameter, previously passed to {@link event_timer_set}() as arg.
 * 
 *
 * @param resource $event 

 * Valid event resource.
 * 
 * @param callable $callback 

 * Callback function to be called when the matching event occurs.
 * 
 * @param mixed $arg [optional] 

 * Optional callback parameter.
 * 
 *
 * @return void
 */
function event_timer_set($event, $callback, $arg = null) {}

/**
 * 
Checks if a specific event is pending or scheduled.
 *
 * @param resource $event 

 * Valid event resource.
 * 
 * @param int $timeout [optional] 

 * Optional timeout (in microseconds).
 * 
 *
 * @return bool TRUE if event is not scheduled (added) FALSE otherwise
 */
function event_timer_pending($event, $timeout = -1) {}

/**
 * 
Alias of {@link event_add}().
 *
 * @param resource $event 

 * Valid event resource.
 * 
 * @param int $timeout [optional] 

 * Optional timeout (in microseconds).
 * 
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_timer_add($event, $timeout = -1) {}

/**
 * 
Alias of {@link event_del}().
 *
 * @param resource $event Valid event resource.
 *
 * @return bool returns TRUE on success or FALSE on error.
 */
function event_timer_del($event) {}

// End of PECL libevent v.0.0.4

 * For a cataloged connection to a database, this parameter
 * represents the connection alias in the DB2 client catalog.
 * 

 * 

 * For an uncataloged connection to a database,
 * this parameter represents a complete DSN in the following format:
 * DRIVER=driver;DATABASE=database;HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=username;PWD=password;
 * 
 * @param string|null $username 

 * The username with which you are connecting to the database, or null if
 * the $database parameter contains a DSN which already provides the username for
 * the connection.
 * 
 * @param string|null $password 

 * The password with which you are connecting to the database, or null if
 * the $database parameter contains a DSN which already provides the password for
 * the connection.
 * 
 * @param array $options 

 * An associative array of connection options that affect the behavior
 * of the connection, where valid array keys include:
 * autocommit
 * 

 * Passing the DB2_AUTOCOMMIT_ON value turns
 * autocommit on for this connection handle.
 * 
 * 

 * Passing the DB2_AUTOCOMMIT_OFF value turns
 * autocommit off for this connection handle.
 * 
 * @return resource|false A connection handle resource if the connection attempt is
 * successful. If the connection attempt fails, db2_connect
 * returns false.
 */
function db2_connect(#[\SensitiveParameter] string $database, ?string $username, #[\SensitiveParameter] ?string $password, array $options = []) {}

/**
 * Commits a transaction
 * @link https://php.net/manual/en/function.db2-commit.php
 * @param resource $connection 

 * A valid database connection resource variable as returned from
 * db2_connect or db2_pconnect.
 * 
 * @return bool true on success or false on failure.
 */
function db2_commit($connection): bool {}

/**
 * Returns a persistent connection to a database
 * @link https://php.net/manual/en/function.db2-pconnect.php
 * @param string $database 

 * For a cataloged connection to a database, this parameter
 * represents the connection alias in the DB2 client catalog.
 * 
 * 

 * For an uncataloged connection to a database,
 * this parameter represents a complete DSN in the following format:
 * DRIVER=driver;DATABASE=database;HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=username;PWD=password;
 * 
 * @param string|null $username 

 * The username with which you are connecting to the database, or null if
 * the $database parameter contains a DSN which already provides the username for
 * the connection.
 * 
 * @param string|null $password 

 * The password with which you are connecting to the database, or null if
 * the $database parameter contains a DSN which already provides the password for
 * the connection.
 * 
 * @param array $options 

 * An associative array of connection options that affect the behavior
 * of the connection, where valid array keys include:
 * autocommit
 * 
 * 

 * Passing the DB2_AUTOCOMMIT_ON value turns
 * autocommit on for this connection handle.
 * 
 * 

 * Passing the DB2_AUTOCOMMIT_OFF value turns
 * autocommit off for this connection handle.
 * 
 * @return resource|false A connection handle resource if the connection attempt is
 * successful. db2_pconnect tries to reuse an existing
 * connection resource that exactly matches the
 * database, username, and
 * password parameters. If the connection attempt fails,
 * db2_pconnect returns false.
 */
function db2_pconnect(#[\SensitiveParameter] string $database, ?string $username, #[\SensitiveParameter] ?string $password, array $options = []) {}

/**
 * Closes a persistent database connection
 *
 * This function closes a persistent DB2 client connection.
 *
 * @link https://php.net/manual/en/function.db2-pclose.php
 *
 * @param resource $connection Specifies a persistent DB2 client connection.
 *
 * @return bool Returns true on success or false on failure.
 */
function db2_pclose($connection): bool {}

/**
 * Returns or sets the AUTOCOMMIT state for a database connection
 * @link https://php.net/manual/en/function.db2-autocommit.php
 * @param resource $connection 

 * A valid database connection resource variable as returned from
 * db2_connect or db2_pconnect.
 * 
 * @param int $value 

 * One of the following constants:
 * 

 * DB2_AUTOCOMMIT_OFF
 * Turns AUTOCOMMIT off.
 * 
 * 

 * DB2_AUTOCOMMIT_ON
 * Turns AUTOCOMMIT on.
 * 
 * @return int|bool 
When db2_autocommit receives only the
 * connection parameter, it returns the current state
 * of AUTOCOMMIT for the requested connection as an integer value. A value of
 * 0 indicates that AUTOCOMMIT is off, while a value of 1 indicates that
 * AUTOCOMMIT is on.
 * 
 * 

 * When db2_autocommit receives both the
 * connection parameter and
 * autocommit parameter, it attempts to set the
 * AUTOCOMMIT state of the requested connection to the corresponding state.
 * true on success or false on failure.
 */
function db2_autocommit($connection, int $value = null): int|bool {}

/**
 * Binds a PHP variable to an SQL statement parameter
 * @link https://php.net/manual/en/function.db2-bind-param.php
 * @param resource $stmt 

 * A prepared statement returned from db2_prepare.
 * 
 * @param int $parameter_number
 * @param string $variable_name
 * @param int $parameter_type
 * @param int $data_type
 * @param int $precision 

 * Specifies the precision with which the variable should be bound to the
 * database. This parameter can also be used for retrieving XML output values
 * from stored procedures. A non-negative value specifies the maximum size of
 * the XML data that will be retrieved from the database. If this parameter
 * is not used, a default of 1MB will be assumed for retrieving the XML
 * output value from the stored procedure.
 * 
 * @param int $scale 

 * Specifies the scale with which the variable should be bound to the
 * database.
 * 
 * @return bool true on success or false on failure.
 */
function db2_bind_param($stmt, int $parameter_number, string $variable_name, int $parameter_type = DB2_PARAM_IN, int $data_type = 0, int $precision = -1, int $scale = 0): bool {}

/**
 * Closes a database connection
 * @link https://php.net/manual/en/function.db2-close.php
 * @param resource $connection 

 * Specifies an active DB2 client connection.
 * 
 * @return bool true on success or false on failure.
 */
function db2_close($connection): bool {}

/**
 * Returns a result set listing the columns and associated privileges for a table
 * @link https://php.net/manual/en/function.db2-column-privileges.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string|null $schema 

 * The schema which contains the tables. To match all schemas, pass null
 * or an empty string.
 * 
 * @param string|null $table_name
 * @param string|null $column_name
 * @return resource|false a statement resource with a result set containing rows describing
 * the column privileges for columns matching the specified parameters. The
 * rows are composed of the following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * TABLE_CAT
 * Name of the catalog. The value is NULL if this table does not
 * have catalogs.
 * 
 * 
 * TABLE_SCHEM
 * Name of the schema.
 * 
 * 
 * TABLE_NAME
 * Name of the table or view.
 * 
 * 
 * COLUMN_NAME
 * Name of the column.
 * 
 * 
 * GRANTOR
 * Authorization ID of the user who granted the privilege.
 * 
 * 
 * GRANTEE
 * Authorization ID of the user to whom the privilege was
 * granted.
 * 
 * 
 * PRIVILEGE
 * The privilege for the column.
 * 
 * 
 * IS_GRANTABLE
 * Whether the GRANTEE is permitted to grant this privilege to
 * other users.
 * 
 */
function db2_column_privileges($connection, ?string $qualifier = null, ?string $schema = null, ?string $table_name = null, ?string $column_name = null) {}

function db2_columnprivileges() {}

/**
 * Returns a result set listing the columns and associated metadata for a table
 * @link https://php.net/manual/en/function.db2-columns.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string $schema 

 * The schema which contains the tables. To match all schemas, pass
 * '%'.
 * 
 * @param string $table_name
 * @param string $column_name
 * @return resource|false A statement resource with a result set containing rows describing
 * the columns matching the specified parameters. The rows are composed of
 * the following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * TABLE_CAT
 * Name of the catalog. The value is NULL if this table does not
 * have catalogs.
 * 
 * 
 * TABLE_SCHEM
 * Name of the schema.
 * 
 * 
 * TABLE_NAME
 * Name of the table or view.
 * 
 * 
 * COLUMN_NAME
 * Name of the column.
 * 
 * 
 * DATA_TYPE
 * The SQL data type for the column represented as an integer value.
 * 
 * 
 * TYPE_NAME
 * A string representing the data type for the column.
 * 
 * 
 * COLUMN_SIZE
 * An integer value representing the size of the column.
 * 
 * 
 * BUFFER_LENGTH
 * 
 * Maximum number of bytes necessary to store data from this column.
 * 
 * 
 * 
 * DECIMAL_DIGITS
 * 
 * The scale of the column, or null where scale is not applicable.
 * 
 * 
 * 
 * NUM_PREC_RADIX
 * 
 * An integer value of either 10 (representing
 * an exact numeric data type), 2 (representing an
 * approximate numeric data type), or null (representing a data type for
 * which radix is not applicable).
 * 
 * 
 * 
 * NULLABLE
 * An integer value representing whether the column is nullable or
 * not.
 * 
 * 
 * REMARKS
 * Description of the column.
 * 
 * 
 * COLUMN_DEF
 * Default value for the column.
 * 
 * 
 * SQL_DATA_TYPE
 * An integer value representing the size of the column.
 * 
 * 
 * SQL_DATETIME_SUB
 * 
 * Returns an integer value representing a datetime subtype code,
 * or null for SQL data types to which this does not apply.
 * 
 * 
 * 
 * CHAR_OCTET_LENGTH
 * 
 * Maximum length in octets for a character data type column, which
 * matches COLUMN_SIZE for single-byte character set data, or null for
 * non-character data types.
 * 
 * 
 * 
 * ORDINAL_POSITION
 * The 1-indexed position of the column in the table.
 * 
 * 
 * IS_NULLABLE
 * 
 * A string value where 'YES' means that the column is nullable and
 * 'NO' means that the column is not nullable.
 * 
 * 
 */
function db2_columns($connection, $qualifier = null, $schema = null, $table_name = null, $column_name = null) {}

/**
 * Returns a result set listing the foreign keys for a table
 * @link https://php.net/manual/en/function.db2-foreign-keys.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string|null $schema 

 * The schema which contains the tables. If schema
 * is null, db2_foreign_keys matches the schema for
 * the current connection.
 * 
 * @param string $table_name
 * @return resource|false A statement resource with a result set containing rows describing
 * the foreign keys for the specified table. The result set is composed of the
 * following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * PKTABLE_CAT
 * 
 * Name of the catalog for the table containing the primary key. The
 * value is NULL if this table does not have catalogs.
 * 
 * 
 * 
 * PKTABLE_SCHEM
 * 
 * Name of the schema for the table containing the primary key.
 * 
 * 
 * 
 * PKTABLE_NAME
 * Name of the table containing the primary key.
 * 
 * 
 * PKCOLUMN_NAME
 * Name of the column containing the primary key.
 * 
 * 
 * FKTABLE_CAT
 * 
 * Name of the catalog for the table containing the foreign key. The
 * value is NULL if this table does not have catalogs.
 * 
 * 
 * 
 * FKTABLE_SCHEM
 * 
 * Name of the schema for the table containing the foreign key.
 * 
 * 
 * 
 * FKTABLE_NAME
 * Name of the table containing the foreign key.
 * 
 * 
 * FKCOLUMN_NAME
 * Name of the column containing the foreign key.
 * 
 * 
 * KEY_SEQ
 * 1-indexed position of the column in the key.
 * 
 * 
 * UPDATE_RULE
 * 
 * Integer value representing the action applied to the foreign key
 * when the SQL operation is UPDATE.
 * 
 * 
 * 
 * DELETE_RULE
 * 
 * Integer value representing the action applied to the foreign key
 * when the SQL operation is DELETE.
 * 
 * 
 * 
 * FK_NAME
 * The name of the foreign key.
 * 
 * 
 * PK_NAME
 * The name of the primary key.
 * 
 * 
 * DEFERRABILITY
 * 
 * An integer value representing whether the foreign key deferrability is
 * SQL_INITIALLY_DEFERRED, SQL_INITIALLY_IMMEDIATE, or
 * SQL_NOT_DEFERRABLE.
 * 
 * 
 */
function db2_foreign_keys($connection, ?string $qualifier, ?string $schema, string $table_name) {}

function db2_foreignkeys() {}

/**
 * Returns a result set listing primary keys for a table
 * @link https://php.net/manual/en/function.db2-primary-keys.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string|null $schema 

 * The schema which contains the tables. If schema
 * is null, db2_primary_keys matches the schema for
 * the current connection.
 * 
 * @param string $table_name
 * @return resource|false A statement resource with a result set containing rows describing
 * the primary keys for the specified table. The result set is composed of the
 * following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * TABLE_CAT
 * 
 * Name of the catalog for the table containing the primary key. The
 * value is NULL if this table does not have catalogs.
 * 
 * 
 * 
 * TABLE_SCHEM
 * 
 * Name of the schema for the table containing the primary key.
 * 
 * 
 * 
 * TABLE_NAME
 * Name of the table containing the primary key.
 * 
 * 
 * COLUMN_NAME
 * Name of the column containing the primary key.
 * 
 * 
 * KEY_SEQ
 * 1-indexed position of the column in the key.
 * 
 * 
 * PK_NAME
 * The name of the primary key.
 * 
 */
function db2_primary_keys($connection, ?string $qualifier, ?string $schema, string $table_name) {}

function db2_primarykeys() {}

/**
 * Returns a result set listing stored procedure parameters
 * @link https://php.net/manual/en/function.db2-procedure-columns.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string $schema 

 * The schema which contains the procedures. This parameter accepts a
 * search pattern containing _ and %
 * as wildcards.
 * 
 * @param string $procedure 

 * The name of the procedure. This parameter accepts a
 * search pattern containing _ and %
 * as wildcards.
 * 
 * @param string|null $parameter 

 * The name of the parameter. This parameter accepts a search pattern
 * containing _ and % as wildcards.
 * If this parameter is null, all parameters for the specified stored
 * procedures are returned.
 * 
 * @return resource|false A statement resource with a result set containing rows describing
 * the parameters for the stored procedures matching the specified parameters.
 * The rows are composed of the following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * PROCEDURE_CAT
 * The catalog that contains the procedure. The value is null if
 * this table does not have catalogs.
 * 
 * 
 * PROCEDURE_SCHEM
 * Name of the schema that contains the stored procedure.
 * 
 * 
 * PROCEDURE_NAME
 * Name of the procedure.
 * 
 * 
 * COLUMN_NAME
 * Name of the parameter.
 * 
 * 
 * COLUMN_TYPE
 * 
 * 

 * An integer value representing the type of the parameter:
 * 
 * Return value
 * Parameter type
 * 
 * 
 * 1 (SQL_PARAM_INPUT)
 * Input (IN) parameter.
 * 
 * 
 * 2 (SQL_PARAM_INPUT_OUTPUT)
 * Input/output (INOUT) parameter.
 * 
 * 
 * 3 (SQL_PARAM_OUTPUT)
 * Output (OUT) parameter.
 * 
 * 
 * 
 * 
 * 
 * DATA_TYPE
 * The SQL data type for the parameter represented as an integer
 * value.
 * 
 * 
 * TYPE_NAME
 * A string representing the data type for the parameter.
 * 
 * 
 * COLUMN_SIZE
 * An integer value representing the size of the parameter.
 * 
 * 
 * BUFFER_LENGTH
 * 
 * Maximum number of bytes necessary to store data for this parameter.
 * 
 * 
 * 
 * DECIMAL_DIGITS
 * 
 * The scale of the parameter, or null where scale is not applicable.
 * 
 * 
 * 
 * NUM_PREC_RADIX
 * 
 * An integer value of either 10 (representing
 * an exact numeric data type), 2 (representing an
 * approximate numeric data type), or null (representing a data type for
 * which radix is not applicable).
 * 
 * 
 * 
 * NULLABLE
 * An integer value representing whether the parameter is nullable
 * or not.
 * 
 * 
 * REMARKS
 * Description of the parameter.
 * 
 * 
 * COLUMN_DEF
 * Default value for the parameter.
 * 
 * 
 * SQL_DATA_TYPE
 * An integer value representing the size of the parameter.
 * 
 * 
 * SQL_DATETIME_SUB
 * 
 * Returns an integer value representing a datetime subtype code,
 * or null for SQL data types to which this does not apply.
 * 
 * 
 * 
 * CHAR_OCTET_LENGTH
 * 
 * Maximum length in octets for a character data type parameter, which
 * matches COLUMN_SIZE for single-byte character set data, or null for
 * non-character data types.
 * 
 * 
 * 
 * ORDINAL_POSITION
 * The 1-indexed position of the parameter in the CALL
 * statement.
 * 
 * 
 * IS_NULLABLE
 * 
 * A string value where 'YES' means that the parameter accepts or
 * returns null values and 'NO' means that the parameter does not
 * accept or return null values.
 * 
 * 
 */
function db2_procedure_columns($connection, ?string $qualifier, string $schema, string $procedure, ?string $parameter) {}

function db2_procedurecolumns() {}

/**
 * Returns a result set listing the stored procedures registered in a database
 * @link https://php.net/manual/en/function.db2-procedures.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string $schema 

 * The schema which contains the procedures. This parameter accepts a
 * search pattern containing _ and %
 * as wildcards.
 * 
 * @param string $procedure 

 * The name of the procedure. This parameter accepts a
 * search pattern containing _ and %
 * as wildcards.
 * 
 * @return resource|false A statement resource with a result set containing rows describing
 * the stored procedures matching the specified parameters. The rows are
 * composed of the following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * PROCEDURE_CAT
 * The catalog that contains the procedure. The value is null if
 * this table does not have catalogs.
 * 
 * 
 * PROCEDURE_SCHEM
 * Name of the schema that contains the stored procedure.
 * 
 * 
 * PROCEDURE_NAME
 * Name of the procedure.
 * 
 * 
 * NUM_INPUT_PARAMS
 * Number of input (IN) parameters for the stored procedure.
 * 
 * 
 * NUM_OUTPUT_PARAMS
 * Number of output (OUT) parameters for the stored procedure.
 * 
 * 
 * NUM_RESULT_SETS
 * Number of result sets returned by the stored procedure.
 * 
 * 
 * REMARKS
 * Any comments about the stored procedure.
 * 
 * 
 * PROCEDURE_TYPE
 * Always returns 1, indicating that the stored
 * procedure does not return a return value.
 * 
 */
function db2_procedures($connection, ?string $qualifier, string $schema, string $procedure) {}

/**
 * Returns a result set listing the unique row identifier columns for a table
 * @link https://php.net/manual/en/function.db2-special-columns.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string $schema 

 * The schema which contains the tables.
 * 
 * @param string $table_name 

 * The name of the table.
 * 
 * @param int $scope 

 * Integer value representing the minimum duration for which the
 * unique row identifier is valid. This can be one of the following
 * values:
 * 
 * Integer value
 * SQL constant
 * Description
 * 
 * 
 * 0
 * SQL_SCOPE_CURROW
 * Row identifier is valid only while the cursor is positioned
 * on the row.
 * 
 * 
 * 1
 * SQL_SCOPE_TRANSACTION
 * Row identifier is valid for the duration of the
 * transaction.
 * 
 * 
 * 2
 * SQL_SCOPE_SESSION
 * Row identifier is valid for the duration of the
 * connection.
 * 
 * 
 * @return resource|false A statement resource with a result set containing rows with unique
 * row identifier information for a table. The rows are composed of the
 * following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * SCOPE
 * 
 * 

 * 
 * Integer value
 * SQL constant
 * Description
 * 
 * 
 * 0
 * SQL_SCOPE_CURROW
 * Row identifier is valid only while the cursor is positioned
 * on the row.
 * 
 * 
 * 1
 * SQL_SCOPE_TRANSACTION
 * Row identifier is valid for the duration of the
 * transaction.
 * 
 * 
 * 2
 * SQL_SCOPE_SESSION
 * Row identifier is valid for the duration of the
 * connection.
 * 
 * 
 * 
 * 
 * 
 * COLUMN_NAME
 * Name of the unique column.
 * 
 * 
 * DATA_TYPE
 * SQL data type for the column.
 * 
 * 
 * TYPE_NAME
 * Character string representation of the SQL data type for the
 * column.
 * 
 * 
 * COLUMN_SIZE
 * An integer value representing the size of the column.
 * 
 * 
 * BUFFER_LENGTH
 * 
 * Maximum number of bytes necessary to store data from this column.
 * 
 * 
 * 
 * DECIMAL_DIGITS
 * 
 * The scale of the column, or null where scale is not applicable.
 * 
 * 
 * 
 * NUM_PREC_RADIX
 * 
 * An integer value of either 10 (representing
 * an exact numeric data type), 2 (representing an
 * approximate numeric data type), or null (representing a data type for
 * which radix is not applicable).
 * 
 * 
 * 
 * PSEUDO_COLUMN
 * Always returns 1.
 * 
 */
function db2_special_columns($connection, ?string $qualifier, string $schema, string $table_name, int $scope) {}

function db2_specialcolumns() {}

/**
 * Returns a result set listing the index and statistics for a table
 * @link https://php.net/manual/en/function.db2-statistics.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string|null $schema 

 * The schema that contains the targeted table. If this parameter is
 * null, the statistics and indexes are returned for the schema of the
 * current user.
 * 
 * @param string $table_name 

 * The name of the table.
 * 
 * @param bool $unique 

 * Whether to return the only the unique indexes or all the indexes in the table.
 * 
 * 

 * Return only the information for unique indexes on the table.
 * 
 * @return resource|false A statement resource with a result set containing rows describing
 * the statistics and indexes for the base tables matching the specified
 * parameters. The rows are composed of the following columns:
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Column name
Description
TABLE_CAT
The catalog that contains the table. The value is null if
 * this table does not have catalogs.
TABLE_SCHEM
Name of the schema that contains the table.
TABLE_NAME
Name of the table.
NON_UNIQUE

 * 
 * 

 * An boolean value representing whether the index prohibits unique
 * values, or whether the row represents statistics on the table itself:
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Return value
Parameter type
false (SQL_FALSE)
The index allows duplicate values.
true (SQL_TRUE)
The index values must be unique.
null
This row is statistics information for the table itself.
 * 
INDEX_QUALIFIER
A string value representing the qualifier that would have to be
 * prepended to INDEX_NAME to fully qualify the index.
INDEX_NAME
A string representing the name of the index.
TYPE

 * 

 * An integer value representing the type of information contained in
 * this row of the result set:
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Return value
Parameter type
0 (SQL_TABLE_STAT)
The row contains statistics about the table itself.
1 (SQL_INDEX_CLUSTERED)
The row contains information about a clustered index.
2 (SQL_INDEX_HASH)
The row contains information about a hashed index.
3 (SQL_INDEX_OTHER)
The row contains information about a type of index that
 * is neither clustered nor hashed.
 * 
ORDINAL_POSITION
The 1-indexed position of the column in the index. null if
 * the row contains statistics information about the table itself.
COLUMN_NAME
The name of the column in the index. null if the row
 * contains statistics information about the table itself.
ASC_OR_DESC

 * A if the column is sorted in ascending order,
 * D if the column is sorted in descending order,
 * null if the row contains statistics information about the table
 * itself.
 * 
CARDINALITY

 * 

 * If the row contains information about an index, this column contains
 * an integer value representing the number of unique values in the
 * index.
 * 
 * 

 * If the row contains information about the table itself, this column
 * contains an integer value representing the number of rows in the
 * table.
 * 
 * 
PAGES

 * 

 * If the row contains information about an index, this column contains
 * an integer value representing the number of pages used to store the
 * index.
 * 
 * 

 * If the row contains information about the table itself, this column
 * contains an integer value representing the number of pages used to
 * store the table.
 * 
 * 
FILTER_CONDITION
Always returns null.
 */
function db2_statistics($connection, ?string $qualifier, ?string $schema, string $table_name, bool $unique) {}

/**
 * Returns a result set listing the tables and associated privileges in a database
 * @link https://php.net/manual/en/function.db2-table-privileges.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string|null $schema 

 * The schema which contains the tables. This parameter accepts a
 * search pattern containing _ and %
 * as wildcards.
 * 
 * @param string|null $table_name 

 * The name of the table. This parameter accepts a search pattern
 * containing _ and % as wildcards.
 * 
 * @return resource|false A statement resource with a result set containing rows describing
 * the privileges for the tables that match the specified parameters. The rows
 * are composed of the following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * TABLE_CAT
 * The catalog that contains the table. The value is null if
 * this table does not have catalogs.
 * 
 * 
 * TABLE_SCHEM
 * Name of the schema that contains the table.
 * 
 * 
 * TABLE_NAME
 * Name of the table.
 * 
 * 
 * GRANTOR
 * Authorization ID of the user who granted the privilege.
 * 
 * 
 * GRANTEE
 * Authorization ID of the user to whom the privilege was
 * granted.
 * 
 * 
 * PRIVILEGE
 * 
 * The privilege that has been granted. This can be one of ALTER,
 * CONTROL, DELETE, INDEX, INSERT, REFERENCES, SELECT, or UPDATE.
 * 
 * 
 * 
 * IS_GRANTABLE
 * 
 * A string value of "YES" or "NO" indicating whether the grantee
 * can grant the privilege to other users.
 * 
 * 
 */
function db2_table_privileges($connection, ?string $qualifier = null, ?string $schema = null, ?string $table_name = null) {}

function db2_tableprivileges() {}

/**
 * Returns a result set listing the tables and associated metadata in a database
 * @link https://php.net/manual/en/function.db2-tables.php
 * @param resource $connection 

 * A valid connection to an IBM DB2, Cloudscape, or Apache Derby database.
 * 
 * @param string|null $qualifier 

 * A qualifier for DB2 databases running on OS/390 or z/OS servers. For
 * other databases, pass null or an empty string.
 * 
 * @param string|null $schema 

 * The schema which contains the tables. This parameter accepts a
 * search pattern containing _ and %
 * as wildcards.
 * 
 * @param string|null $table_name
 * @param string|null $table_type
 * @return resource|false A statement resource with a result set containing rows describing
 * the tables that match the specified parameters. The rows are composed of
 * the following columns:
 * 
 * Column name
 * Description
 * 
 * 
 * TABLE_CAT
 * The catalog that contains the table. The value is null if
 * this table does not have catalogs.
 * 
 * 
 * TABLE_SCHEM
 * Name of the schema that contains the table.
 * 
 * 
 * TABLE_NAME
 * Name of the table.
 * 
 * 
 * TABLE_TYPE
 * Table type identifier for the table.
 * 
 * 
 * REMARKS
 * Description of the table.
 * 
 */
function db2_tables($connection, ?string $qualifier = null, ?string $schema = null, ?string $table_name = null, ?string $table_type = null) {}

/**
 * Executes an SQL statement directly
 * @link https://php.net/manual/en/function.db2-exec.php
 * @param resource $connection 

 * A valid database connection resource variable as returned from
 * db2_connect or db2_pconnect.
 * 
 * @param string $statement 

 * An SQL statement. The statement cannot contain any parameter markers.
 * 
 * @param array $options 

 * An associative array containing statement options. You can use this
 * parameter to request a scrollable cursor on database servers that
 * support this functionality.
 * cursor
 * 
 * 

 * Passing the DB2_FORWARD_ONLY value requests a
 * forward-only cursor for this SQL statement. This is the default
 * type of cursor, and it is supported by all database servers. It is
 * also much faster than a scrollable cursor.
 * 
 * 

 * Passing the DB2_SCROLLABLE value requests a
 * scrollable cursor for this SQL statement. This type of cursor
 * enables you to fetch rows non-sequentially from the database
 * server. However, it is only supported by DB2 servers, and is much
 * slower than forward-only cursors.
 * 
 * @return resource|false A statement resource if the SQL statement was issued successfully,
 * or false if the database failed to execute the SQL statement.
 */
function db2_exec($connection, string $statement, array $options = []) {}

/**
 * Prepares an SQL statement to be executed
 * @link https://php.net/manual/en/function.db2-prepare.php
 * @param resource $connection 

 * A valid database connection resource variable as returned from
 * db2_connect or db2_pconnect.
 * 
 * @param string $statement 

 * An SQL statement, optionally containing one or more parameter markers..
 * 
 * @param array $options 

 * An associative array containing statement options. You can use this
 * parameter to request a scrollable cursor on database servers that
 * support this functionality.
 * cursor
 * 
 * 

 * Passing the DB2_FORWARD_ONLY value requests a
 * forward-only cursor for this SQL statement. This is the default
 * type of cursor, and it is supported by all database servers. It is
 * also much faster than a scrollable cursor.
 * 

 * 

 * Passing the DB2_SCROLLABLE value requests a
 * scrollable cursor for this SQL statement. This type of cursor
 * enables you to fetch rows non-sequentially from the database
 * server. However, it is only supported by DB2 servers, and is much
 * slower than forward-only cursors.
 * 
 * @return resource|false A statement resource if the SQL statement was successfully parsed and
 * prepared by the database server. Returns false if the database server
 * returned an error. You can determine which error was returned by calling
 * db2_stmt_error or db2_stmt_errormsg.
 */
function db2_prepare($connection, string $statement, array $options = []) {}

/**
 * Executes a prepared SQL statement
 * @link https://php.net/manual/en/function.db2-execute.php
 * @param resource $stmt 

 * A prepared statement returned from db2_prepare.
 * 
 * @param array $parameters 

 * An array of input parameters matching any parameter markers contained
 * in the prepared statement.
 * 
 * @return bool true on success or false on failure.
 */
function db2_execute($stmt, array $parameters = []): bool {}

/**
 * Returns a string containing the last SQL statement error message
 * @link https://php.net/manual/en/function.db2-stmt-errormsg.php
 * @param resource|null $stmt 

 * A valid statement resource or NULL.
 * 
 * @return string a string containing the error message and SQLCODE value for the
 * last error that occurred issuing an SQL statement.
 */
function db2_stmt_errormsg($stmt = null) {}

/**
 * Returns the last connection error message and SQLCODE value
 * @link https://php.net/manual/en/function.db2-conn-errormsg.php
 * @param resource|null $connection 

 * A connection resource associated with a connection that initially
 * succeeded, but which over time became invalid.
 * 
 * @return string a string containing the error message and SQLCODE value resulting
 * from a failed connection attempt. If there is no error associated with the last
 * connection attempt, db2_conn_errormsg returns an empty
 * string.
 */
function db2_conn_errormsg($connection = null) {}

/**
 * Returns a string containing the SQLSTATE returned by the last connection attempt
 * @link https://php.net/manual/en/function.db2-conn-error.php
 * @param resource|null $connection 

 * A connection resource associated with a connection that initially
 * succeeded, but which over time became invalid.
 * 
 * @return string the SQLSTATE value resulting from a failed connection attempt.
 * Returns an empty string if there is no error associated with the last
 * connection attempt.
 */
function db2_conn_error($connection = null) {}

/**
 * Returns a string containing the SQLSTATE returned by an SQL statement
 * @link https://php.net/manual/en/function.db2-stmt-error.php
 * @param resource|null $stmt 

 * A valid statement resource or NULL.
 * 
 * @return string a string containing an SQLSTATE value.
 */
function db2_stmt_error($stmt = null) {}

/**
 * Requests the next result set from a stored procedure
 * @link https://php.net/manual/en/function.db2-next-result.php
 * @param resource $stmt 

 * A prepared statement returned from db2_exec or
 * db2_execute.
 * 
 * @return resource|false A new statement resource containing the next result set if the
 * stored procedure returned another result set. Returns false if the stored
 * procedure did not return another result set.
 */
function db2_next_result($stmt) {}

/**
 * Returns the number of fields contained in a result set
 * @link https://php.net/manual/en/function.db2-num-fields.php
 * @param resource $stmt 

 * A valid statement resource containing a result set.
 * 
 * @return int|false An integer value representing the number of fields in the result
 * set associated with the specified statement resource. Returns false if
 * the statement resource is not a valid input value.
 */
function db2_num_fields($stmt): int|false {}

/**
 * Returns the number of rows affected by an SQL statement
 * @link https://php.net/manual/en/function.db2-num-rows.php
 * @param resource $stmt 

 * A valid stmt resource containing a result set.
 * 
 * @return int|false the number of rows affected by the last SQL statement issued by
 * the specified statement handle, or false in case of failure.
 */
function db2_num_rows($stmt): int|false {}

/**
 * Returns the name of the column in the result set
 * @link https://php.net/manual/en/function.db2-field-name.php
 * @param resource $stmt 

 * Specifies a statement resource containing a result set.
 * 
 * @param int|string $column 

 * Specifies the column in the result set. This can either be an integer
 * representing the 0-indexed position of the column, or a string
 * containing the name of the column.
 * 
 * @return string|false A string containing the name of the specified column. If the
 * specified column does not exist in the result
 * set, db2_field_name returns false.
 */
function db2_field_name($stmt, int|string $column): string|false {}

/**
 * Returns the maximum number of bytes required to display a column
 * @link https://php.net/manual/en/function.db2-field-display-size.php
 * @param resource $stmt 

 * Specifies a statement resource containing a result set.
 * 
 * @param int|string $column 

 * Specifies the column in the result set. This can either be an integer
 * representing the 0-indexed position of the column, or a string
 * containing the name of the column.
 * 
 * @return int|false An integer value with the maximum number of bytes required to
 * display the specified column. If the column does not exist in the result
 * set, db2_field_display_size returns false.
 */
function db2_field_display_size($stmt, int|string $column): int|false {}

/**
 * Returns the position of the named column in a result set
 * @link https://php.net/manual/en/function.db2-field-num.php
 * @param resource $stmt 

 * Specifies a statement resource containing a result set.
 * 
 * @param int|string $column 

 * Specifies the column in the result set. This can either be an integer
 * representing the 0-indexed position of the column, or a string
 * containing the name of the column.
 * 
 * @return int|false An integer containing the 0-indexed position of the named column in
 * the result set. If the specified column does not exist in the result set,
 * db2_field_num returns false.
 */
function db2_field_num($stmt, int|string $column): int|false {}

/**
 * Returns the precision of the indicated column in a result set
 * @link https://php.net/manual/en/function.db2-field-precision.php
 * @param resource $stmt 

 * Specifies a statement resource containing a result set.
 * 
 * @param int|string $column 

 * Specifies the column in the result set. This can either be an integer
 * representing the 0-indexed position of the column, or a string
 * containing the name of the column.
 * 
 * @return int|false An integer containing the precision of the specified column. If the
 * specified column does not exist in the result set,
 * db2_field_precision returns false.
 */
function db2_field_precision($stmt, int|string $column): int|false {}

/**
 * Returns the scale of the indicated column in a result set
 * @link https://php.net/manual/en/function.db2-field-scale.php
 * @param resource $stmt 

 * Specifies a statement resource containing a result set.
 * 
 * @param int|string $column 

 * Specifies the column in the result set. This can either be an integer
 * representing the 0-indexed position of the column, or a string
 * containing the name of the column.
 * 
 * @return int|false An integer containing the scale of the specified column. If the
 * specified column does not exist in the result set,
 * db2_field_scale returns false.
 */
function db2_field_scale($stmt, int|string $column): int|false {}

/**
 * Returns the data type of the indicated column in a result set
 * @link https://php.net/manual/en/function.db2-field-type.php
 * @param resource $stmt 

 * Specifies a statement resource containing a result set.
 * 
 * @param int|string $column 

 * Specifies the column in the result set. This can either be an integer
 * representing the 0-indexed position of the column, or a string
 * containing the name of the column.
 * 
 * @return string|false A string containing the defined data type of the specified column.
 * If the specified column does not exist in the result set,
 * db2_field_type returns false.
 */
function db2_field_type($stmt, int|string $column): string|false {}

/**
 * Returns the width of the current value of the indicated column in a result set
 * @link https://php.net/manual/en/function.db2-field-width.php
 * @param resource $stmt 

 * Specifies a statement resource containing a result set.
 * 
 * @param int|string $column 

 * Specifies the column in the result set. This can either be an integer
 * representing the 0-indexed position of the column, or a string
 * containing the name of the column.
 * 
 * @return int|false An integer containing the width of the specified character or
 * binary data type column in a result set. If the specified column does not
 * exist in the result set, db2_field_width returns
 * false.
 */
function db2_field_width($stmt, int|string $column): int|false {}

/**
 * Returns the cursor type used by a statement resource
 * @link https://php.net/manual/en/function.db2-cursor-type.php
 * @param resource $stmt 

 * A valid statement resource.
 * 
 * @return int either DB2_FORWARD_ONLY if the statement
 * resource uses a forward-only cursor or DB2_SCROLLABLE if
 * the statement resource uses a scrollable cursor.
 */
function db2_cursor_type($stmt): int {}

/**
 * Rolls back a transaction
 * @link https://php.net/manual/en/function.db2-rollback.php
 * @param resource $connection 

 * A valid database connection resource variable as returned from
 * db2_connect or db2_pconnect.
 * 
 * @return bool true on success or false on failure.
 */
function db2_rollback($connection): bool {}

/**
 * Frees resources associated with the indicated statement resource
 * @link https://php.net/manual/en/function.db2-free-stmt.php
 * @param resource $stmt 

 * A valid statement resource.
 * 
 * @return bool true on success or false on failure.
 */
function db2_free_stmt($stmt): bool {}

/**
 * Returns a single column from a row in the result set
 * @link https://php.net/manual/en/function.db2-result.php
 * @param resource $stmt 

 * A valid stmt resource.
 * 
 * @param int|string $column 

 * Either an integer mapping to the 0-indexed field in the result set, or
 * a string matching the name of the column.
 * 
 * @return mixed the value of the requested field if the field exists in the result
 * set. Returns NULL if the field does not exist, and issues a warning.
 */
function db2_result($stmt, int|string $column): mixed {}

/**
 * Sets the result set pointer to the next row or requested row
 * @link https://php.net/manual/en/function.db2-fetch-row.php
 * @param resource $stmt 

 * A valid stmt resource.
 * 
 * @param int $row_number 

 * With scrollable cursors, you can request a specific row number in the
 * result set. Row numbering is 1-indexed.
 * 
 * @return bool true if the requested row exists in the result set. Returns
 * false if the requested row does not exist in the result set.
 */
function db2_fetch_row($stmt, int $row_number = null) {}

/**
 * Returns an array, indexed by column name, representing a row in a result set
 * @link https://php.net/manual/en/function.db2-fetch-assoc.php
 * @param resource $stmt 

 * A valid stmt resource containing a result set.
 * 
 * @param int $row_number 

 * Requests a specific 1-indexed row from the result set. Passing this
 * parameter results in a PHP warning if the result set uses a
 * forward-only cursor.
 * 
 * @return array|false An associative array with column values indexed by the column name
 * representing the next or requested row in the result set. Returns false if
 * there are no rows left in the result set, or if the row requested by
 * row_number does not exist in the result set.
 */
function db2_fetch_assoc($stmt, int $row_number = null): array|false {}

/**
 * Returns an array, indexed by column position, representing a row in a result set
 * @link https://php.net/manual/en/function.db2-fetch-array.php
 * @param resource $stmt 

 * A valid stmt resource containing a result set.
 * 
 * @param int $row_number 

 * Requests a specific 1-indexed row from the result set. Passing this
 * parameter results in a PHP warning if the result set uses a
 * forward-only cursor.
 * 
 * @return array|false A 0-indexed array with column values indexed by the column position
 * representing the next or requested row in the result set. Returns false if
 * there are no rows left in the result set, or if the row requested by
 * row_number does not exist in the result set.
 */
function db2_fetch_array($stmt, int $row_number = null): array|false {}

/**
 * Returns an array, indexed by both column name and position, representing a row in a result set
 * @link https://php.net/manual/en/function.db2-fetch-both.php
 * @param resource $stmt 

 * A valid stmt resource containing a result set.
 * 
 * @param int $row_number 

 * Requests a specific 1-indexed row from the result set. Passing this
 * parameter results in a PHP warning if the result set uses a
 * forward-only cursor.
 * 
 * @return array|false An associative array with column values indexed by both the column
 * name and 0-indexed column number. The array represents the next or
 * requested row in the result set. Returns false if there are no rows left
 * in the result set, or if the row requested by
 * row_number does not exist in the result set.
 */
function db2_fetch_both($stmt, int $row_number = null): array|false {}

/**
 * Frees resources associated with a result set
 * @link https://php.net/manual/en/function.db2-free-result.php
 * @param resource $stmt 

 * A valid statement resource.
 * 
 * @return bool true on success or false on failure.
 */
function db2_free_result($stmt): bool {}

/**
 * Set options for connection or statement resources
 * @link https://php.net/manual/en/function.db2-set-option.php
 * @param resource $resource 

 * A valid statement resource as returned from
 * db2_prepare or a valid connection resource as
 * returned from db2_connect or
 * db2_pconnect.
 * 
 * @param array $options 

 * An associative array containing valid statement or connection
 * options. This parameter can be used to change autocommit values,
 * cursor types (scrollable or forward), and to specify the case of
 * the column names (lower, upper, or natural) that will appear in a
 * result set.
 * autocommit
 * 

 * Passing DB2_AUTOCOMMIT_ON turns
 * autocommit on for the specified connection resource.
 * 
 * 

 * Passing DB2_AUTOCOMMIT_OFF turns
 * autocommit off for the specified connection resource.
 * 
 * @param int $type 

 * An integer value that specifies the type of resource that was
 * passed into the function. The type of resource and this value
 * must correspond.
 * 

 * Passing 1 as the value specifies that
 * a connection resource has been passed into the function.
 * 
 * 

 * Passing any integer not equal to 1 as
 * the value specifies that a statement resource has been
 * passed into the function.
 * 
 * @return bool true on success or false on failure.
 */
function db2_set_option($resource, array $options, int $type): bool {}

function db2_setoption(): bool {}

/**
 * Returns an object with properties representing columns in the fetched row
 * @link https://php.net/manual/en/function.db2-fetch-object.php
 * @param resource $stmt 

 * A valid stmt resource containing a result set.
 * 
 * @param int $row_number 

 * Requests a specific 1-indexed row from the result set. Passing this
 * parameter results in a PHP warning if the result set uses a
 * forward-only cursor.
 * 
 * @return stdClass|false An object representing a single row in the result set. The
 * properties of the object map to the names of the columns in the result set.
 * 

 * 

 * The IBM DB2, Cloudscape, and Apache Derby database servers typically fold
 * column names to upper-case, so the object properties will reflect that case.
 * 
 * 

 * If your SELECT statement calls a scalar function to modify the value
 * of a column, the database servers return the column number as the name of
 * the column in the result set. If you prefer a more descriptive column name
 * and object property, you can use the AS clause to assign a name to the
 * column in the result set.
 * 
 * 

 * Returns false if no row was retrieved.
 */
function db2_fetch_object($stmt, int $row_number = null): stdClass|false {}

/**
 * Returns an object with properties that describe the DB2 database server
 * @link https://php.net/manual/en/function.db2-server-info.php
 * @param resource $connection 

 * Specifies an active DB2 client connection.
 * 
 * @return stdClass|false An object on a successful call. Returns false on failure.
 */
function db2_server_info($connection): stdClass|false {}

/**
 * Returns an object with properties that describe the DB2 database client
 * @link https://php.net/manual/en/function.db2-client-info.php
 * @param resource $connection 

 * Specifies an active DB2 client connection.
 * 
 * @return stdClass|false An object on a successful call. Returns false on failure.
 */
function db2_client_info($connection): stdClass|false {}

/**
 * Used to escape certain characters
 * @link https://php.net/manual/en/function.db2-escape-string.php
 * @param string $string_literal 

 * The string that contains special characters that need to be modified.
 * Characters that are prepended with a backslash are \x00,
 * \n, \r, \,
 * ', " and \x1a.
 * 
 * @return string string_literal with the special characters
 * noted above prepended with backslashes.
 */
function db2_escape_string(string $string_literal): string {}

/**
 * Gets a user defined size of LOB files with each invocation
 * @link https://php.net/manual/en/function.db2-lob-read.php
 * @param resource $stmt 

 * A valid stmt resource containing LOB data.
 * 
 * @param int $colnum 

 * A valid column number in the result set of the stmt resource.
 * 
 * @param int $length 

 * The size of the LOB data to be retrieved from the stmt resource.
 * 
 * @return string|false The amount of data the user specifies. Returns
 * false if the data cannot be retrieved.
 */
function db2_lob_read($stmt, int $colnum, int $length): string|false {}

/**
 * Retrieves an option value for a statement resource or a connection resource
 * @link https://php.net/manual/en/function.db2-get-option.php
 * @param resource $resource 

 * A valid statement resource as returned from
 * db2_prepare or a valid connection resource as
 * returned from db2_connect or
 * db2_pconnect.
 * 
 * @param string $option 

 * A valid statement or connection options. The following new options are available
 * as of ibm_db2 version 1.6.0. They provide useful tracking information
 * that can be set during execution with db2_get_option.
 * 
 * 

 * Note: Prior versions of ibm_db2 do not support these new options.
 * 
 * 

 * When the value in each option is being set, some servers might not handle
 * the entire length provided and might truncate the value.
 * 
 * 

 * To ensure that the data specified in each option is converted correctly
 * when transmitted to a host system, use only the characters A through Z,
 * 0 through 9, and the underscore (_) or period (.).
 * 
 * 

 * SQL_ATTR_INFO_USERID - A pointer to a null-terminated
 * character string used to identify the client user ID sent to the host
 * database server when using DB2 Connect.
 * 
 * 

 * Note: DB2 for z/OS and OS/390 servers support up to a length of 16 characters.
 * This user-id is not to be confused with the authentication user-id, it is for
 * identification purposes only and is not used for any authorization.
 * 
 * @return string|false The current setting of the connection attribute provided on success
 * or false on failure.
 */
function db2_get_option($resource, string $option): string|false {}

/**
 * Returns the auto generated ID of the last insert query that successfully executed on this connection.
 * @link https://php.net/manual/en/function.db2-last-insert-id.php
 * The result of this function is not affected by any of the following:
 * 
A single row INSERT statement with a VALUES clause for a table without an identity column.
 * 
A multiple row INSERT statement with a VALUES clause.
 * 
An INSERT statement with a fullselect.
 * 
A ROLLBACK TO SAVEPOINT statement.
 * 
 * @param resource $resource A valid connection resource as returned from db2_connect() or db2_pconnect().
 * The value of this parameter cannot be a statement resource or result set resource.
 * @return string|null Returns the auto generated ID of last insert query that successfully executed on this connection
 *                     or NULL if no ID was found.
 */
function db2_last_insert_id($resource): ?string {}

/**
 * Specifies that binary data shall be returned as is. This is the default
 * mode.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_BINARY', 1);

/**
 * Specifies that binary data shall be converted to a hexadecimal encoding
 * and returned as an ASCII string.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_CONVERT', 2);

/**
 * Specifies that binary data shall be converted to a null value.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_PASSTHRU', 3);

/**
 * Specifies a scrollable cursor for a statement resource. This mode enables
 * random access to rows in a result set, but currently is supported only by
 * IBM DB2 Universal Database.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_SCROLLABLE', 1);

/**
 * Specifies a forward-only cursor for a statement resource. This is the
 * default cursor type and is supported on all database servers.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_FORWARD_ONLY', 0);

/**
 * Specifies the PHP variable should be bound as an IN parameter for a
 * stored procedure.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_PARAM_IN', 1);

/**
 * Specifies the PHP variable should be bound as an OUT parameter for a
 * stored procedure.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_PARAM_OUT', 4);

/**
 * Specifies the PHP variable should be bound as an INOUT parameter for a
 * stored procedure.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_PARAM_INOUT', 2);

/**
 * Specifies that the column should be bound directly to a file for input.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_PARAM_FILE', 11);

/**
 * Specifies that autocommit should be turned on.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_AUTOCOMMIT_ON', 1);

/**
 * Specifies that autocommit should be turned off.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_AUTOCOMMIT_OFF', 0);

/**
 * Specifies that deferred prepare should be turned on for the specified statement resource.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_DEFERRED_PREPARE_ON', 1);

/**
 * Specifies that deferred prepare should be turned off for the specified statement resource.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_DEFERRED_PREPARE_OFF', 0);

/**
 * Specifies that the variable should be bound as a DOUBLE, FLOAT, or REAL
 * data type.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_DOUBLE', 8);

/**
 * Specifies that the variable should be bound as a SMALLINT, INTEGER, or
 * BIGINT data type.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_LONG', 4);

/**
 * Specifies that the variable should be bound as a CHAR or VARCHAR data type.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_CHAR', 1);
define('DB2_XML', -370);

/**
 * Specifies that column names will be returned in their natural case.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_CASE_NATURAL', 0);

/**
 * Specifies that column names will be returned in lower case.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_CASE_LOWER', 1);

/**
 * Specifies that column names will be returned in upper case.
 * @link https://php.net/manual/en/ibm-db2.constants.php
 */
define('DB2_CASE_UPPER', 2);

// End of ibm_db2 v.1.6.0
TRUE if PHP is running as an Apache 1 module, the Apache version is non-multithreaded, and the child_terminate PHP directive is enabled (disabled by default). If these conditions are not met, FALSE is returned and an error of level E_WARNING is generated.
 */
function apache_child_terminate() {}

/**
 * Get a list of loaded Apache modules
 * @link https://php.net/manual/en/function.apache-get-modules.php
 * @return array of loaded Apache modules.
 */
#[Pure]
function apache_get_modules() {}

/**
 * Fetch the Apache version
 * @link https://php.net/manual/en/function.apache-get-version.php
 * @return string|false the Apache version on success or FALSE on failure.
 */
#[Pure]
function apache_get_version() {}

/**
 * Get an Apache subprocess_env variable
 * Retrieve an Apache environment variable specified by $variable.
 * This function requires Apache 2 otherwise it's undefined.
 * @link https://php.net/manual/en/function.apache-getenv.php
 * @param string $variable 

 * The Apache environment variable.
 * 
 * @param bool $walk_to_top 

 * Whether to get the top-level variable available to all Apache layers.
 * 
 * @return string|false The value of the Apache environment variable on success, or FALSE on failure.
 */
#[Pure]
function apache_getenv($variable, $walk_to_top = false) {}

/**
 * Perform a partial request for the specified URI and return all info about it
 * This performs a partial request for a URI. It goes just far enough to obtain all the important information about the given resource.
 * This function is supported when PHP is installed as an Apache module or by the NSAPI server module in Netscape/iPlanet/SunONE webservers.
 * @link https://php.net/manual/en/function.apache-lookup-uri.php
 * @param string $filename 

 * The filename (URI) that's being requested.
 * 
 * @return object of related URI information.
 */
function apache_lookup_uri($filename) {}

/**
 * Get and set apache request notes
 * This function is a wrapper for Apache's table_get and table_set. It edits the table of notes that exists during a request. The table's purpose is to allow Apache modules to communicate.
 * The main use for apache_note() is to pass information from one module to another within the same request.
 * @link https://php.net/manual/en/function.apache-note.php
 * @param string $note_name 

 * The name of the note.
 * 
 * @param string $note_value 

 * The value of the note.
 * 
 * @return string|false If called with one argument, it returns the current value of note note_name. If called with two arguments, it sets the value of note note_name to note_value and returns the previous value of note note_name. If the note cannot be retrieved, FALSE is returned.
 */
function apache_note($note_name, $note_value = '') {}

/**
 * Reset the Apache write timer
 * apache_reset_timeout() resets the Apache write timer, which defaults to 300 seconds. With set_time_limit(0); ignore_user_abort(true) and periodic apache_reset_timeout() calls, Apache can theoretically run forever.
 * This function requires Apache 1.
 * @link https://php.net/manual/en/function.apache-reset-timeout.php
 * @return bool TRUE on success or FALSE on failure.
 */
function apache_reset_timeout() {}

/**
 * Fetch all HTTP response headers
 * @link https://php.net/manual/en/function.apache-response-headers.php
 * @return array|false An array of all Apache response headers on success or FALSE on failure.
 */
function apache_response_headers() {}

/**
 * Sets the value of the Apache environment variable specified by variable.
 * Note: When setting an Apache environment variable, the corresponding $_SERVER variable is not changed.
 * @link https://php.net/manual/en/function.apache-setenv.php
 * @param string $variable 

 * The environment variable that's being set.
 * 
 * @param string $value 

 * The new variable value.
 * 
 * @param bool $walk_to_top 

 * Whether to set the top-level variable available to all Apache layers.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function apache_setenv($variable, $value, $walk_to_top = false) {}

/**
 * Perform an Apache sub-request
 * virtual() is an Apache-specific function which is similar to  in mod_include. It performs an Apache sub-request. It is useful for including CGI scripts or .shtml files, or anything else that you would parse through Apache. Note that for a CGI script, the script must generate valid CGI headers. At the minimum that means it must generate a Content-Type header.
 * To run the sub-request, all buffers are terminated and flushed to the browser, pending headers are sent too.
 * This function is supported when PHP is installed as an Apache module or by the NSAPI server module in Netscape/iPlanet/SunONE webservers.
 * @link https://secure.php.net/manual/en/function.virtual.php
 * @param string $filename 

 * The file that the virtual command will be performed on.
 * 
 * @return bool Performs the virtual command on success, or returns FALSE on failure.
 */
function virtual($filename) {}
IntlChar provides access to a number of utility methods that can be used to access information about Unicode characters.

 * 
The methods and constants adhere closely to the names and behavior used by the underlying ICU library.
 * @since 7.0
 */
class IntlChar
{
    public const UNICODE_VERSION = 13.0;
    public const CODEPOINT_MIN = 0;
    public const CODEPOINT_MAX = 1114111;
    public const FOLD_CASE_DEFAULT = 0;
    public const FOLD_CASE_EXCLUDE_SPECIAL_I = 1;
    public const PROPERTY_ALPHABETIC = 0;
    public const PROPERTY_BINARY_START = 0;
    public const PROPERTY_ASCII_HEX_DIGIT = 1;
    public const PROPERTY_BIDI_CONTROL = 2;
    public const PROPERTY_BIDI_MIRRORED = 3;
    public const PROPERTY_DASH = 4;
    public const PROPERTY_DEFAULT_IGNORABLE_CODE_POINT = 5;
    public const PROPERTY_DEPRECATED = 6;
    public const PROPERTY_DIACRITIC = 7;
    public const PROPERTY_EXTENDER = 8;
    public const PROPERTY_FULL_COMPOSITION_EXCLUSION = 9;
    public const PROPERTY_GRAPHEME_BASE = 10;
    public const PROPERTY_GRAPHEME_EXTEND = 11;
    public const PROPERTY_GRAPHEME_LINK = 12;
    public const PROPERTY_HEX_DIGIT = 13;
    public const PROPERTY_HYPHEN = 14;
    public const PROPERTY_ID_CONTINUE = 15;
    public const PROPERTY_ID_START = 16;
    public const PROPERTY_IDEOGRAPHIC = 17;
    public const PROPERTY_IDS_BINARY_OPERATOR = 18;
    public const PROPERTY_IDS_TRINARY_OPERATOR = 19;
    public const PROPERTY_JOIN_CONTROL = 20;
    public const PROPERTY_LOGICAL_ORDER_EXCEPTION = 21;
    public const PROPERTY_LOWERCASE = 22;
    public const PROPERTY_MATH = 23;
    public const PROPERTY_NONCHARACTER_CODE_POINT = 24;
    public const PROPERTY_QUOTATION_MARK = 25;
    public const PROPERTY_RADICAL = 26;
    public const PROPERTY_SOFT_DOTTED = 27;
    public const PROPERTY_TERMINAL_PUNCTUATION = 28;
    public const PROPERTY_UNIFIED_IDEOGRAPH = 29;
    public const PROPERTY_UPPERCASE = 30;
    public const PROPERTY_WHITE_SPACE = 31;
    public const PROPERTY_XID_CONTINUE = 32;
    public const PROPERTY_XID_START = 33;
    public const PROPERTY_CASE_SENSITIVE = 34;
    public const PROPERTY_S_TERM = 35;
    public const PROPERTY_VARIATION_SELECTOR = 36;
    public const PROPERTY_NFD_INERT = 37;
    public const PROPERTY_NFKD_INERT = 38;
    public const PROPERTY_NFC_INERT = 39;
    public const PROPERTY_NFKC_INERT = 40;
    public const PROPERTY_SEGMENT_STARTER = 41;
    public const PROPERTY_PATTERN_SYNTAX = 42;
    public const PROPERTY_PATTERN_WHITE_SPACE = 43;
    public const PROPERTY_POSIX_ALNUM = 44;
    public const PROPERTY_POSIX_BLANK = 45;
    public const PROPERTY_POSIX_GRAPH = 46;
    public const PROPERTY_POSIX_PRINT = 47;
    public const PROPERTY_POSIX_XDIGIT = 48;
    public const PROPERTY_CASED = 49;
    public const PROPERTY_CASE_IGNORABLE = 50;
    public const PROPERTY_CHANGES_WHEN_LOWERCASED = 51;
    public const PROPERTY_CHANGES_WHEN_UPPERCASED = 52;
    public const PROPERTY_CHANGES_WHEN_TITLECASED = 53;
    public const PROPERTY_CHANGES_WHEN_CASEFOLDED = 54;
    public const PROPERTY_CHANGES_WHEN_CASEMAPPED = 55;
    public const PROPERTY_CHANGES_WHEN_NFKC_CASEFOLDED = 56;
    public const PROPERTY_BINARY_LIMIT = 65;
    public const PROPERTY_BIDI_CLASS = 4096;
    public const PROPERTY_INT_START = 4096;
    public const PROPERTY_BLOCK = 4097;
    public const PROPERTY_CANONICAL_COMBINING_CLASS = 4098;
    public const PROPERTY_DECOMPOSITION_TYPE = 4099;
    public const PROPERTY_EAST_ASIAN_WIDTH = 4100;
    public const PROPERTY_GENERAL_CATEGORY = 4101;
    public const PROPERTY_JOINING_GROUP = 4102;
    public const PROPERTY_JOINING_TYPE = 4103;
    public const PROPERTY_LINE_BREAK = 4104;
    public const PROPERTY_NUMERIC_TYPE = 4105;
    public const PROPERTY_SCRIPT = 4106;
    public const PROPERTY_HANGUL_SYLLABLE_TYPE = 4107;
    public const PROPERTY_NFD_QUICK_CHECK = 4108;
    public const PROPERTY_NFKD_QUICK_CHECK = 4109;
    public const PROPERTY_NFC_QUICK_CHECK = 4110;
    public const PROPERTY_NFKC_QUICK_CHECK = 4111;
    public const PROPERTY_LEAD_CANONICAL_COMBINING_CLASS = 4112;
    public const PROPERTY_TRAIL_CANONICAL_COMBINING_CLASS = 4113;
    public const PROPERTY_GRAPHEME_CLUSTER_BREAK = 4114;
    public const PROPERTY_SENTENCE_BREAK = 4115;
    public const PROPERTY_WORD_BREAK = 4116;
    public const PROPERTY_BIDI_PAIRED_BRACKET_TYPE = 4117;
    public const PROPERTY_INT_LIMIT = 4121;
    public const PROPERTY_GENERAL_CATEGORY_MASK = 8192;
    public const PROPERTY_MASK_START = 8192;
    public const PROPERTY_MASK_LIMIT = 8193;
    public const PROPERTY_NUMERIC_VALUE = 12288;
    public const PROPERTY_DOUBLE_START = 12288;
    public const PROPERTY_DOUBLE_LIMIT = 12289;
    public const PROPERTY_AGE = 16384;
    public const PROPERTY_STRING_START = 16384;
    public const PROPERTY_BIDI_MIRRORING_GLYPH = 16385;
    public const PROPERTY_CASE_FOLDING = 16386;
    public const PROPERTY_ISO_COMMENT = 16387;
    public const PROPERTY_LOWERCASE_MAPPING = 16388;
    public const PROPERTY_NAME = 16389;
    public const PROPERTY_SIMPLE_CASE_FOLDING = 16390;
    public const PROPERTY_SIMPLE_LOWERCASE_MAPPING = 16391;
    public const PROPERTY_SIMPLE_TITLECASE_MAPPING = 16392;
    public const PROPERTY_SIMPLE_UPPERCASE_MAPPING = 16393;
    public const PROPERTY_TITLECASE_MAPPING = 16394;
    public const PROPERTY_UNICODE_1_NAME = 16395;
    public const PROPERTY_UPPERCASE_MAPPING = 16396;
    public const PROPERTY_BIDI_PAIRED_BRACKET = 16397;
    public const PROPERTY_STRING_LIMIT = 16398;
    public const PROPERTY_SCRIPT_EXTENSIONS = 28672;
    public const PROPERTY_OTHER_PROPERTY_START = 28672;
    public const PROPERTY_OTHER_PROPERTY_LIMIT = 28673;
    public const PROPERTY_INVALID_CODE = -1;
    public const CHAR_CATEGORY_UNASSIGNED = 0;
    public const CHAR_CATEGORY_GENERAL_OTHER_TYPES = 0;
    public const CHAR_CATEGORY_UPPERCASE_LETTER = 1;
    public const CHAR_CATEGORY_LOWERCASE_LETTER = 2;
    public const CHAR_CATEGORY_TITLECASE_LETTER = 3;
    public const CHAR_CATEGORY_MODIFIER_LETTER = 4;
    public const CHAR_CATEGORY_OTHER_LETTER = 5;
    public const CHAR_CATEGORY_NON_SPACING_MARK = 6;
    public const CHAR_CATEGORY_ENCLOSING_MARK = 7;
    public const CHAR_CATEGORY_COMBINING_SPACING_MARK = 8;
    public const CHAR_CATEGORY_DECIMAL_DIGIT_NUMBER = 9;
    public const CHAR_CATEGORY_LETTER_NUMBER = 10;
    public const CHAR_CATEGORY_OTHER_NUMBER = 11;
    public const CHAR_CATEGORY_SPACE_SEPARATOR = 12;
    public const CHAR_CATEGORY_LINE_SEPARATOR = 13;
    public const CHAR_CATEGORY_PARAGRAPH_SEPARATOR = 14;
    public const CHAR_CATEGORY_CONTROL_CHAR = 15;
    public const CHAR_CATEGORY_FORMAT_CHAR = 16;
    public const CHAR_CATEGORY_PRIVATE_USE_CHAR = 17;
    public const CHAR_CATEGORY_SURROGATE = 18;
    public const CHAR_CATEGORY_DASH_PUNCTUATION = 19;
    public const CHAR_CATEGORY_START_PUNCTUATION = 20;
    public const CHAR_CATEGORY_END_PUNCTUATION = 21;
    public const CHAR_CATEGORY_CONNECTOR_PUNCTUATION = 22;
    public const CHAR_CATEGORY_OTHER_PUNCTUATION = 23;
    public const CHAR_CATEGORY_MATH_SYMBOL = 24;
    public const CHAR_CATEGORY_CURRENCY_SYMBOL = 25;
    public const CHAR_CATEGORY_MODIFIER_SYMBOL = 26;
    public const CHAR_CATEGORY_OTHER_SYMBOL = 27;
    public const CHAR_CATEGORY_INITIAL_PUNCTUATION = 28;
    public const CHAR_CATEGORY_FINAL_PUNCTUATION = 29;
    public const CHAR_CATEGORY_CHAR_CATEGORY_COUNT = 30;
    public const CHAR_DIRECTION_LEFT_TO_RIGHT = 0;
    public const CHAR_DIRECTION_RIGHT_TO_LEFT = 1;
    public const CHAR_DIRECTION_EUROPEAN_NUMBER = 2;
    public const CHAR_DIRECTION_EUROPEAN_NUMBER_SEPARATOR = 3;
    public const CHAR_DIRECTION_EUROPEAN_NUMBER_TERMINATOR = 4;
    public const CHAR_DIRECTION_ARABIC_NUMBER = 5;
    public const CHAR_DIRECTION_COMMON_NUMBER_SEPARATOR = 6;
    public const CHAR_DIRECTION_BLOCK_SEPARATOR = 7;
    public const CHAR_DIRECTION_SEGMENT_SEPARATOR = 8;
    public const CHAR_DIRECTION_WHITE_SPACE_NEUTRAL = 9;
    public const CHAR_DIRECTION_OTHER_NEUTRAL = 10;
    public const CHAR_DIRECTION_LEFT_TO_RIGHT_EMBEDDING = 11;
    public const CHAR_DIRECTION_LEFT_TO_RIGHT_OVERRIDE = 12;
    public const CHAR_DIRECTION_RIGHT_TO_LEFT_ARABIC = 13;
    public const CHAR_DIRECTION_RIGHT_TO_LEFT_EMBEDDING = 14;
    public const CHAR_DIRECTION_RIGHT_TO_LEFT_OVERRIDE = 15;
    public const CHAR_DIRECTION_POP_DIRECTIONAL_FORMAT = 16;
    public const CHAR_DIRECTION_DIR_NON_SPACING_MARK = 17;
    public const CHAR_DIRECTION_BOUNDARY_NEUTRAL = 18;
    public const CHAR_DIRECTION_FIRST_STRONG_ISOLATE = 19;
    public const CHAR_DIRECTION_LEFT_TO_RIGHT_ISOLATE = 20;
    public const CHAR_DIRECTION_RIGHT_TO_LEFT_ISOLATE = 21;
    public const CHAR_DIRECTION_POP_DIRECTIONAL_ISOLATE = 22;
    public const CHAR_DIRECTION_CHAR_DIRECTION_COUNT = 23;
    public const BLOCK_CODE_NO_BLOCK = 0;
    public const BLOCK_CODE_BASIC_LATIN = 1;
    public const BLOCK_CODE_LATIN_1_SUPPLEMENT = 2;
    public const BLOCK_CODE_LATIN_EXTENDED_A = 3;
    public const BLOCK_CODE_LATIN_EXTENDED_B = 4;
    public const BLOCK_CODE_IPA_EXTENSIONS = 5;
    public const BLOCK_CODE_SPACING_MODIFIER_LETTERS = 6;
    public const BLOCK_CODE_COMBINING_DIACRITICAL_MARKS = 7;
    public const BLOCK_CODE_GREEK = 8;
    public const BLOCK_CODE_CYRILLIC = 9;
    public const BLOCK_CODE_ARMENIAN = 10;
    public const BLOCK_CODE_HEBREW = 11;
    public const BLOCK_CODE_ARABIC = 12;
    public const BLOCK_CODE_SYRIAC = 13;
    public const BLOCK_CODE_THAANA = 14;
    public const BLOCK_CODE_DEVANAGARI = 15;
    public const BLOCK_CODE_BENGALI = 16;
    public const BLOCK_CODE_GURMUKHI = 17;
    public const BLOCK_CODE_GUJARATI = 18;
    public const BLOCK_CODE_ORIYA = 19;
    public const BLOCK_CODE_TAMIL = 20;
    public const BLOCK_CODE_TELUGU = 21;
    public const BLOCK_CODE_KANNADA = 22;
    public const BLOCK_CODE_MALAYALAM = 23;
    public const BLOCK_CODE_SINHALA = 24;
    public const BLOCK_CODE_THAI = 25;
    public const BLOCK_CODE_LAO = 26;
    public const BLOCK_CODE_TIBETAN = 27;
    public const BLOCK_CODE_MYANMAR = 28;
    public const BLOCK_CODE_GEORGIAN = 29;
    public const BLOCK_CODE_HANGUL_JAMO = 30;
    public const BLOCK_CODE_ETHIOPIC = 31;
    public const BLOCK_CODE_CHEROKEE = 32;
    public const BLOCK_CODE_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS = 33;
    public const BLOCK_CODE_OGHAM = 34;
    public const BLOCK_CODE_RUNIC = 35;
    public const BLOCK_CODE_KHMER = 36;
    public const BLOCK_CODE_MONGOLIAN = 37;
    public const BLOCK_CODE_LATIN_EXTENDED_ADDITIONAL = 38;
    public const BLOCK_CODE_GREEK_EXTENDED = 39;
    public const BLOCK_CODE_GENERAL_PUNCTUATION = 40;
    public const BLOCK_CODE_SUPERSCRIPTS_AND_SUBSCRIPTS = 41;
    public const BLOCK_CODE_CURRENCY_SYMBOLS = 42;
    public const BLOCK_CODE_COMBINING_MARKS_FOR_SYMBOLS = 43;
    public const BLOCK_CODE_LETTERLIKE_SYMBOLS = 44;
    public const BLOCK_CODE_NUMBER_FORMS = 45;
    public const BLOCK_CODE_ARROWS = 46;
    public const BLOCK_CODE_MATHEMATICAL_OPERATORS = 47;
    public const BLOCK_CODE_MISCELLANEOUS_TECHNICAL = 48;
    public const BLOCK_CODE_CONTROL_PICTURES = 49;
    public const BLOCK_CODE_OPTICAL_CHARACTER_RECOGNITION = 50;
    public const BLOCK_CODE_ENCLOSED_ALPHANUMERICS = 51;
    public const BLOCK_CODE_BOX_DRAWING = 52;
    public const BLOCK_CODE_BLOCK_ELEMENTS = 53;
    public const BLOCK_CODE_GEOMETRIC_SHAPES = 54;
    public const BLOCK_CODE_MISCELLANEOUS_SYMBOLS = 55;
    public const BLOCK_CODE_DINGBATS = 56;
    public const BLOCK_CODE_BRAILLE_PATTERNS = 57;
    public const BLOCK_CODE_CJK_RADICALS_SUPPLEMENT = 58;
    public const BLOCK_CODE_KANGXI_RADICALS = 59;
    public const BLOCK_CODE_IDEOGRAPHIC_DESCRIPTION_CHARACTERS = 60;
    public const BLOCK_CODE_CJK_SYMBOLS_AND_PUNCTUATION = 61;
    public const BLOCK_CODE_HIRAGANA = 62;
    public const BLOCK_CODE_KATAKANA = 63;
    public const BLOCK_CODE_BOPOMOFO = 64;
    public const BLOCK_CODE_HANGUL_COMPATIBILITY_JAMO = 65;
    public const BLOCK_CODE_KANBUN = 66;
    public const BLOCK_CODE_BOPOMOFO_EXTENDED = 67;
    public const BLOCK_CODE_ENCLOSED_CJK_LETTERS_AND_MONTHS = 68;
    public const BLOCK_CODE_CJK_COMPATIBILITY = 69;
    public const BLOCK_CODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A = 70;
    public const BLOCK_CODE_CJK_UNIFIED_IDEOGRAPHS = 71;
    public const BLOCK_CODE_YI_SYLLABLES = 72;
    public const BLOCK_CODE_YI_RADICALS = 73;
    public const BLOCK_CODE_HANGUL_SYLLABLES = 74;
    public const BLOCK_CODE_HIGH_SURROGATES = 75;
    public const BLOCK_CODE_HIGH_PRIVATE_USE_SURROGATES = 76;
    public const BLOCK_CODE_LOW_SURROGATES = 77;
    public const BLOCK_CODE_PRIVATE_USE_AREA = 78;
    public const BLOCK_CODE_PRIVATE_USE = 78;
    public const BLOCK_CODE_CJK_COMPATIBILITY_IDEOGRAPHS = 79;
    public const BLOCK_CODE_ALPHABETIC_PRESENTATION_FORMS = 80;
    public const BLOCK_CODE_ARABIC_PRESENTATION_FORMS_A = 81;
    public const BLOCK_CODE_COMBINING_HALF_MARKS = 82;
    public const BLOCK_CODE_CJK_COMPATIBILITY_FORMS = 83;
    public const BLOCK_CODE_SMALL_FORM_VARIANTS = 84;
    public const BLOCK_CODE_ARABIC_PRESENTATION_FORMS_B = 85;
    public const BLOCK_CODE_SPECIALS = 86;
    public const BLOCK_CODE_HALFWIDTH_AND_FULLWIDTH_FORMS = 87;
    public const BLOCK_CODE_OLD_ITALIC = 88;
    public const BLOCK_CODE_GOTHIC = 89;
    public const BLOCK_CODE_DESERET = 90;
    public const BLOCK_CODE_BYZANTINE_MUSICAL_SYMBOLS = 91;
    public const BLOCK_CODE_MUSICAL_SYMBOLS = 92;
    public const BLOCK_CODE_MATHEMATICAL_ALPHANUMERIC_SYMBOLS = 93;
    public const BLOCK_CODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B = 94;
    public const BLOCK_CODE_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT = 95;
    public const BLOCK_CODE_TAGS = 96;
    public const BLOCK_CODE_CYRILLIC_SUPPLEMENT = 97;
    public const BLOCK_CODE_CYRILLIC_SUPPLEMENTARY = 97;
    public const BLOCK_CODE_TAGALOG = 98;
    public const BLOCK_CODE_HANUNOO = 99;
    public const BLOCK_CODE_BUHID = 100;
    public const BLOCK_CODE_TAGBANWA = 101;
    public const BLOCK_CODE_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A = 102;
    public const BLOCK_CODE_SUPPLEMENTAL_ARROWS_A = 103;
    public const BLOCK_CODE_SUPPLEMENTAL_ARROWS_B = 104;
    public const BLOCK_CODE_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B = 105;
    public const BLOCK_CODE_SUPPLEMENTAL_MATHEMATICAL_OPERATORS = 106;
    public const BLOCK_CODE_KATAKANA_PHONETIC_EXTENSIONS = 107;
    public const BLOCK_CODE_VARIATION_SELECTORS = 108;
    public const BLOCK_CODE_SUPPLEMENTARY_PRIVATE_USE_AREA_A = 109;
    public const BLOCK_CODE_SUPPLEMENTARY_PRIVATE_USE_AREA_B = 110;
    public const BLOCK_CODE_LIMBU = 111;
    public const BLOCK_CODE_TAI_LE = 112;
    public const BLOCK_CODE_KHMER_SYMBOLS = 113;
    public const BLOCK_CODE_PHONETIC_EXTENSIONS = 114;
    public const BLOCK_CODE_MISCELLANEOUS_SYMBOLS_AND_ARROWS = 115;
    public const BLOCK_CODE_YIJING_HEXAGRAM_SYMBOLS = 116;
    public const BLOCK_CODE_LINEAR_B_SYLLABARY = 117;
    public const BLOCK_CODE_LINEAR_B_IDEOGRAMS = 118;
    public const BLOCK_CODE_AEGEAN_NUMBERS = 119;
    public const BLOCK_CODE_UGARITIC = 120;
    public const BLOCK_CODE_SHAVIAN = 121;
    public const BLOCK_CODE_OSMANYA = 122;
    public const BLOCK_CODE_CYPRIOT_SYLLABARY = 123;
    public const BLOCK_CODE_TAI_XUAN_JING_SYMBOLS = 124;
    public const BLOCK_CODE_VARIATION_SELECTORS_SUPPLEMENT = 125;
    public const BLOCK_CODE_ANCIENT_GREEK_MUSICAL_NOTATION = 126;
    public const BLOCK_CODE_ANCIENT_GREEK_NUMBERS = 127;
    public const BLOCK_CODE_ARABIC_SUPPLEMENT = 128;
    public const BLOCK_CODE_BUGINESE = 129;
    public const BLOCK_CODE_CJK_STROKES = 130;
    public const BLOCK_CODE_COMBINING_DIACRITICAL_MARKS_SUPPLEMENT = 131;
    public const BLOCK_CODE_COPTIC = 132;
    public const BLOCK_CODE_ETHIOPIC_EXTENDED = 133;
    public const BLOCK_CODE_ETHIOPIC_SUPPLEMENT = 134;
    public const BLOCK_CODE_GEORGIAN_SUPPLEMENT = 135;
    public const BLOCK_CODE_GLAGOLITIC = 136;
    public const BLOCK_CODE_KHAROSHTHI = 137;
    public const BLOCK_CODE_MODIFIER_TONE_LETTERS = 138;
    public const BLOCK_CODE_NEW_TAI_LUE = 139;
    public const BLOCK_CODE_OLD_PERSIAN = 140;
    public const BLOCK_CODE_PHONETIC_EXTENSIONS_SUPPLEMENT = 141;
    public const BLOCK_CODE_SUPPLEMENTAL_PUNCTUATION = 142;
    public const BLOCK_CODE_SYLOTI_NAGRI = 143;
    public const BLOCK_CODE_TIFINAGH = 144;
    public const BLOCK_CODE_VERTICAL_FORMS = 145;
    public const BLOCK_CODE_NKO = 146;
    public const BLOCK_CODE_BALINESE = 147;
    public const BLOCK_CODE_LATIN_EXTENDED_C = 148;
    public const BLOCK_CODE_LATIN_EXTENDED_D = 149;
    public const BLOCK_CODE_PHAGS_PA = 150;
    public const BLOCK_CODE_PHOENICIAN = 151;
    public const BLOCK_CODE_CUNEIFORM = 152;
    public const BLOCK_CODE_CUNEIFORM_NUMBERS_AND_PUNCTUATION = 153;
    public const BLOCK_CODE_COUNTING_ROD_NUMERALS = 154;
    public const BLOCK_CODE_SUNDANESE = 155;
    public const BLOCK_CODE_LEPCHA = 156;
    public const BLOCK_CODE_OL_CHIKI = 157;
    public const BLOCK_CODE_CYRILLIC_EXTENDED_A = 158;
    public const BLOCK_CODE_VAI = 159;
    public const BLOCK_CODE_CYRILLIC_EXTENDED_B = 160;
    public const BLOCK_CODE_SAURASHTRA = 161;
    public const BLOCK_CODE_KAYAH_LI = 162;
    public const BLOCK_CODE_REJANG = 163;
    public const BLOCK_CODE_CHAM = 164;
    public const BLOCK_CODE_ANCIENT_SYMBOLS = 165;
    public const BLOCK_CODE_PHAISTOS_DISC = 166;
    public const BLOCK_CODE_LYCIAN = 167;
    public const BLOCK_CODE_CARIAN = 168;
    public const BLOCK_CODE_LYDIAN = 169;
    public const BLOCK_CODE_MAHJONG_TILES = 170;
    public const BLOCK_CODE_DOMINO_TILES = 171;
    public const BLOCK_CODE_SAMARITAN = 172;
    public const BLOCK_CODE_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED = 173;
    public const BLOCK_CODE_TAI_THAM = 174;
    public const BLOCK_CODE_VEDIC_EXTENSIONS = 175;
    public const BLOCK_CODE_LISU = 176;
    public const BLOCK_CODE_BAMUM = 177;
    public const BLOCK_CODE_COMMON_INDIC_NUMBER_FORMS = 178;
    public const BLOCK_CODE_DEVANAGARI_EXTENDED = 179;
    public const BLOCK_CODE_HANGUL_JAMO_EXTENDED_A = 180;
    public const BLOCK_CODE_JAVANESE = 181;
    public const BLOCK_CODE_MYANMAR_EXTENDED_A = 182;
    public const BLOCK_CODE_TAI_VIET = 183;
    public const BLOCK_CODE_MEETEI_MAYEK = 184;
    public const BLOCK_CODE_HANGUL_JAMO_EXTENDED_B = 185;
    public const BLOCK_CODE_IMPERIAL_ARAMAIC = 186;
    public const BLOCK_CODE_OLD_SOUTH_ARABIAN = 187;
    public const BLOCK_CODE_AVESTAN = 188;
    public const BLOCK_CODE_INSCRIPTIONAL_PARTHIAN = 189;
    public const BLOCK_CODE_INSCRIPTIONAL_PAHLAVI = 190;
    public const BLOCK_CODE_OLD_TURKIC = 191;
    public const BLOCK_CODE_RUMI_NUMERAL_SYMBOLS = 192;
    public const BLOCK_CODE_KAITHI = 193;
    public const BLOCK_CODE_EGYPTIAN_HIEROGLYPHS = 194;
    public const BLOCK_CODE_ENCLOSED_ALPHANUMERIC_SUPPLEMENT = 195;
    public const BLOCK_CODE_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT = 196;
    public const BLOCK_CODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C = 197;
    public const BLOCK_CODE_MANDAIC = 198;
    public const BLOCK_CODE_BATAK = 199;
    public const BLOCK_CODE_ETHIOPIC_EXTENDED_A = 200;
    public const BLOCK_CODE_BRAHMI = 201;
    public const BLOCK_CODE_BAMUM_SUPPLEMENT = 202;
    public const BLOCK_CODE_KANA_SUPPLEMENT = 203;
    public const BLOCK_CODE_PLAYING_CARDS = 204;
    public const BLOCK_CODE_MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS = 205;
    public const BLOCK_CODE_EMOTICONS = 206;
    public const BLOCK_CODE_TRANSPORT_AND_MAP_SYMBOLS = 207;
    public const BLOCK_CODE_ALCHEMICAL_SYMBOLS = 208;
    public const BLOCK_CODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D = 209;
    public const BLOCK_CODE_ARABIC_EXTENDED_A = 210;
    public const BLOCK_CODE_ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS = 211;
    public const BLOCK_CODE_CHAKMA = 212;
    public const BLOCK_CODE_MEETEI_MAYEK_EXTENSIONS = 213;
    public const BLOCK_CODE_MEROITIC_CURSIVE = 214;
    public const BLOCK_CODE_MEROITIC_HIEROGLYPHS = 215;
    public const BLOCK_CODE_MIAO = 216;
    public const BLOCK_CODE_SHARADA = 217;
    public const BLOCK_CODE_SORA_SOMPENG = 218;
    public const BLOCK_CODE_SUNDANESE_SUPPLEMENT = 219;
    public const BLOCK_CODE_TAKRI = 220;
    public const BLOCK_CODE_BASSA_VAH = 221;
    public const BLOCK_CODE_CAUCASIAN_ALBANIAN = 222;
    public const BLOCK_CODE_COPTIC_EPACT_NUMBERS = 223;
    public const BLOCK_CODE_COMBINING_DIACRITICAL_MARKS_EXTENDED = 224;
    public const BLOCK_CODE_DUPLOYAN = 225;
    public const BLOCK_CODE_ELBASAN = 226;
    public const BLOCK_CODE_GEOMETRIC_SHAPES_EXTENDED = 227;
    public const BLOCK_CODE_GRANTHA = 228;
    public const BLOCK_CODE_KHOJKI = 229;
    public const BLOCK_CODE_KHUDAWADI = 230;
    public const BLOCK_CODE_LATIN_EXTENDED_E = 231;
    public const BLOCK_CODE_LINEAR_A = 232;
    public const BLOCK_CODE_MAHAJANI = 233;
    public const BLOCK_CODE_MANICHAEAN = 234;
    public const BLOCK_CODE_MENDE_KIKAKUI = 235;
    public const BLOCK_CODE_MODI = 236;
    public const BLOCK_CODE_MRO = 237;
    public const BLOCK_CODE_MYANMAR_EXTENDED_B = 238;
    public const BLOCK_CODE_NABATAEAN = 239;
    public const BLOCK_CODE_OLD_NORTH_ARABIAN = 240;
    public const BLOCK_CODE_OLD_PERMIC = 241;
    public const BLOCK_CODE_ORNAMENTAL_DINGBATS = 242;
    public const BLOCK_CODE_PAHAWH_HMONG = 243;
    public const BLOCK_CODE_PALMYRENE = 244;
    public const BLOCK_CODE_PAU_CIN_HAU = 245;
    public const BLOCK_CODE_PSALTER_PAHLAVI = 246;
    public const BLOCK_CODE_SHORTHAND_FORMAT_CONTROLS = 247;
    public const BLOCK_CODE_SIDDHAM = 248;
    public const BLOCK_CODE_SINHALA_ARCHAIC_NUMBERS = 249;
    public const BLOCK_CODE_SUPPLEMENTAL_ARROWS_C = 250;
    public const BLOCK_CODE_TIRHUTA = 251;
    public const BLOCK_CODE_WARANG_CITI = 252;
    public const BLOCK_CODE_COUNT = 309;
    public const BLOCK_CODE_INVALID_CODE = -1;
    public const BPT_NONE = 0;
    public const BPT_OPEN = 1;
    public const BPT_CLOSE = 2;
    public const BPT_COUNT = 3;
    public const EA_NEUTRAL = 0;
    public const EA_AMBIGUOUS = 1;
    public const EA_HALFWIDTH = 2;
    public const EA_FULLWIDTH = 3;
    public const EA_NARROW = 4;
    public const EA_WIDE = 5;
    public const EA_COUNT = 6;
    public const UNICODE_CHAR_NAME = 0;
    public const UNICODE_10_CHAR_NAME = 1;
    public const EXTENDED_CHAR_NAME = 2;
    public const CHAR_NAME_ALIAS = 3;
    public const CHAR_NAME_CHOICE_COUNT = 4;
    public const SHORT_PROPERTY_NAME = 0;
    public const LONG_PROPERTY_NAME = 1;
    public const PROPERTY_NAME_CHOICE_COUNT = 2;
    public const DT_NONE = 0;
    public const DT_CANONICAL = 1;
    public const DT_COMPAT = 2;
    public const DT_CIRCLE = 3;
    public const DT_FINAL = 4;
    public const DT_FONT = 5;
    public const DT_FRACTION = 6;
    public const DT_INITIAL = 7;
    public const DT_ISOLATED = 8;
    public const DT_MEDIAL = 9;
    public const DT_NARROW = 10;
    public const DT_NOBREAK = 11;
    public const DT_SMALL = 12;
    public const DT_SQUARE = 13;
    public const DT_SUB = 14;
    public const DT_SUPER = 15;
    public const DT_VERTICAL = 16;
    public const DT_WIDE = 17;
    public const DT_COUNT = 18;
    public const JT_NON_JOINING = 0;
    public const JT_JOIN_CAUSING = 1;
    public const JT_DUAL_JOINING = 2;
    public const JT_LEFT_JOINING = 3;
    public const JT_RIGHT_JOINING = 4;
    public const JT_TRANSPARENT = 5;
    public const JT_COUNT = 6;
    public const JG_NO_JOINING_GROUP = 0;
    public const JG_AIN = 1;
    public const JG_ALAPH = 2;
    public const JG_ALEF = 3;
    public const JG_BEH = 4;
    public const JG_BETH = 5;
    public const JG_DAL = 6;
    public const JG_DALATH_RISH = 7;
    public const JG_E = 8;
    public const JG_FEH = 9;
    public const JG_FINAL_SEMKATH = 10;
    public const JG_GAF = 11;
    public const JG_GAMAL = 12;
    public const JG_HAH = 13;
    public const JG_TEH_MARBUTA_GOAL = 14;
    public const JG_HAMZA_ON_HEH_GOAL = 14;
    public const JG_HE = 15;
    public const JG_HEH = 16;
    public const JG_HEH_GOAL = 17;
    public const JG_HETH = 18;
    public const JG_KAF = 19;
    public const JG_KAPH = 20;
    public const JG_KNOTTED_HEH = 21;
    public const JG_LAM = 22;
    public const JG_LAMADH = 23;
    public const JG_MEEM = 24;
    public const JG_MIM = 25;
    public const JG_NOON = 26;
    public const JG_NUN = 27;
    public const JG_PE = 28;
    public const JG_QAF = 29;
    public const JG_QAPH = 30;
    public const JG_REH = 31;
    public const JG_REVERSED_PE = 32;
    public const JG_SAD = 33;
    public const JG_SADHE = 34;
    public const JG_SEEN = 35;
    public const JG_SEMKATH = 36;
    public const JG_SHIN = 37;
    public const JG_SWASH_KAF = 38;
    public const JG_SYRIAC_WAW = 39;
    public const JG_TAH = 40;
    public const JG_TAW = 41;
    public const JG_TEH_MARBUTA = 42;
    public const JG_TETH = 43;
    public const JG_WAW = 44;
    public const JG_YEH = 45;
    public const JG_YEH_BARREE = 46;
    public const JG_YEH_WITH_TAIL = 47;
    public const JG_YUDH = 48;
    public const JG_YUDH_HE = 49;
    public const JG_ZAIN = 50;
    public const JG_FE = 51;
    public const JG_KHAPH = 52;
    public const JG_ZHAIN = 53;
    public const JG_BURUSHASKI_YEH_BARREE = 54;
    public const JG_FARSI_YEH = 55;
    public const JG_NYA = 56;
    public const JG_ROHINGYA_YEH = 57;
    public const JG_MANICHAEAN_ALEPH = 58;
    public const JG_MANICHAEAN_AYIN = 59;
    public const JG_MANICHAEAN_BETH = 60;
    public const JG_MANICHAEAN_DALETH = 61;
    public const JG_MANICHAEAN_DHAMEDH = 62;
    public const JG_MANICHAEAN_FIVE = 63;
    public const JG_MANICHAEAN_GIMEL = 64;
    public const JG_MANICHAEAN_HETH = 65;
    public const JG_MANICHAEAN_HUNDRED = 66;
    public const JG_MANICHAEAN_KAPH = 67;
    public const JG_MANICHAEAN_LAMEDH = 68;
    public const JG_MANICHAEAN_MEM = 69;
    public const JG_MANICHAEAN_NUN = 70;
    public const JG_MANICHAEAN_ONE = 71;
    public const JG_MANICHAEAN_PE = 72;
    public const JG_MANICHAEAN_QOPH = 73;
    public const JG_MANICHAEAN_RESH = 74;
    public const JG_MANICHAEAN_SADHE = 75;
    public const JG_MANICHAEAN_SAMEKH = 76;
    public const JG_MANICHAEAN_TAW = 77;
    public const JG_MANICHAEAN_TEN = 78;
    public const JG_MANICHAEAN_TETH = 79;
    public const JG_MANICHAEAN_THAMEDH = 80;
    public const JG_MANICHAEAN_TWENTY = 81;
    public const JG_MANICHAEAN_WAW = 82;
    public const JG_MANICHAEAN_YODH = 83;
    public const JG_MANICHAEAN_ZAYIN = 84;
    public const JG_STRAIGHT_WAW = 85;
    public const JG_COUNT = 102;
    public const GCB_OTHER = 0;
    public const GCB_CONTROL = 1;
    public const GCB_CR = 2;
    public const GCB_EXTEND = 3;
    public const GCB_L = 4;
    public const GCB_LF = 5;
    public const GCB_LV = 6;
    public const GCB_LVT = 7;
    public const GCB_T = 8;
    public const GCB_V = 9;
    public const GCB_SPACING_MARK = 10;
    public const GCB_PREPEND = 11;
    public const GCB_REGIONAL_INDICATOR = 12;
    public const GCB_COUNT = 18;
    public const WB_OTHER = 0;
    public const WB_ALETTER = 1;
    public const WB_FORMAT = 2;
    public const WB_KATAKANA = 3;
    public const WB_MIDLETTER = 4;
    public const WB_MIDNUM = 5;
    public const WB_NUMERIC = 6;
    public const WB_EXTENDNUMLET = 7;
    public const WB_CR = 8;
    public const WB_EXTEND = 9;
    public const WB_LF = 10;
    public const WB_MIDNUMLET = 11;
    public const WB_NEWLINE = 12;
    public const WB_REGIONAL_INDICATOR = 13;
    public const WB_HEBREW_LETTER = 14;
    public const WB_SINGLE_QUOTE = 15;
    public const WB_DOUBLE_QUOTE = 16;
    public const WB_COUNT = 23;
    public const SB_OTHER = 0;
    public const SB_ATERM = 1;
    public const SB_CLOSE = 2;
    public const SB_FORMAT = 3;
    public const SB_LOWER = 4;
    public const SB_NUMERIC = 5;
    public const SB_OLETTER = 6;
    public const SB_SEP = 7;
    public const SB_SP = 8;
    public const SB_STERM = 9;
    public const SB_UPPER = 10;
    public const SB_CR = 11;
    public const SB_EXTEND = 12;
    public const SB_LF = 13;
    public const SB_SCONTINUE = 14;
    public const SB_COUNT = 15;
    public const LB_UNKNOWN = 0;
    public const LB_AMBIGUOUS = 1;
    public const LB_ALPHABETIC = 2;
    public const LB_BREAK_BOTH = 3;
    public const LB_BREAK_AFTER = 4;
    public const LB_BREAK_BEFORE = 5;
    public const LB_MANDATORY_BREAK = 6;
    public const LB_CONTINGENT_BREAK = 7;
    public const LB_CLOSE_PUNCTUATION = 8;
    public const LB_COMBINING_MARK = 9;
    public const LB_CARRIAGE_RETURN = 10;
    public const LB_EXCLAMATION = 11;
    public const LB_GLUE = 12;
    public const LB_HYPHEN = 13;
    public const LB_IDEOGRAPHIC = 14;
    public const LB_INSEPARABLE = 15;
    public const LB_INSEPERABLE = 15;
    public const LB_INFIX_NUMERIC = 16;
    public const LB_LINE_FEED = 17;
    public const LB_NONSTARTER = 18;
    public const LB_NUMERIC = 19;
    public const LB_OPEN_PUNCTUATION = 20;
    public const LB_POSTFIX_NUMERIC = 21;
    public const LB_PREFIX_NUMERIC = 22;
    public const LB_QUOTATION = 23;
    public const LB_COMPLEX_CONTEXT = 24;
    public const LB_SURROGATE = 25;
    public const LB_SPACE = 26;
    public const LB_BREAK_SYMBOLS = 27;
    public const LB_ZWSPACE = 28;
    public const LB_NEXT_LINE = 29;
    public const LB_WORD_JOINER = 30;
    public const LB_H2 = 31;
    public const LB_H3 = 32;
    public const LB_JL = 33;
    public const LB_JT = 34;
    public const LB_JV = 35;
    public const LB_CLOSE_PARENTHESIS = 36;
    public const LB_CONDITIONAL_JAPANESE_STARTER = 37;
    public const LB_HEBREW_LETTER = 38;
    public const LB_REGIONAL_INDICATOR = 39;
    public const LB_COUNT = 43;
    public const NT_NONE = 0;
    public const NT_DECIMAL = 1;
    public const NT_DIGIT = 2;
    public const NT_NUMERIC = 3;
    public const NT_COUNT = 4;
    public const HST_NOT_APPLICABLE = 0;
    public const HST_LEADING_JAMO = 1;
    public const HST_VOWEL_JAMO = 2;
    public const HST_TRAILING_JAMO = 3;
    public const HST_LV_SYLLABLE = 4;
    public const HST_LVT_SYLLABLE = 5;
    public const HST_COUNT = 6;
    public const NO_NUMERIC_VALUE = -123456789;
    /**
     * @since 8.4
     */
    public const PROPERTY_IDS_UNARY_OPERATOR = 72;
    /**
     * @since 8.4
     */
    public const PROPERTY_ID_COMPAT_MATH_START = 73;
    /**
     * @since 8.4
     */
    public const PROPERTY_ID_COMPAT_MATH_CONTINUE = 74;

    /**
     * Check a binary Unicode property for a code point
     * @link https://php.net/manual/en/intlchar.hasbinaryproperty.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @param int $property The Unicode property to lookup (see the IntlChar::PROPERTY_* constants).
     * @return bool|null Returns TRUE or FALSE according to the binary Unicode property value for codepoint.
     * Also FALSE if property is out of bounds or if the Unicode version does not have data for the property at all, or not for this code point.
     * Or NULL if codepoint is out of bounds.
     * @since 7.0
     */
    #[Pure]
    #[TentativeType]
    public static function hasBinaryProperty(
        #[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $property
    ): ?bool {}

    /**
     * @link https://php.net/manual/en/intlchar.charage.php
     * Get the "age" of the code point
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return array|null The Unicode version number, as an array. For example, version 1.3.31.2 would be represented as [1, 3, 31, 2].
     * Or NULL if codepoint is out of bounds.
     * @since 7.0
     */
    #[TentativeType]
    public static function charAge(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?array {}

    /**
     * @link https://php.net/manual/en/intlchar.chardigitvalue.php
     * Get the decimal digit value of a decimal digit character
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|null The decimal digit value of codepoint, or -1 if it is not a decimal digit character.
     * Or NULL if codepoint is out of bounds.
     * @since 7.0
     */
    #[TentativeType]
    public static function charDigitValue(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?int {}

    /**
     * Get bidirectional category value for a code point
     * @link https://php.net/manual/en/intlchar.chardirection.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|null 
The bidirectional category value; one of the following constants:
     * 
     * 

     * 
 IntlChar::CHAR_DIRECTION_LEFT_TO_RIGHT 
     * 
 IntlChar::CHAR_DIRECTION_RIGHT_TO_LEFT 
     * 
 IntlChar::CHAR_DIRECTION_EUROPEAN_NUMBER 
     * 
 IntlChar::CHAR_DIRECTION_EUROPEAN_NUMBER_SEPARATOR 
     * 
 IntlChar::CHAR_DIRECTION_EUROPEAN_NUMBER_TERMINATOR 
     * 
 IntlChar::CHAR_DIRECTION_ARABIC_NUMBER 
     * 
 IntlChar::CHAR_DIRECTION_COMMON_NUMBER_SEPARATOR 
     * 
 IntlChar::CHAR_DIRECTION_BLOCK_SEPARATOR 
     * 
 IntlChar::CHAR_DIRECTION_SEGMENT_SEPARATOR 
     * 
 IntlChar::CHAR_DIRECTION_WHITE_SPACE_NEUTRAL 
     * 
 IntlChar::CHAR_DIRECTION_OTHER_NEUTRAL 
     * 
 IntlChar::CHAR_DIRECTION_LEFT_TO_RIGHT_EMBEDDING 
     * 
 IntlChar::CHAR_DIRECTION_LEFT_TO_RIGHT_OVERRIDE 
     * 
 IntlChar::CHAR_DIRECTION_RIGHT_TO_LEFT_ARABIC 
     * 
 IntlChar::CHAR_DIRECTION_RIGHT_TO_LEFT_EMBEDDING 
     * 
 IntlChar::CHAR_DIRECTION_RIGHT_TO_LEFT_OVERRIDE 
     * 
 IntlChar::CHAR_DIRECTION_POP_DIRECTIONAL_FORMAT 
     * 
 IntlChar::CHAR_DIRECTION_DIR_NON_SPACING_MARK 
     * 
 IntlChar::CHAR_DIRECTION_BOUNDARY_NEUTRAL 
     * 
 IntlChar::CHAR_DIRECTION_FIRST_STRONG_ISOLATE 
     * 
 IntlChar::CHAR_DIRECTION_LEFT_TO_RIGHT_ISOLATE 
     * 
 IntlChar::CHAR_DIRECTION_RIGHT_TO_LEFT_ISOLATE 
     * 
 IntlChar::CHAR_DIRECTION_POP_DIRECTIONAL_ISOLATE 
     * 
 IntlChar::CHAR_DIRECTION_CHAR_DIRECTION_COUNT 
     * 
     * Or NULL if codepoint is out of bounds.
     * @since 7.0
     */
    #[TentativeType]
    public static function charDirection(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?int {}

    /**
     * @link https://php.net/manual/en/intlchar.charfromname.php
     * Find Unicode character by name and return its code point value
     * @param string $name 
Full name of the Unicode character.
     * @param int $type [optional] 

     * Which set of names to use for the lookup. Can be any of these constants:
     * 

     * 
 IntlChar::UNICODE_CHAR_NAME  (default)
     * 
 IntlChar::UNICODE_10_CHAR_NAME 
     * 
 IntlChar::EXTENDED_CHAR_NAME 
     * 
 IntlChar::CHAR_NAME_ALIAS 
     * 
 IntlChar::CHAR_NAME_CHOICE_COUNT 
     * 
     * @return int|null The Unicode value of the code point with the given name (as an integer), or NULL if there is no such code point.
     * @since 7.0
     */
    #[TentativeType]
    public static function charFromName(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $name,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $type = IntlChar::UNICODE_CHAR_NAME
    ): ?int {}

    /**
     * @link https://php.net/manual/en/intlchar.charmirror.php
     * Get the "mirror-image" character for a code point
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|string|null Returns another Unicode code point that may serve as a mirror-image substitute, or codepoint itself if there is no such mapping or codepoint does not have the Bidi_Mirrored property.
     * The return type will be integer unless the code point was passed as a UTF-8 string, in which case a string will be returned.
     * Or NULL if codepoint will be out of bound.
     */
    #[TentativeType]
    public static function charMirror(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): string|int|null {}

    /**
     * Retrieve the name of a Unicode character
     * @link https://php.net/manual/en/intlchar.charname.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @param int $type [optional] Which set of names to use for the lookup. Can be any of these constants:
     * 

     * 
 IntlChar::UNICODE_CHAR_NAME  (default)
     * 
 IntlChar::UNICODE_10_CHAR_NAME 
     * 
 IntlChar::EXTENDED_CHAR_NAME 
     * 
 IntlChar::CHAR_NAME_ALIAS 
     * 
 IntlChar::CHAR_NAME_CHOICE_COUNT 
     * 
     * @return string|null The corresponding name, or an empty string if there is no name for this character, or NULL if codepoint is out of bounds.
     * @since 7.0
     */
    #[TentativeType]
    public static function charName(
        #[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $type = IntlChar::UNICODE_CHAR_NAME
    ): ?string {}

    /**
     * Get the general category value for a code point
     * @link https://php.net/manual/en/intlchar.chartype.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|null Returns the general category type, which may be one of the following constants:
     * 

     * 
 IntlChar::CHAR_CATEGORY_UNASSIGNED 
     * 
 IntlChar::CHAR_CATEGORY_GENERAL_OTHER_TYPES 
     * 
 IntlChar::CHAR_CATEGORY_UPPERCASE_LETTER 
     * 
 IntlChar::CHAR_CATEGORY_LOWERCASE_LETTER 
     * 
 IntlChar::CHAR_CATEGORY_TITLECASE_LETTER 
     * 
 IntlChar::CHAR_CATEGORY_MODIFIER_LETTER 
     * 
 IntlChar::CHAR_CATEGORY_OTHER_LETTER 
     * 
 IntlChar::CHAR_CATEGORY_NON_SPACING_MARK 
     * 
 IntlChar::CHAR_CATEGORY_ENCLOSING_MARK 
     * 
 IntlChar::CHAR_CATEGORY_COMBINING_SPACING_MARK 
     * 
 IntlChar::CHAR_CATEGORY_DECIMAL_DIGIT_NUMBER 
     * 
 IntlChar::CHAR_CATEGORY_LETTER_NUMBER 
     * 
 IntlChar::CHAR_CATEGORY_OTHER_NUMBER 
     * 
 IntlChar::CHAR_CATEGORY_SPACE_SEPARATOR 
     * 
 IntlChar::CHAR_CATEGORY_LINE_SEPARATOR 
     * 
 IntlChar::CHAR_CATEGORY_PARAGRAPH_SEPARATOR 
     * 
 IntlChar::CHAR_CATEGORY_CONTROL_CHAR 
     * 
 IntlChar::CHAR_CATEGORY_FORMAT_CHAR 
     * 
 IntlChar::CHAR_CATEGORY_PRIVATE_USE_CHAR 
     * 
 IntlChar::CHAR_CATEGORY_SURROGATE 
     * 
 IntlChar::CHAR_CATEGORY_DASH_PUNCTUATION 
     * 
 IntlChar::CHAR_CATEGORY_START_PUNCTUATION 
     * 
 IntlChar::CHAR_CATEGORY_END_PUNCTUATION 
     * 
 IntlChar::CHAR_CATEGORY_CONNECTOR_PUNCTUATION 
     * 
 IntlChar::CHAR_CATEGORY_OTHER_PUNCTUATION 
     * 
 IntlChar::CHAR_CATEGORY_MATH_SYMBOL 
     * 
 IntlChar::CHAR_CATEGORY_CURRENCY_SYMBOL 
     * 
 IntlChar::CHAR_CATEGORY_MODIFIER_SYMBOL 
     * 
 IntlChar::CHAR_CATEGORY_OTHER_SYMBOL 
     * 
 IntlChar::CHAR_CATEGORY_INITIAL_PUNCTUATION 
     * 
 IntlChar::CHAR_CATEGORY_FINAL_PUNCTUATION 
     * 
 IntlChar::CHAR_CATEGORY_CHAR_CATEGORY_COUNT 
     * 
Or NULL if codepoint is out of bound.
 'int|string'], default: '')] $codepoint): ?int {}

    /**
     * Return Unicode character by code point value
     * @link https://php.net/manual/en/intlchar.chr.php
     * @param mixed $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return string|null A string containing the single character specified by the Unicode code point value.
     * Or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function chr(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?string {}

    /**
     * Get the decimal digit value of a code point for a given radix
     * @link https://php.net/manual/en/intlchar.digit.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @param int $base 
The radix (defaults to 10).
     * @return int|false|null Returns the numeric value represented by the character in the specified radix,
     * or FALSE if there is no value or if the value exceeds the radix,
     * or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function digit(
        #[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $base = 10
    ): int|false|null {}

    /**
     * Enumerate all assigned Unicode characters within a range
     * @link https://php.net/manual/en/intlchar.enumcharnames.php
     * @param int|string $start The first code point in the enumeration range.
     * @param int|string $end One more than the last code point in the enumeration range (the first one after the range).
     * @param callable $callback 

     * The function that is to be called for each character name.  The following three arguments will be passed into it:
     * 

     * 
integer $codepoint - The numeric code point value
     * 
integer $nameChoice - The same value as the nameChoice parameter below
     * 
string $name - The name of the character
     * 
     * @param int $type [optional]  

     * Selector for which kind of names to enumerate.  Can be any of these constants:
     * 

     * 
IntlChar::UNICODE_CHAR_NAME (default)
     * 
IntlChar::UNICODE_10_CHAR_NAME
     * 
IntlChar::EXTENDED_CHAR_NAME
     * 
IntlChar::CHAR_NAME_ALIAS
     * 
IntlChar::CHAR_NAME_CHOICE_COUNT
     * 
     * @since 7.0
     */
    #[TentativeType]
    #[LanguageLevelTypeAware(['8.3' => 'bool'], default: 'bool|null')]
    public static function enumCharNames(
        #[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $start,
        #[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $end,
        #[LanguageLevelTypeAware(['8.0' => 'callable'], default: '')] $callback,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $type = IntlChar::UNICODE_CHAR_NAME
    ) {}

    /**
     * Enumerate all code points with their Unicode general categories
     * @link https://php.net/manual/en/intlchar.enumchartypes.php
     * @param callable $callback 

     * The function that is to be called for each contiguous range of code points with the same general category.
     * The following three arguments will be passed into it:
     * 

     * 
integer $start - The starting code point of the range
     * 
integer $end - The ending code point of the range
     * 
integer $name - The category type (one of the IntlChar::CHAR_CATEGORY_* constants)
     * 
     * @since 7.0
     */
    #[TentativeType]
    public static function enumCharTypes(
        #[PhpStormStubsElementAvailable(from: '7.0', to: '7.4')] $callback = null,
        #[PhpStormStubsElementAvailable(from: '8.0')] callable $callback
    ): void {}

    /**
     * Perform case folding on a code point
     * @link https://php.net/manual/en/intlchar.foldcase.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @param int $options [optional] Either IntlChar::FOLD_CASE_DEFAULT (default) or IntlChar::FOLD_CASE_EXCLUDE_SPECIAL_I.
     * @return int|string|null Returns the Simple_Case_Folding of the code point, if any; otherwise the code point itself.
     * Returns NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function foldCase(
        #[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $options = IntlChar::FOLD_CASE_DEFAULT
    ): string|int|null {}

    /**
     * Get character representation for a given digit and radix
     * @link https://php.net/manual/en/intlchar.fordigit.php
     * @param int $digit 
The number to convert to a character.
     * @param int $base [optional] 
The radix (defaults to 10).
     * @return int The character representation (as a string) of the specified digit in the specified radix.
     * @since 7.0
     */
    #[TentativeType]
    public static function forDigit(
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $digit,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $base = 10
    ): int {}

    /**
     * Get the paired bracket character for a code point
     * @link https://php.net/manual/en/intlchar.getbidipairedbracket.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|string|null  Returns the paired bracket code point, or codepoint itself if there is no such mapping.
     * The return type will be integer unless the code point was passed as a UTF-8 string, in which case a string will be returned.
     * Or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function getBidiPairedBracket(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): string|int|null {}

    /**
     * Get the Unicode allocation block containing a code point
     * @link https://php.net/manual/en/intlchar.getblockcode.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|null Returns the block value for codepoint, or NULL if codepoint is out of bound.
     * See the IntlChar::BLOCK_CODE_* constants for possible return values.
     * @since 7.0
     */
    #[TentativeType]
    public static function getBlockCode(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?int {}

    /**
     * Get the combining class of a code point
     * @link https://php.net/manual/en/intlchar.getcombiningclass.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|null Returns the combining class of the character.
     * Or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function getCombiningClass(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?int {}

    /**
     * Get the FC_NFKC_Closure property for a code point
     * @link https://php.net/manual/en/intlchar.getfc-nfkc-closure.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return string|false|null Returns the FC_NFKC_Closure property string for the codepoint, or an empty string if there is none,
     * or NULL if codepoint is out of bound,
     * or FALSE if there was an error.
     * @since 7.0
     */
    #[TentativeType]
    public static function getFC_NFKC_Closure(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): string|false|null {}

    /**
     * Get the max value for a Unicode property
     * @link https://php.net/manual/en/intlchar.getintpropertymaxvalue.php
     * @param int $property The Unicode property to lookup (see the IntlChar::PROPERTY_* constants).
     * @return int The maximum value returned by {@see IntlChar::getIntPropertyValue()} for a Unicode property. <=0 if the property selector is out of range.
     * @since 7.0
     */
    #[TentativeType]
    public static function getIntPropertyMaxValue(#[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $property): int {}

    /**
     * Get the min value for a Unicode property
     * @link https://php.net/manual/en/intlchar.getintpropertyminvalue.php
     * @param int $property The Unicode property to lookup (see the IntlChar::PROPERTY_* constants).
     * @return int The minimum value returned by {@see IntlChar::getIntPropertyValue()} for a Unicode property. 0 if the property selector is out of range.
     * @since 7.0
     */
    #[TentativeType]
    public static function getIntPropertyMinValue(#[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $property): int {}

    /**
     * Get the value for a Unicode property for a code point
     * @link https://php.net/manual/en/intlchar.getintpropertyvalue.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @param int $property The Unicode property to lookup (see the IntlChar::PROPERTY_* constants).
     * @return int|null 

     * Returns the numeric value that is directly the property value or, for enumerated properties, corresponds to the
     * numeric value of the enumerated constant of the respective property value enumeration type.
     * 
     * 

     * Returns 0 or 1 (for FALSE/TRUE) for binary Unicode properties.
     * 
     * 

     * Returns a bit-mask for mask properties.
     * 
     * 

     * Returns 0 if property is out of bounds or if the Unicode version does not
     * have data for the property at all, or not for this code point.
     * 
     * 

     * Returns NULL if codepoint is out of bound.
     * 
     * @since 7.0
     */
    #[TentativeType]
    public static function getIntPropertyValue(
        #[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $property
    ): ?int {}

    /**
     * Get the numeric value for a Unicode code point
     * @link https://php.net/manual/en/intlchar.getnumericvalue.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return float|null Numeric value of codepoint, or float(-123456789) if none is defined, or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function getNumericValue(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?float {}

    /**
     * Get the property constant value for a given property name
     * @link https://php.net/manual/en/intlchar.getpropertyenum.php
     * @param string $alias The property name to be matched. The name is compared using "loose matching" as described in PropertyAliases.txt.
     * @return int Returns an IntlChar::PROPERTY_ constant value, or IntlChar::PROPERTY_INVALID_CODE if the given name does not match any property.
     * @since 7.0
     */
    #[TentativeType]
    public static function getPropertyEnum(#[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $alias): int {}

    /**
     * Get the Unicode name for a property
     * @link https://php.net/manual/en/intlchar.getpropertyname.php
     * @param int $property 
The Unicode property to lookup (see the IntlChar::PROPERTY_* constants).
     * 
IntlChar::PROPERTY_INVALID_CODE should not be used. Also, if property is out of range, FALSE is returned.
     * @param int $type 
 Selector for which name to get. If out of range, FALSE is returned.
     * 
All properties have a long name. Most have a short name, but some do not. Unicode allows for additional names; if present these will be returned by adding 1, 2, etc. to IntlChar::LONG_PROPERTY_NAME.
     * @return string|false 

     * Returns the name, or FALSE if either the property or the nameChoice
     * is out of range.
     * 
     * 

     * If a given nameChoice returns FALSE, then all larger values of
     * nameChoice will return FALSE, with one exception: if FALSE is returned for
     * IntlChar::SHORT_PROPERTY_NAME, then IntlChar::LONG_PROPERTY_NAME
     * (and higher) may still return a non-FALSE value.
     * 
     * @since 7.0
     */
    #[TentativeType]
    public static function getPropertyName(
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $property,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $type = IntlChar::LONG_PROPERTY_NAME
    ): string|false {}

    /**
     * Get the property value for a given value name
     * @link https://php.net/manual/en/intlchar.getpropertyvalueenum.php
     * @param int $property 
The Unicode property to lookup (see the IntlChar::PROPERTY_* constants).
     * If out of range, or this method doesn't work with the given value, IntlChar::PROPERTY_INVALID_CODE is returned
     * @param string $name 
 The value name to be matched. The name is compared using "loose matching" as described in PropertyValueAliases.txt.
     * @return int Returns the corresponding value integer, or IntlChar::PROPERTY_INVALID_CODE if the given name does not match any value of the given property, or if the property is invalid.
     * @since 7.0
     */
    #[TentativeType]
    public static function getPropertyValueEnum(
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $property,
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $name
    ): int {}

    /**
     * Get the Unicode name for a property value
     * @link https://php.net/manual/en/intlchar.getpropertyvaluename.php
     * @param int $property 

     * The Unicode property to lookup (see the IntlChar::PROPERTY_* constants).
     * If out of range, or this method doesn't work with the given value, FALSE is returned.
     * 
     * @param int $value 

     * Selector for a value for the given property. If out of range, FALSE is returned.
     * 
     * 

     * In general, valid values range from 0 up to some maximum. There are a couple exceptions:
     * 

     * 

     * IntlChar::PROPERTY_BLOCK values begin at the non-zero value IntlChar::BLOCK_CODE_BASIC_LATIN
     * 
     * 

     * IntlChar::PROPERTY_CANONICAL_COMBINING_CLASS values are not contiguous and range from 0..240.
     * 
     * 
     * @param int $type [optional] 

     * Selector for which name to get. If out of range, FALSE is returned.
     * All values have a long name. Most have a short name, but some do not. Unicode allows for additional names; if present these will be returned by adding 1, 2, etc. to IntlChar::LONG_PROPERTY_NAME.
     * 
     * @return  string|false Returns the name, or FALSE if either the property or the nameChoice is out of range.
     * If a given nameChoice returns FALSE, then all larger values of nameChoice will return FALSE, with one exception: if FALSE is returned for IntlChar::SHORT_PROPERTY_NAME, then IntlChar::LONG_PROPERTY_NAME (and higher) may still return a non-FALSE value.
     * @since 7.0
     */
    #[TentativeType]
    public static function getPropertyValueName(
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $property,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $value,
        #[LanguageLevelTypeAware(['8.0' => 'int'], default: '')] $type = IntlChar::LONG_PROPERTY_NAME
    ): string|false {}

    /**
     * Get the Unicode version
     * @link https://php.net/manual/en/intlchar.getunicodeversion.php
     * @return array An array containing the Unicode version number.
     * @since 7.0
     */
    #[TentativeType]
    public static function getUnicodeVersion(): array {}

    /**
     * Check if code point is an alphanumeric character
     * @link https://php.net/manual/en/intlchar.isalnum.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is an alphanumeric character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isalnum(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a letter character
     * @link https://php.net/manual/en/intlchar.isalpha.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a letter character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isalpha(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a base character
     * @link https://php.net/manual/en/intlchar.isbase.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a base character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isbase(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a "blank" or "horizontal space" character
     * @link https://php.net/manual/en/intlchar.isblank.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is either a "blank" or "horizontal space" character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isblank(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a control character
     * @link https://php.net/manual/en/intlchar.iscntrl.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a control character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function iscntrl(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check whether the code point is defined
     * @link https://php.net/manual/en/intlchar.isdefined.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a defined character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isdefined(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a digit character
     * @link https://php.net/manual/en/intlchar.isdigit.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a digit character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isdigit(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a graphic character
     * @link https://php.net/manual/en/intlchar.isgraph.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a "graphic" character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isgraph(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is an ignorable character
     * @link https://php.net/manual/en/intlchar.isidignorable.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is ignorable in identifiers, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isIDIgnorable(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is permissible in an identifier
     * @link https://php.net/manual/en/intlchar.isidpart.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is the code point may occur in an identifier, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isIDPart(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is permissible as the first character in an identifier
     * @link https://php.net/manual/en/intlchar.isidstart.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint may start an identifier, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isIDStart(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is an ISO control code
     * @link https://php.net/manual/en/intlchar.isisocontrol.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is an ISO control code, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isISOControl(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is permissible in a Java identifier
     * @link https://php.net/manual/en/intlchar.isjavaidpart.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint may occur in a Java identifier, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isJavaIDPart(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is permissible as the first character in a Java identifier
     * @link https://php.net/manual/en/intlchar.isjavaidstart.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint may start a Java identifier, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isJavaIDStart(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a space character according to Java
     * @link https://php.net/manual/en/intlchar.isjavaspacechar.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a space character according to Java, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isJavaSpaceChar(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a lowercase letter
     * @link https://php.net/manual/en/intlchar.islower.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN),
     * or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is an Ll lowercase letter, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function islower(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point has the Bidi_Mirrored property
     * @link https://php.net/manual/en/intlchar.ismirrored.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint has the Bidi_Mirrored property, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isMirrored(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a printable character
     * @link https://php.net/manual/en/intlchar.isprint.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a printable character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isprint(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is punctuation character
     * @link https://php.net/manual/en/intlchar.ispunct.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN),
     * or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a punctuation character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function ispunct(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a space character
     * @link https://php.net/manual/en/intlchar.isspace.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a space character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isspace(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a titlecase letter
     * @link https://php.net/manual/en/intlchar.istitle.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a titlecase letter, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function istitle(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point has the Alphabetic Unicode property
     * @link https://php.net/manual/en/intlchar.isualphabetic.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint has the Alphabetic Unicode property, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isUAlphabetic(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point has the Lowercase Unicode property
     * @link https://php.net/manual/en/intlchar.isulowercase.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint has the Lowercase Unicode property, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isULowercase(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point has the general category "Lu" (uppercase letter)
     * @link https://php.net/manual/en/intlchar.isupper.php
     * @param int|string $codepoint 
The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN),
     * or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is an Lu uppercase letter, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isupper(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point has the Uppercase Unicode property
     * @link https://php.net/manual/en/intlchar.isuuppercase.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint has the Uppercase Unicode property, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isUUppercase(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point has the White_Space Unicode property
     * @link https://php.net/manual/en/intlchar.isuwhitespace.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint has the White_Space Unicode property, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isUWhiteSpace(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a whitespace character according to ICU
     * @link https://php.net/manual/en/intlchar.iswhitespace.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a whitespace character according to ICU, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isWhitespace(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Check if code point is a hexadecimal digit
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return bool|null Returns TRUE if codepoint is a hexadecimal character, FALSE if not, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function isxdigit(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): ?bool {}

    /**
     * Return Unicode code point value of character
     * @link https://php.net/manual/en/intlchar.ord.php
     * @param int|string $character 
A Unicode character.
     * @return int|null Returns the Unicode code point value as an integer, NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function ord(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $character): ?int {}

    /**
     * Make Unicode character lowercase
     * @link https://php.net/manual/en/intlchar.tolower.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|string|null Returns the Simple_Lowercase_Mapping of the code point, if any; otherwise the code point itself.
     * The return type will be integer unless the code point was passed as a UTF-8 string, in which case a string will be returned.
     * Or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function tolower(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): string|int|null {}

    /**
     * Make Unicode character titlecase
     * @link https://php.net/manual/en/intlchar.totitle.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|string|null  Returns the Simple_Titlecase_Mapping of the code point, if any; otherwise the code point itself.
     * The return type will be integer unless the code point was passed as a UTF-8 string, in which case a string will be returned.
     * Or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function totitle(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): string|int|null {}

    /**
     * Make Unicode character uppercase
     * @link https://php.net/manual/en/intlchar.toupper.php
     * @param int|string $codepoint The integer codepoint value (e.g. 0x2603 for U+2603 SNOWMAN), or the character encoded as a UTF-8 string (e.g. "\u{2603}")
     * @return int|string|null Returns the Simple_Uppercase_Mapping of the code point, if any; otherwise the code point itself.
     * The return type will be integer unless the code point was passed as a UTF-8 string, in which case a string will be returned.
     * Or NULL if codepoint is out of bound.
     * @since 7.0
     */
    #[TentativeType]
    public static function toupper(#[LanguageLevelTypeAware(['8.0' => 'int|string'], default: '')] $codepoint): string|int|null {}
}

     * Sort strings with different accents from the back of the string. This
     * attribute is automatically set to
     * On
     * for the French locales and a few others. Users normally would not need
     * to explicitly set this attribute. There is a string comparison
     * performance cost when it is set On,
     * but sort key length is unaffected. Possible values are:
     * Collator::ON
     * Collator::OFF(default)
     * Collator::DEFAULT_VALUE
     * 

     * 

     * FRENCH_COLLATION rules
     * 

     * F=OFF cote < coté < côte < côté
     * F=ON cote < côte < coté < côté
     * 
     * 

     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const FRENCH_COLLATION = 0;

    /**
     * 

     * The Alternate attribute is used to control the handling of the so called
     * variable characters in the UCA: whitespace, punctuation and symbols. If
     * Alternate is set to NonIgnorable
     * (N), then differences among these characters are of the same importance
     * as differences among letters. If Alternate is set to
     * Shifted
     * (S), then these characters are of only minor importance. The
     * Shifted value is often used in combination with
     * Strength
     * set to Quaternary. In such a case, whitespace, punctuation, and symbols
     * are considered when comparing strings, but only if all other aspects of
     * the strings (base letters, accents, and case) are identical. If
     * Alternate is not set to Shifted, then there is no difference between a
     * Strength of 3 and a Strength of 4. For more information and examples,
     * see Variable_Weighting in the
     * UCA.
     * The reason the Alternate values are not simply
     * On and Off
     * is that additional Alternate values may be added in the future. The UCA
     * option Blanked is expressed with Strength set to 3, and Alternate set to
     * Shifted. The default for most locales is NonIgnorable. If Shifted is
     * selected, it may be slower if there are many strings that are the same
     * except for punctuation; sort key length will not be affected unless the
     * strength level is also increased.
     * 
     * 

     * Possible values are:
     * Collator::NON_IGNORABLE(default)
     * Collator::SHIFTED
     * Collator::DEFAULT_VALUE
     * 
     * 

     * ALTERNATE_HANDLING rules
     * 

     * S=3, A=N di Silva < Di Silva < diSilva < U.S.A. < USA
     * S=3, A=S di Silva = diSilva < Di Silva < U.S.A. = USA
     * S=4, A=S di Silva < diSilva < Di Silva < U.S.A. < USA
     * 
     * 

     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const ALTERNATE_HANDLING = 1;

    /**
     * 

     * The Case_First attribute is used to control whether uppercase letters
     * come before lowercase letters or vice versa, in the absence of other
     * differences in the strings. The possible values are
     * Uppercase_First
     * (U) and Lowercase_First
     * (L), plus the standard Default
     * and Off.
     * There is almost no difference between the Off and Lowercase_First
     * options in terms of results, so typically users will not use
     * Lowercase_First: only Off or Uppercase_First. (People interested in the
     * detailed differences between X and L should consult the Collation
     * Customization). Specifying either L or U won't affect string comparison
     * performance, but will affect the sort key length.
     * 
     * 

     * Possible values are:
     * Collator::OFF(default)
     * Collator::LOWER_FIRST
     * Collator::UPPER_FIRST
     * Collator:DEFAULT
     * 
     * 

     * CASE_FIRST rules
     * 

     * C=X or C=L "china" < "China" < "denmark" < "Denmark"
     * C=U "China" < "china" < "Denmark" < "denmark"
     * 
     * 

     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const CASE_FIRST = 2;

    /**
     * 

     * The Case_Level attribute is used when ignoring accents but not case. In
     * such a situation, set Strength to be Primary,
     * and Case_Level to be On.
     * In most locales, this setting is Off by default. There is a small
     * string comparison performance and sort key impact if this attribute is
     * set to be On.
     * 
     * 

     * Possible values are:
     * Collator::OFF(default)
     * Collator::ON
     * Collator::DEFAULT_VALUE
     * 
     * 

     * CASE_LEVEL rules
     * 

     * S=1, E=X role = Role = rôle
     * S=1, E=O role = rôle < Role
     * 
     * 

     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const CASE_LEVEL = 3;

    /**
     * 

     * The Normalization setting determines whether text is thoroughly
     * normalized or not in comparison. Even if the setting is off (which is
     * the default for many locales), text as represented in common usage will
     * compare correctly (for details, see UTN #5). Only if the accent marks
     * are in noncanonical order will there be a problem. If the setting is
     * On,
     * then the best results are guaranteed for all possible text input.
     * There is a medium string comparison performance cost if this attribute
     * is On,
     * depending on the frequency of sequences that require normalization.
     * There is no significant effect on sort key length. If the input text is
     * known to be in NFD or NFKD normalization forms, there is no need to
     * enable this Normalization option.
     * 
     * 

     * Possible values are:
     * Collator::OFF(default)
     * Collator::ON
     * Collator::DEFAULT_VALUE
     * 
     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const NORMALIZATION_MODE = 4;

    /**
     * 

     * The ICU Collation Service supports many levels of comparison (named
     * "Levels", but also known as "Strengths"). Having these categories
     * enables ICU to sort strings precisely according to local conventions.
     * However, by allowing the levels to be selectively employed, searching
     * for a string in text can be performed with various matching conditions.
     * For more detailed information, see
     * collator_set_strength chapter.
     * 
     * 

     * Possible values are:
     * Collator::PRIMARY
     * Collator::SECONDARY
     * Collator::TERTIARY(default)
     * Collator::QUATERNARY
     * Collator::IDENTICAL
     * Collator::DEFAULT_VALUE
     * 
     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const STRENGTH = 5;

    /**
     * 

     * Compatibility with JIS x 4061 requires the introduction of an additional
     * level to distinguish Hiragana and Katakana characters. If compatibility
     * with that standard is required, then this attribute should be set
     * On,
     * and the strength set to Quaternary. This will affect sort key length
     * and string comparison string comparison performance.
     * 
     * 

     * Possible values are:
     * Collator::OFF(default)
     * Collator::ON
     * Collator::DEFAULT_VALUE
     * 
     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const HIRAGANA_QUATERNARY_MODE = 6;

    /**
     * 

     * When turned on, this attribute generates a collation key for the numeric
     * value of substrings of digits. This is a way to get '100' to sort AFTER
     * '2'.
     * 
     * 

     * Possible values are:
     * Collator::OFF(default)
     * Collator::ON
     * Collator::DEFAULT_VALUE
     * 
     * @link https://php.net/manual/en/class.collator.php#intl.collator-constants
     */
    public const NUMERIC_COLLATION = 7;
    public const SORT_REGULAR = 0;
    public const SORT_STRING = 1;
    public const SORT_NUMERIC = 2;

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Create a collator
     * @link https://php.net/manual/en/collator.construct.php
     * @param string $locale
     */
    #[Pure]
    public function __construct(#[LanguageAware(['8.0' => 'string'], default: '')] $locale) {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Create a collator
     * @link https://php.net/manual/en/collator.create.php
     * @param string $locale 

     * The locale containing the required collation rules. Special values for
     * locales can be passed in - if null is passed for the locale, the
     * default locale collation rules will be used. If empty string ("") or
     * "root" are passed, UCA rules will be used.
     * 
     * @return Collator|null Return new instance of Collator object, or NULL
     * on error.
     */
    #[TentativeType]
    public static function create(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): ?Collator {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Compare two Unicode strings
     * @link https://php.net/manual/en/collator.compare.php
     * @param string $string1 

     * The first string to compare.
     * 
     * @param string $string2 

     * The second string to compare.
     * 
     * @return int|false Return comparison result:

     * 

     * 

     * 1 if str1 is greater than
     * str2 ;
     * 
     * 

     * 0 if str1 is equal to
     * str2;
     * 
     * 

     * -1 if str1 is less than
     * str2 .
     * 
     * On error
     * boolean
     * FALSE
     * is returned.
     */
    #[Pure]
    #[TentativeType]
    public function compare(
        #[LanguageAware(['8.0' => 'string'], default: '')] $string1,
        #[LanguageAware(['8.0' => 'string'], default: '')] $string2
    ): int|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Sort array using specified collator
     * @link https://php.net/manual/en/collator.sort.php
     * @param string[] &$array 

     * Array of strings to sort.
     * 
     * @param int $flags [optional] 

     * Optional sorting type, one of the following:
     * 
     * 

     * Collator::SORT_REGULAR
     * - compare items normally (don't change types)
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function sort(
        array &$array,
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([Collator::SORT_REGULAR])] $flags = 0
    ): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Sort array using specified collator and sort keys
     * @link https://php.net/manual/en/collator.sortwithsortkeys.php
     * @param string[] &$array 
Array of strings to sort
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function sortWithSortKeys(
        array &$array,
        #[ElementAvailable(from: '5.3', to: '5.6')] $flags = []
    ): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Sort array maintaining index association
     * @link https://php.net/manual/en/collator.asort.php
     * @param string[] &$array 
Array of strings to sort.
     * @param int $flags [optional] 

     * Optional sorting type, one of the following:
     * Collator::SORT_REGULAR
     * - compare items normally (don't change types)
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function asort(
        array &$array,
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([Collator::SORT_REGULAR])] $flags = 0
    ): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get collation attribute value
     * @link https://php.net/manual/en/collator.getattribute.php
     * @param int $attribute 

     * Attribute to get value for.
     * 
     * @return int|false Attribute value, or boolean FALSE on error.
     */
    #[Pure]
    #[TentativeType]
    public function getAttribute(#[LanguageAware(['8.0' => 'int'], default: '')] $attribute): int|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set collation attribute
     * @link https://php.net/manual/en/collator.setattribute.php
     * @param int $attribute 
Attribute.
     * @param int $value 

     * Attribute value.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function setAttribute(
        #[LanguageAware(['8.0' => 'int'], default: '')] $attribute,
        #[LanguageAware(['8.0' => 'int'], default: '')] $value
    ): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get current collation strength
     * @link https://php.net/manual/en/collator.getstrength.php
     * @return int current collation strength, or boolean FALSE on error.
     */
    #[Pure]
    #[TentativeType]
    public function getStrength(): int {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set collation strength
     * @link https://php.net/manual/en/collator.setstrength.php
     * @param int $strength 
Strength to set.
     * 

     * Possible values are:
     * Collator::PRIMARY
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public function setStrength(#[LanguageAware(['8.0' => 'int'], default: '')] #[EV([Collator::PRIMARY])] $strength) {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get collator's last error code
     * @link https://php.net/manual/en/collator.geterrorcode.php
     * @return int|false Error code returned by the last Collator API function call.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the locale name of the collator
     * @link https://php.net/manual/en/collator.getlocale.php
     * @param int $type 

     * You can choose between valid and actual locale (
     * Locale::VALID_LOCALE and
     * Locale::ACTUAL_LOCALE,
     * respectively).
     * 
     * @return string|false Real locale name from which the collation data comes. If the collator was
     * instantiated from rules or an error occurred, returns
     * boolean FALSE.
     */
    #[Pure]
    #[TentativeType]
    public function getLocale(
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([Locale::VALID_LOCALE, Locale::ACTUAL_LOCALE])] $type
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get text for collator's last error code
     * @link https://php.net/manual/en/collator.geterrormessage.php
     * @return string|false Description of an error occurred in the last Collator API function call.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string|false {}

    /**
     * (PHP 5 >= 5.3.2, PECL intl >= 1.0.3)

     * Get sorting key for a string
     * @link https://php.net/manual/en/collator.getsortkey.php
     * @param string $string 

     * The string to produce the key from.
     * 
     * @return string|false the collation key for the string. Collation keys can be compared directly instead of strings.
     */
    #[Pure]
    #[TentativeType]
    public function getSortKey(
        #[LanguageAware(['8.0' => 'string'], default: '')] $string,
        #[ElementAvailable(from: '5.3', to: '5.6')] $arg2
    ): string|false {}
}

class NumberFormatter
{
    public const CURRENCY_ACCOUNTING = 12;

    /**
     * Decimal format defined by pattern
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PATTERN_DECIMAL = 0;

    /**
     * Decimal format
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DECIMAL = 1;

    /**
     * Currency format
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const CURRENCY = 2;

    /**
     * Percent format
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PERCENT = 3;

    /**
     * Scientific format
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const SCIENTIFIC = 4;

    /**
     * Spellout rule-based format
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const SPELLOUT = 5;

    /**
     * Ordinal rule-based format
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ORDINAL = 6;

    /**
     * Duration rule-based format
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DURATION = 7;

    /**
     * Rule-based format defined by pattern
     * @link https://php.net/manual/en/class.locale.php#intl.locale-constants
     */
    public const PATTERN_RULEBASED = 9;

    /**
     * Alias for PATTERN_DECIMAL
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const IGNORE = 0;

    /**
     * Default format for the locale
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DEFAULT_STYLE = 1;

    /**
     * Rounding mode to round towards positive infinity.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUND_CEILING = 0;

    /**
     * Rounding mode to round towards negative infinity.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUND_FLOOR = 1;

    /**
     * Rounding mode to round towards zero.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUND_DOWN = 2;

    /**
     * Rounding mode to round away from zero.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUND_UP = 3;

    /**
     * Rounding mode to round towards the "nearest neighbor" unless both
     * neighbors are equidistant, in which case, round towards the even
     * neighbor.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUND_HALFEVEN = 4;

    /**
     * Rounding mode to round towards "nearest neighbor" unless both neighbors
     * are equidistant, in which case round down.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUND_HALFDOWN = 5;

    /**
     * Rounding mode to round towards "nearest neighbor" unless both neighbors
     * are equidistant, in which case round up.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUND_HALFUP = 6;

    /**
     * Pad characters inserted before the prefix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PAD_BEFORE_PREFIX = 0;

    /**
     * Pad characters inserted after the prefix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PAD_AFTER_PREFIX = 1;

    /**
     * Pad characters inserted before the suffix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PAD_BEFORE_SUFFIX = 2;

    /**
     * Pad characters inserted after the suffix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PAD_AFTER_SUFFIX = 3;

    /**
     * Parse integers only.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PARSE_INT_ONLY = 0;

    /**
     * Use grouping separator.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const GROUPING_USED = 1;

    /**
     * Always show decimal point.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DECIMAL_ALWAYS_SHOWN = 2;

    /**
     * Maximum integer digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MAX_INTEGER_DIGITS = 3;

    /**
     * Minimum integer digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MIN_INTEGER_DIGITS = 4;

    /**
     * Integer digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const INTEGER_DIGITS = 5;

    /**
     * Maximum fraction digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MAX_FRACTION_DIGITS = 6;

    /**
     * Minimum fraction digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MIN_FRACTION_DIGITS = 7;

    /**
     * Fraction digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const FRACTION_DIGITS = 8;

    /**
     * Multiplier.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MULTIPLIER = 9;

    /**
     * Grouping size.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const GROUPING_SIZE = 10;

    /**
     * Rounding Mode.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUNDING_MODE = 11;

    /**
     * Rounding increment.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ROUNDING_INCREMENT = 12;

    /**
     * The width to which the output of format() is padded.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const FORMAT_WIDTH = 13;

    /**
     * The position at which padding will take place. See pad position
     * constants for possible argument values.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PADDING_POSITION = 14;

    /**
     * Secondary grouping size.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const SECONDARY_GROUPING_SIZE = 15;

    /**
     * Use significant digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const SIGNIFICANT_DIGITS_USED = 16;

    /**
     * Minimum significant digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MIN_SIGNIFICANT_DIGITS = 17;

    /**
     * Maximum significant digits.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MAX_SIGNIFICANT_DIGITS = 18;

    /**
     * Lenient parse mode used by rule-based formats.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const LENIENT_PARSE = 19;

    /**
     * Positive prefix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const POSITIVE_PREFIX = 0;

    /**
     * Positive suffix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const POSITIVE_SUFFIX = 1;

    /**
     * Negative prefix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const NEGATIVE_PREFIX = 2;

    /**
     * Negative suffix.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const NEGATIVE_SUFFIX = 3;

    /**
     * The character used to pad to the format width.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PADDING_CHARACTER = 4;

    /**
     * The ISO currency code.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const CURRENCY_CODE = 5;

    /**
     * The default rule set. This is only available with rule-based
     * formatters.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DEFAULT_RULESET = 6;

    /**
     * The public rule sets. This is only available with rule-based
     * formatters. This is a read-only attribute. The public rulesets are
     * returned as a single string, with each ruleset name delimited by ';'
     * (semicolon).
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PUBLIC_RULESETS = 7;

    /**
     * The decimal separator.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DECIMAL_SEPARATOR_SYMBOL = 0;

    /**
     * The grouping separator.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const GROUPING_SEPARATOR_SYMBOL = 1;

    /**
     * The pattern separator.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PATTERN_SEPARATOR_SYMBOL = 2;

    /**
     * The percent sign.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PERCENT_SYMBOL = 3;

    /**
     * Zero.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ZERO_DIGIT_SYMBOL = 4;

    /**
     * Character representing a digit in the pattern.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DIGIT_SYMBOL = 5;

    /**
     * The minus sign.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MINUS_SIGN_SYMBOL = 6;

    /**
     * The plus sign.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PLUS_SIGN_SYMBOL = 7;

    /**
     * The currency symbol.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const CURRENCY_SYMBOL = 8;

    /**
     * The international currency symbol.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const INTL_CURRENCY_SYMBOL = 9;

    /**
     * The monetary separator.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MONETARY_SEPARATOR_SYMBOL = 10;

    /**
     * The exponential symbol.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const EXPONENTIAL_SYMBOL = 11;

    /**
     * Per mill symbol.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PERMILL_SYMBOL = 12;

    /**
     * Escape padding character.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PAD_ESCAPE_SYMBOL = 13;

    /**
     * Infinity symbol.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const INFINITY_SYMBOL = 14;

    /**
     * Not-a-number symbol.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const NAN_SYMBOL = 15;

    /**
     * Significant digit symbol.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const SIGNIFICANT_DIGIT_SYMBOL = 16;

    /**
     * The monetary grouping separator.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const MONETARY_GROUPING_SEPARATOR_SYMBOL = 17;

    /**
     * Derive the type from variable type
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const TYPE_DEFAULT = 0;

    /**
     * Format/parse as 32-bit integer
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const TYPE_INT32 = 1;

    /**
     * Format/parse as 64-bit integer
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const TYPE_INT64 = 2;

    /**
     * Format/parse as floating point value
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const TYPE_DOUBLE = 3;

    /**
     * Format/parse as currency value
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     * @deprecated 8.3
     */
    public const TYPE_CURRENCY = 4;
    /**
     * @since 8.4
     */
    public const ROUND_TOWARD_ZERO = 2;
    /**
     * @since 8.4
     */
    public const ROUND_AWAY_FROM_ZERO = 3;
    /**
     * @since 8.4
     */
    public const ROUND_HALFODD = 8;

    /**
     * @link https://www.php.net/manual/en/class.numberformatter.php
     * @param string $locale
     * @param int $style
     * @param string $pattern [optional]
     */
    #[Pure]
    public function __construct(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([NumberFormatter::DECIMAL, NumberFormatter::PATTERN_DECIMAL,
            NumberFormatter::PATTERN_RULEBASED, NumberFormatter::CURRENCY, NumberFormatter::PERCENT,
            NumberFormatter::SCIENTIFIC, NumberFormatter::SPELLOUT, NumberFormatter::ORDINAL,
            NumberFormatter::DURATION, NumberFormatter::PATTERN_RULEBASED, NumberFormatter::CURRENCY_ACCOUNTING,
            NumberFormatter::DEFAULT_STYLE, NumberFormatter::IGNORE])] $style,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $pattern = null
    ) {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Create a number formatter
     * @link https://php.net/manual/en/numberformatter.create.php
     * @param string $locale 

     * Locale in which the number would be formatted (locale name, e.g. en_CA).
     * 
     * @param int $style 

     * Style of the formatting, one of the
     * format style constants. If
     * NumberFormatter::PATTERN_DECIMAL
     * or NumberFormatter::PATTERN_RULEBASED
     * is passed then the number format is opened using the given pattern,
     * which must conform to the syntax described in
     * ICU DecimalFormat
     * documentation or
     * ICU RuleBasedNumberFormat
     * documentation, respectively.
     * 
     * @param string $pattern [optional] 

     * Pattern string if the chosen style requires a pattern.
     * 
     * @return NumberFormatter|false NumberFormatter object or FALSE on error.
     */
    #[TentativeType]
    public static function create(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([NumberFormatter::PATTERN_DECIMAL,
            NumberFormatter::PATTERN_RULEBASED, NumberFormatter::CURRENCY, NumberFormatter::PERCENT,
            NumberFormatter::SCIENTIFIC, NumberFormatter::SPELLOUT, NumberFormatter::ORDINAL,
            NumberFormatter::DURATION, NumberFormatter::PATTERN_RULEBASED, NumberFormatter::CURRENCY_ACCOUNTING,
            NumberFormatter::DEFAULT_STYLE, NumberFormatter::IGNORE])] $style,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $pattern = null
    ): ?NumberFormatter {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Format a number
     * @link https://php.net/manual/en/numberformatter.format.php
     * @param int|float $num 

     * The value to format. Can be integer or float,
     * other values will be converted to a numeric value.
     * 
     * @param int $type [optional] 

     * The
     * formatting type to use.
     * 
     * @return string|false the string containing formatted value, or FALSE on error.
     */
    #[Pure]
    #[TentativeType]
    public function format(
        #[LanguageAware(['8.0' => 'int|float'], default: '')] $num,
        #[LanguageAware(['8.0' => 'int'], default: '')] $type = 0
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Parse a number
     * @link https://php.net/manual/en/numberformatter.parse.php
     * @param string $string
     * @param int $type [optional] 

     * The
     * formatting type to use. By default,
     * NumberFormatter::TYPE_DOUBLE is used.
     * 
     * @param int &$offset [optional] 

     * Offset in the string at which to begin parsing. On return, this value
     * will hold the offset at which parsing ended.
     * 
     * @return mixed The value of the parsed number or FALSE on error.
     */
    #[TentativeType]
    public function parse(
        #[LanguageAware(['8.0' => 'string'], default: '')] $string,
        #[LanguageAware(['8.0' => 'int'], default: '')] $type = NumberFormatter::TYPE_DOUBLE,
        &$offset = null
    ): int|float|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Format a currency value
     * @link https://php.net/manual/en/numberformatter.formatcurrency.php
     * @param float $amount 

     * The numeric currency value.
     * 
     * @param string $currency 

     * The 3-letter ISO 4217 currency code indicating the currency to use.
     * 
     * @return string|false String representing the formatted currency value.
     */
    #[Pure]
    #[TentativeType]
    public function formatCurrency(
        #[LanguageAware(['8.0' => 'float'], default: '')] $amount,
        #[LanguageAware(['8.0' => 'string'], default: '')] $currency
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Parse a currency number
     * @link https://php.net/manual/en/numberformatter.parsecurrency.php
     * @param string $string
     * @param string &$currency 

     * Parameter to receive the currency name (3-letter ISO 4217 currency
     * code).
     * 
     * @param int &$offset [optional] 

     * Offset in the string at which to begin parsing. On return, this value
     * will hold the offset at which parsing ended.
     * 
     * @return float|false The parsed numeric value or FALSE on error.
     */
    #[TentativeType]
    public function parseCurrency(#[LanguageAware(['8.0' => 'string'], default: '')] $string, &$currency, &$offset = null): float|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set an attribute
     * @link https://php.net/manual/en/numberformatter.setattribute.php
     * @param int $attribute 

     * Attribute specifier - one of the
     * numeric attribute constants.
     * 
     * @param int $value 

     * The attribute value.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function setAttribute(
        #[LanguageAware(['8.0' => 'int'], default: '')] $attribute,
        #[LanguageAware(['8.0' => 'int|float'], default: '')] $value
    ): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get an attribute
     * @link https://php.net/manual/en/numberformatter.getattribute.php
     * @param int $attribute 

     * Attribute specifier - one of the
     * numeric attribute constants.
     * 
     * @return int|float|false Return attribute value on success, or FALSE on error.
     */
    #[Pure]
    #[TentativeType]
    public function getAttribute(#[LanguageAware(['8.0' => 'int'], default: '')] $attribute): int|float|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set a text attribute
     * @link https://php.net/manual/en/numberformatter.settextattribute.php
     * @param int $attribute 

     * Attribute specifier - one of the
     * text attribute
     * constants.
     * 
     * @param string $value 

     * Text for the attribute value.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function setTextAttribute(
        #[LanguageAware(['8.0' => 'int'], default: '')] $attribute,
        #[LanguageAware(['8.0' => 'string'], default: '')] $value
    ): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get a text attribute
     * @link https://php.net/manual/en/numberformatter.gettextattribute.php
     * @param int $attribute 

     * Attribute specifier - one of the
     * text attribute constants.
     * 
     * @return string|false Return attribute value on success, or FALSE on error.
     */
    #[Pure]
    #[TentativeType]
    public function getTextAttribute(#[LanguageAware(['8.0' => 'int'], default: '')] $attribute): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set a symbol value
     * @link https://php.net/manual/en/numberformatter.setsymbol.php
     * @param int $symbol 

     * Symbol specifier, one of the
     * format symbol constants.
     * 
     * @param string $value 

     * Text for the symbol.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function setSymbol(
        #[LanguageAware(['8.0' => 'int'], default: '')] $symbol,
        #[LanguageAware(['8.0' => 'string'], default: '')] $value
    ): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get a symbol value
     * @link https://php.net/manual/en/numberformatter.getsymbol.php
     * @param int $symbol 

     * Symbol specifier, one of the
     * format symbol constants.
     * 
     * @return string|false The symbol string or FALSE on error.
     */
    #[Pure]
    #[TentativeType]
    public function getSymbol(#[LanguageAware(['8.0' => 'int'], default: '')] $symbol): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set formatter pattern
     * @link https://php.net/manual/en/numberformatter.setpattern.php
     * @param string $pattern 

     * Pattern in syntax described in
     * ICU DecimalFormat
     * documentation.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function setPattern(#[LanguageAware(['8.0' => 'string'], default: '')] $pattern): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get formatter pattern
     * @link https://php.net/manual/en/numberformatter.getpattern.php
     * @return string|false Pattern string that is used by the formatter, or FALSE if an error happens.
     */
    #[Pure]
    #[TentativeType]
    public function getPattern(): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get formatter locale
     * @link https://php.net/manual/en/numberformatter.getlocale.php
     * @param int $type [optional] 

     * You can choose between valid and actual locale (
     * Locale::VALID_LOCALE,
     * Locale::ACTUAL_LOCALE,
     * respectively). The default is the actual locale.
     * 
     * @return string|false The locale name used to create the formatter.
     */
    #[Pure]
    #[TentativeType]
    public function getLocale(
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([Locale::VALID_LOCALE, Locale::ACTUAL_LOCALE])] $type = 0
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get formatter's last error code.
     * @link https://php.net/manual/en/numberformatter.geterrorcode.php
     * @return int error code from last formatter call.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get formatter's last error message.
     * @link https://php.net/manual/en/numberformatter.geterrormessage.php
     * @return string error message from last formatter call.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string {}
}

class Normalizer
{
    public const NFKC_CF = 48;
    public const FORM_KC_CF = 48;

    /**
     * Default normalization options
     * @link https://secure.php.net/manual/en/class.normalizer.php
     */
    public const OPTION_DEFAULT = "";

    /**
     * No decomposition/composition
     * @link https://secure.php.net/manual/en/class.normalizer.php
     * @removed 8.0
     */
    public const NONE = "1";

    /**
     * Normalization Form D (NFD) - Canonical Decomposition
     * @link https://secure.php.net/manual/en/class.normalizer.php
     */
    public const FORM_D = 4;
    public const NFD = 4;

    /**
     * Normalization Form KD (NFKD) - Compatibility Decomposition
     * @link https://secure.php.net/manual/en/class.normalizer.php
     */
    public const FORM_KD = 8;
    public const NFKD = 8;

    /**
     * Normalization Form C (NFC) - Canonical Decomposition followed by
     * Canonical Composition
     * @link https://secure.php.net/manual/en/class.normalizer.php
     */
    public const FORM_C = 16;
    public const NFC = 16;

    /**
     * Normalization Form KC (NFKC) - Compatibility Decomposition, followed by
     * Canonical Composition
     * @link https://secure.php.net/manual/en/class.normalizer.php
     */
    public const FORM_KC = 32;
    public const NFKC = 32;

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Normalizes the input provided and returns the normalized string
     * @link https://php.net/manual/en/normalizer.normalize.php
     * @param string $string 
The input string to normalize
     * @param int $form 
One of the normalization forms.
     * @return string|false The normalized string or FALSE if an error occurred.
     */
    #[TentativeType]
    public static function normalize(
        #[LanguageAware(['8.0' => 'string'], default: '')] $string,
        #[ElementAvailable(from: '5.3', to: '5.6')] $form,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'int'], default: '')] $form = Normalizer::FORM_C,
        #[ElementAvailable(from: '5.3', to: '5.6')] $arg3
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Checks if the provided string is already in the specified normalization form.
     * @link https://php.net/manual/en/normalizer.isnormalized.php
     * @param string $string 
The input string to normalize
     * @param int $form 

     * One of the normalization forms.
     * 
     * @return bool TRUE if normalized, FALSE otherwise or if there an error
     */
    #[TentativeType]
    public static function isNormalized(
        #[LanguageAware(['8.0' => 'string'], default: '')] $string,
        #[ElementAvailable(from: '5.3', to: '5.6')] $form,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'int'], default: '')] $form = Normalizer::FORM_C,
        #[ElementAvailable(from: '5.3', to: '5.6')] $arg3
    ): bool {}

    /**
     * @param string $string 
The input string to normalize
     * @param int $form
     * @return string|null 
Returns a string containing the Decomposition_Mapping property, if present in the UCD.
     * Returns null if there is no Decomposition_Mapping property for the character.
     * @link https://www.php.net/manual/en/normalizer.getrawdecomposition.php
     * @since 7.3
     */
    #[TentativeType]
    public static function getRawDecomposition(
        string $string,
        #[ElementAvailable(from: '8.0')] int $form = 16
    ): ?string {}
}

class Locale
{
    /**
     * This is locale the data actually comes from.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const ACTUAL_LOCALE = 0;

    /**
     * This is the most specific locale supported by ICU.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const VALID_LOCALE = 1;

    /**
     * Used as locale parameter with the methods of the various locale affected classes,
     * such as NumberFormatter. This constant would make the methods to use default
     * locale.
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const DEFAULT_LOCALE = null;

    /**
     * Language subtag
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const LANG_TAG = "language";

    /**
     * Extended language subtag
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const EXTLANG_TAG = "extlang";

    /**
     * Script subtag
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const SCRIPT_TAG = "script";

    /**
     * Region subtag
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const REGION_TAG = "region";

    /**
     * Variant subtag
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const VARIANT_TAG = "variant";

    /**
     * Grandfathered Language subtag
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const GRANDFATHERED_LANG_TAG = "grandfathered";

    /**
     * Private subtag
     * @link https://php.net/manual/en/class.numberformatter.php#intl.numberformatter-constants
     */
    public const PRIVATE_TAG = "private";

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Gets the default locale value from the INTL global 'default_locale'
     * @link https://php.net/manual/en/locale.getdefault.php
     * @return string The current runtime locale
     */
    #[TentativeType]
    public static function getDefault(): string {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * sets the default runtime locale
     * @link https://php.net/manual/en/locale.setdefault.php
     * @param string $locale 

     * Is a BCP 47 compliant language tag containing the
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public static function setDefault(#[LanguageAware(['8.0' => 'string'], default: '')] $locale) {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Gets the primary language for the input locale
     * @link https://php.net/manual/en/locale.getprimarylanguage.php
     * @param string $locale 

     * The locale to extract the primary language code from
     * 
     * @return string|null The language code associated with the language or NULL in case of error.
     */
    #[TentativeType]
    public static function getPrimaryLanguage(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): ?string {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Gets the script for the input locale
     * @link https://php.net/manual/en/locale.getscript.php
     * @param string $locale 

     * The locale to extract the script code from
     * 
     * @return string|null The script subtag for the locale or NULL if not present
     */
    #[TentativeType]
    public static function getScript(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): ?string {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Gets the region for the input locale
     * @link https://php.net/manual/en/locale.getregion.php
     * @param string $locale 

     * The locale to extract the region code from
     * 
     * @return string|null The region subtag for the locale or NULL if not present
     */
    #[TentativeType]
    public static function getRegion(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): ?string {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Gets the keywords for the input locale
     * @link https://php.net/manual/en/locale.getkeywords.php
     * @param string $locale 

     * The locale to extract the keywords from
     * 
     * @return array|false|null Associative array containing the keyword-value pairs for this locale
     */
    #[TentativeType]
    public static function getKeywords(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): array|false|null {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Returns an appropriately localized display name for script of the input locale
     * @link https://php.net/manual/en/locale.getdisplayscript.php
     * @param string $locale 

     * The locale to return a display script for
     * 
     * @param string $displayLocale 

     * Optional format locale to use to display the script name
     * 
     * @return string|false Display name of the script for the $locale in the format appropriate for
     * $in_locale.
     */
    #[TentativeType]
    public static function getDisplayScript(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '5.6')] $displayLocale,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'string|null'], default: '')] $displayLocale = null
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Returns an appropriately localized display name for region of the input locale
     * @link https://php.net/manual/en/locale.getdisplayregion.php
     * @param string $locale 

     * The locale to return a display region for.
     * 
     * @param string $displayLocale 

     * Optional format locale to use to display the region name
     * 
     * @return string|false display name of the region for the $locale in the format appropriate for
     * $in_locale.
     */
    #[TentativeType]
    public static function getDisplayRegion(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '5.6')] $displayLocale,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'string|null'], default: '')] $displayLocale = null
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Returns an appropriately localized display name for the input locale
     * @link https://php.net/manual/en/locale.getdisplayname.php
     * @param string $locale 

     * The locale to return a display name for.
     * 
     * @param string $displayLocale 
optional format locale
     * @return string|false Display name of the locale in the format appropriate for $in_locale.
     */
    #[TentativeType]
    public static function getDisplayName(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '5.6')] $displayLocale,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'string|null'], default: '')] $displayLocale = null
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Returns an appropriately localized display name for language of the inputlocale
     * @link https://php.net/manual/en/locale.getdisplaylanguage.php
     * @param string $locale 

     * The locale to return a display language for
     * 
     * @param string $displayLocale 

     * Optional format locale to use to display the language name
     * 
     * @return string|false display name of the language for the $locale in the format appropriate for
     * $in_locale.
     */
    #[TentativeType]
    public static function getDisplayLanguage(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '5.6')] $displayLocale,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'string|null'], default: '')] $displayLocale = null
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Returns an appropriately localized display name for variants of the input locale
     * @link https://php.net/manual/en/locale.getdisplayvariant.php
     * @param string $locale 

     * The locale to return a display variant for
     * 
     * @param string $displayLocale 

     * Optional format locale to use to display the variant name
     * 
     * @return string|false Display name of the variant for the $locale in the format appropriate for
     * $in_locale.
     */
    #[TentativeType]
    public static function getDisplayVariant(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '5.6')] $displayLocale,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'string|null'], default: '')] $displayLocale = null
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Returns a correctly ordered and delimited locale ID
     * @link https://php.net/manual/en/locale.composelocale.php
     * @param array $subtags 

     * an array containing a list of key-value pairs, where the keys identify
     * the particular locale ID subtags, and the values are the associated
     * subtag values.
     * 

     * The 'variant' and 'private' subtags can take maximum 15 values
     * whereas 'extlang' can take maximum 3 values.e.g. Variants are allowed
     * with the suffix ranging from 0-14. Hence the keys for the input array
     * can be variant0, variant1, ...,variant14. In the returned locale id,
     * the subtag is ordered by suffix resulting in variant0 followed by
     * variant1 followed by variant2 and so on.
     * 
     * 

     * The 'variant', 'private' and 'extlang' multiple values can be specified both
     * as array under specific key (e.g. 'variant') and as multiple numbered keys
     * (e.g. 'variant0', 'variant1', etc.).
     * 
     * 

     * @return string|false The corresponding locale identifier.
     */
    #[TentativeType]
    public static function composeLocale(array $subtags): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Returns a key-value array of locale ID subtag elements.
     * @link https://php.net/manual/en/locale.parselocale.php
     * @param string $locale 

     * The locale to extract the subtag array from. Note: The 'variant' and
     * 'private' subtags can take maximum 15 values whereas 'extlang' can take
     * maximum 3 values.
     * 
     * @return array|null an array containing a list of key-value pairs, where the keys
     * identify the particular locale ID subtags, and the values are the
     * associated subtag values. The array will be ordered as the locale id
     * subtags e.g. in the locale id if variants are '-varX-varY-varZ' then the
     * returned array will have variant0=>varX , variant1=>varY ,
     * variant2=>varZ
     */
    #[TentativeType]
    public static function parseLocale(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): ?array {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Gets the variants for the input locale
     * @link https://php.net/manual/en/locale.getallvariants.php
     * @param string $locale 

     * The locale to extract the variants from
     * 
     * @return array|null The array containing the list of all variants subtag for the locale
     * or NULL if not present
     */
    #[TentativeType]
    public static function getAllVariants(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): ?array {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Checks if a language tag filter matches with locale
     * @link https://php.net/manual/en/locale.filtermatches.php
     * @param string $languageTag 

     * The language tag to check
     * 
     * @param string $locale 

     * The language range to check against
     * 
     * @param bool $canonicalize 

     * If true, the arguments will be converted to canonical form before
     * matching.
     * 
     * @return bool|null TRUE if $locale matches $langtag FALSE otherwise.
     */
    #[TentativeType]
    public static function filterMatches(
        #[LanguageAware(['8.0' => 'string'], default: '')] $languageTag,
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '5.6')] $canonicalize,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'bool'], default: '')] $canonicalize = false
    ): ?bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Searches the language tag list for the best match to the language
     * @link https://php.net/manual/en/locale.lookup.php
     * @param array $languageTag 

     * An array containing a list of language tags to compare to
     * locale. Maximum 100 items allowed.
     * 
     * @param string $locale 

     * The locale to use as the language range when matching.
     * 
     * @param bool $canonicalize 

     * If true, the arguments will be converted to canonical form before
     * matching.
     * 
     * @param string $defaultLocale 

     * The locale to use if no match is found.
     * 
     * @return string|null The closest matching language tag or default value.
     */
    #[TentativeType]
    public static function lookup(
        array $languageTag,
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '5.6')] $canonicalize,
        #[ElementAvailable(from: '5.3', to: '5.6')] $defaultLocale,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'bool'], default: '')] $canonicalize = false,
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'string|null'], default: '')] $defaultLocale = null
    ): ?string {}

    /**
     * @link https://php.net/manual/en/locale.canonicalize.php
     * @param string $locale
     * @return string|null
     */
    #[TentativeType]
    public static function canonicalize(#[LanguageAware(['8.0' => 'string'], default: '')] $locale): ?string {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Tries to find out best available locale based on HTTP "Accept-Language" header
     * @link https://php.net/manual/en/locale.acceptfromhttp.php
     * @param string $header 

     * The string containing the "Accept-Language" header according to format in RFC 2616.
     * 
     * @return string|false The corresponding locale identifier.
     */
    #[TentativeType]
    public static function acceptFromHttp(#[LanguageAware(['8.0' => 'string'], default: '')] $header): string|false {}
}

class MessageFormatter
{
    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Constructs a new Message Formatter
     * @link https://php.net/manual/en/messageformatter.create.php
     * @param string $locale 

     * The locale to use when formatting arguments
     * 
     * @param string $pattern 

     * The pattern string to stick arguments into.
     * The pattern uses an 'apostrophe-friendly' syntax; it is run through
     * umsg_autoQuoteApostrophe
     * before being interpreted.
     * 
     * @throws IntlException on failure.
     */
    #[Pure]
    public function __construct(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'string'], default: '')] $pattern
    ) {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Constructs a new Message Formatter
     * @link https://php.net/manual/en/messageformatter.create.php
     * @param string $locale 

     * The locale to use when formatting arguments
     * 
     * @param string $pattern 

     * The pattern string to stick arguments into.
     * The pattern uses an 'apostrophe-friendly' syntax; it is run through
     * umsg_autoQuoteApostrophe
     * before being interpreted.
     * 
     * @return MessageFormatter|null The formatter object
     */
    #[TentativeType]
    public static function create(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'string'], default: '')] $pattern
    ): ?MessageFormatter {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Format the message
     * @link https://php.net/manual/en/messageformatter.format.php
     * @param array $values 

     * Arguments to insert into the format string
     * 
     * @return string|false The formatted string, or FALSE if an error occurred
     */
    #[Pure]
    #[TentativeType]
    public function format(array $values): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Quick format message
     * @link https://php.net/manual/en/messageformatter.formatmessage.php
     * @param string $locale 

     * The locale to use for formatting locale-dependent parts
     * 
     * @param string $pattern 

     * The pattern string to insert things into.
     * The pattern uses an 'apostrophe-friendly' syntax; it is run through
     * umsg_autoQuoteApostrophe
     * before being interpreted.
     * 
     * @param array $values 

     * The array of values to insert into the format string
     * 
     * @return string|false The formatted pattern string or FALSE if an error occurred
     */
    #[TentativeType]
    public static function formatMessage(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'string'], default: '')] $pattern,
        array $values
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Parse input string according to pattern
     * @link https://php.net/manual/en/messageformatter.parse.php
     * @param string $string 

     * The string to parse
     * 
     * @return array|false An array containing the items extracted, or FALSE on error
     */
    #[Pure]
    #[TentativeType]
    public function parse(#[LanguageAware(['8.0' => 'string'], default: '')] $string): array|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Quick parse input string
     * @link https://php.net/manual/en/messageformatter.parsemessage.php
     * @param string $locale 

     * The locale to use for parsing locale-dependent parts
     * 
     * @param string $pattern 

     * The pattern with which to parse the value.
     * 
     * @param string $message 

     * The string to parse, conforming to the pattern.
     * 
     * @return array|false An array containing items extracted, or FALSE on error
     */
    #[TentativeType]
    public static function parseMessage(
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'string'], default: '')] $pattern,
        #[LanguageAware(['8.0' => 'string'], default: '')] $message
    ): array|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set the pattern used by the formatter
     * @link https://php.net/manual/en/messageformatter.setpattern.php
     * @param string $pattern 

     * The pattern string to use in this message formatter.
     * The pattern uses an 'apostrophe-friendly' syntax; it is run through
     * umsg_autoQuoteApostrophe
     * before being interpreted.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function setPattern(#[LanguageAware(['8.0' => 'string'], default: '')] $pattern): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the pattern used by the formatter
     * @link https://php.net/manual/en/messageformatter.getpattern.php
     * @return string|false The pattern string for this message formatter
     */
    #[Pure]
    #[TentativeType]
    public function getPattern(): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the locale for which the formatter was created.
     * @link https://php.net/manual/en/messageformatter.getlocale.php
     * @return string The locale name
     */
    #[Pure]
    #[TentativeType]
    public function getLocale(): string {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the error code from last operation
     * @link https://php.net/manual/en/messageformatter.geterrorcode.php
     * @return int The error code, one of UErrorCode values. Initial value is U_ZERO_ERROR.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the error text from the last operation
     * @link https://php.net/manual/en/messageformatter.geterrormessage.php
     * @return string Description of the last error.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string {}
}

class IntlDateFormatter
{
    /**
     * Completely specified style (Tuesday, April 12, 1952 AD or 3:30:42pm PST)
     * @link https://php.net/manual/en/class.intldateformatter.php#intl.intldateformatter-constants
     */
    public const FULL = 0;

    /**
     * Long style (January 12, 1952 or 3:30:32pm)
     * @link https://php.net/manual/en/class.intldateformatter.php#intl.intldateformatter-constants
     */
    public const LONG = 1;

    /**
     * Medium style (Jan 12, 1952)
     * @link https://php.net/manual/en/class.intldateformatter.php#intl.intldateformatter-constants
     */
    public const MEDIUM = 2;

    /**
     * Most abbreviated style, only essential data (12/13/52 or 3:30pm)
     * @link https://php.net/manual/en/class.intldateformatter.php#intl.intldateformatter-constants
     */
    public const SHORT = 3;

    /**
     * Do not include this element
     * @link https://php.net/manual/en/class.intldateformatter.php#intl.intldateformatter-constants
     */
    public const NONE = -1;

    /**
     * Gregorian Calendar
     * @link https://php.net/manual/en/class.intldateformatter.php#intl.intldateformatter-constants
     */
    public const GREGORIAN = 1;

    /**
     * Non-Gregorian Calendar
     * @link https://php.net/manual/en/class.intldateformatter.php#intl.intldateformatter-constants
     */
    public const TRADITIONAL = 0;
    public const RELATIVE_FULL = 128;
    public const RELATIVE_LONG = 129;
    public const RELATIVE_MEDIUM = 130;
    public const RELATIVE_SHORT = 131;
    public const PATTERN = -2;

    /**
     * @param string|null $locale
     * @param int $dateType
     * @param int $timeType
     * @param mixed|null $timezone [optional]
     * @param mixed|null $calendar [optional]
     * @param string $pattern [optional]
     */
    #[Pure]
    public function __construct(
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '8.0')] #[LanguageAware(['8.0' => 'int'], default: '')] $dateType,
        #[ElementAvailable(from: '5.3', to: '8.0')] #[LanguageAware(['8.0' => 'int'], default: '')] $timeType,
        #[ElementAvailable(from: '8.1')] int $dateType = 0,
        #[ElementAvailable(from: '8.1')] int $timeType = 0,
        $timezone = null,
        $calendar = null,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $pattern = null
    ) {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Create a date formatter
     * @link https://php.net/manual/en/intldateformatter.create.php
     * @param string $locale 

     * Locale to use when formatting or parsing; default is specified in the ini setting intl.default_locale.
     * 
     * @param int $dateType 

     * Date type to use (none,
     * short, medium,
     * long, full).
     * This is one of the
     * IntlDateFormatter constants.
     * 
     * @param int $timeType 

     * Time type to use (none,
     * short, medium,
     * long, full).
     * This is one of the
     * IntlDateFormatter constants.
     * 
     * @param string $timezone [optional] 

     * Time zone ID, default is system default.
     * 
     * @param int $calendar [optional] 

     * Calendar to use for formatting or parsing; default is Gregorian.
     * This is one of the
     * IntlDateFormatter calendar constants.
     * 
     * @param string $pattern [optional] 

     * Optional pattern to use when formatting or parsing.
     * Possible patterns are documented at http://userguide.icu-project.org/formatparse/datetime.
     * 
     * @return IntlDateFormatter|null
     */
    #[TentativeType]
    public static function create(
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $locale,
        #[ElementAvailable(from: '5.3', to: '8.0')] #[LanguageAware(['8.0' => 'int'], default: '')] $dateType,
        #[ElementAvailable(from: '5.3', to: '8.0')] #[LanguageAware(['8.0' => 'int'], default: '')] $timeType,
        #[ElementAvailable(from: '8.1')] int $dateType = 0,
        #[ElementAvailable(from: '8.1')] int $timeType = 0,
        $timezone = null,
        #[LanguageAware(['8.0' => 'IntlCalendar|int|null'], default: '')] $calendar = null,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $pattern = null
    ): ?IntlDateFormatter {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the datetype used for the IntlDateFormatter
     * @link https://php.net/manual/en/intldateformatter.getdatetype.php
     * @return int|false The current date type value of the formatter.
     */
    #[Pure]
    #[TentativeType]
    public function getDateType(): int|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the timetype used for the IntlDateFormatter
     * @link https://php.net/manual/en/intldateformatter.gettimetype.php
     * @return int|false The current date type value of the formatter.
     */
    #[Pure]
    #[TentativeType]
    public function getTimeType(): int|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the calendar used for the IntlDateFormatter
     * @link https://php.net/manual/en/intldateformatter.getcalendar.php
     * @return int|false The calendar being used by the formatter.
     */
    #[Pure]
    #[TentativeType]
    public function getCalendar(): int|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * sets the calendar used to the appropriate calendar, which must be
     * @link https://php.net/manual/en/intldateformatter.setcalendar.php
     * @param int $calendar 

     * The calendar to use.
     * Default is IntlDateFormatter::GREGORIAN.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function setCalendar(#[LanguageAware(['8.0' => 'IntlCalendar|int|null'], default: '')] $calendar): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the timezone-id used for the IntlDateFormatter
     * @link https://php.net/manual/en/intldateformatter.gettimezoneid.php
     * @return string|false ID string for the time zone used by this formatter.
     */
    #[Pure]
    #[TentativeType]
    public function getTimeZoneId(): string|false {}

    /**
     * (PHP 5 >= 5.5.0, PECL intl >= 3.0.0)

     * Get copy of formatter's calendar object
     * @link https://secure.php.net/manual/en/intldateformatter.getcalendarobject.php
     * @return IntlCalendar|false|null A copy of the internal calendar object used by this formatter.
     */
    #[Pure]
    #[TentativeType]
    public function getCalendarObject(): IntlCalendar|false|null {}

    /**
     * (PHP 5 >= 5.5.0, PECL intl >= 3.0.0)

     *  Get formatter's timezone
     * @link https://secure.php.net/manual/en/intldateformatter.gettimezone.php
     * @return IntlTimeZone|false The associated IntlTimeZone object or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getTimeZone(): IntlTimeZone|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Sets the time zone to use
     * @link https://php.net/manual/en/intldateformatter.settimezoneid.php
     * @param string $zone 

     * The time zone ID string of the time zone to use.
     * If NULL or the empty string, the default time zone for the runtime is used.
     * 
     * @return bool TRUE on success or FALSE on failure.
     * @removed 7.0
     * @see IntlDateFormatter::setTimeZone()
     */
    #[Deprecated(replacement: "%class%->setTimeZone(%parametersList%)", since: "5.5")]
    public function setTimeZoneId($zone) {}

    /**
     * (PHP 5 >= 5.5.0, PECL intl >= 3.0.0)

     * Sets formatter's timezone
     * @link https://php.net/manual/en/intldateformatter.settimezone.php
     * @param mixed $timezone 

     * The timezone to use for this formatter. This can be specified in the
     * following forms:
     * 

     * 

     * 

     * NULL, in which case the default timezone will be used, as specified in
     * the ini setting {@link "https://secure.php.net/manual/en/datetime.configuration.php#ini.date.timezone" date.timezone} or
     * through the function  {@link "https://secure.php.net/manual/en/function.date-default-timezone-set.php" date_default_timezone_set()} and as
     * returned by {@link "https://secure.php.net/manual/en/function.date-default-timezone-get.php" date_default_timezone_get()}.
     * 
     * 
     * 

     * 

     * An {@link "https://secure.php.net/manual/en/class.intltimezone.php" IntlTimeZone}, which will be used directly.
     * 
     * 
     * 

     * 

     * A {@link "https://secure.php.net/manual/en/class.datetimezone.php" DateTimeZone}. Its identifier will be extracted
     * and an ICU timezone object will be created; the timezone will be backed
     * by ICU's database, not PHP's.
     * 
     * 
     * 

     * 

     * A {@link "https://secure.php.net/manual/en/language.types.string.php" string}, which should be a valid ICU timezone identifier.
     * See IntlTimeZone::createTimeZoneIDEnumeration(). Raw offsets such as "GMT+08:30" are also accepted.
     * 
     * 
     * 
     * 

     * @return bool|null TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    #[LanguageAware(['8.3' => 'bool'], default: 'bool|null')]
    public function setTimeZone($timezone) {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set the pattern used for the IntlDateFormatter
     * @link https://php.net/manual/en/intldateformatter.setpattern.php
     * @param string $pattern 

     * New pattern string to use.
     * Possible patterns are documented at http://userguide.icu-project.org/formatparse/datetime.
     * 
     * @return bool TRUE on success or FALSE on failure.
     * Bad formatstrings are usually the cause of the failure.
     */
    #[TentativeType]
    public function setPattern(#[LanguageAware(['8.0' => 'string'], default: '')] $pattern): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the pattern used for the IntlDateFormatter
     * @link https://php.net/manual/en/intldateformatter.getpattern.php
     * @return string|false The pattern string being used to format/parse.
     */
    #[Pure]
    #[TentativeType]
    public function getPattern(): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the locale used by formatter
     * @link https://php.net/manual/en/intldateformatter.getlocale.php
     * @param int $type [optional]
     * @return string|false the locale of this formatter or 'false' if error
     */
    #[Pure]
    #[TentativeType]
    public function getLocale(
        #[ElementAvailable(from: '8.0')] #[LanguageAware(['8.0' => 'int'], default: '')] $type = 0
    ): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Set the leniency of the parser
     * @link https://php.net/manual/en/intldateformatter.setlenient.php
     * @param bool $lenient 

     * Sets whether the parser is lenient or not, default is TRUE (lenient).
     * 
     * @return void
     */
    #[TentativeType]
    public function setLenient(#[LanguageAware(['8.0' => 'bool'], default: '')] $lenient): void {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the lenient used for the IntlDateFormatter
     * @link https://php.net/manual/en/intldateformatter.islenient.php
     * @return bool TRUE if parser is lenient, FALSE if parser is strict. By default the parser is lenient.
     */
    #[Pure]
    #[TentativeType]
    public function isLenient(): bool {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Format the date/time value as a string
     * @link https://php.net/manual/en/intldateformatter.format.php
     * @param mixed $datetime 

     * Value to format. This may be a DateTime object,
     * an integer representing a Unix timestamp value (seconds
     * since epoch, UTC) or an array in the format output by
     * localtime.
     * 
     * @return string|false The formatted string or, if an error occurred, FALSE.
     */
    #[TentativeType]
    public function format(
        #[ElementAvailable(from: '5.3', to: '7.4')] $datetime = null,
        #[ElementAvailable(from: '8.0')] $datetime,
        #[ElementAvailable(from: '5.3', to: '7.4')] $array = null
    ): string|false {}

    /**
     * (PHP 5 >= 5.5.0, PECL intl >= 3.0.0)

     * Formats an object
     * @link https://secure.php.net/manual/en/intldateformatter.formatobject.php
     * @param object $datetime 

     * An object of type {@link "https://secure.php.net/manual/en/class.intlcalendar.php" IntlCalendar} or {@link "https://secure.php.net/manual/en/class.datetime.php" DateTime}. The timezone information in the object will be used.
     * 
     * @param mixed $format [optional] 

     * How to format the date/time. This can either be an {@link "https://secure.php.net/manual/en/language.types.array.php" array} with
     * two elements (first the date style, then the time style, these being one
     * of the constants IntlDateFormatter::NONE,
     * IntlDateFormatter::SHORT,
     * IntlDateFormatter::MEDIUM,
     * IntlDateFormatter::LONG,
     * IntlDateFormatter::FULL), a long with
     * the value of one of these constants (in which case it will be used both
     * for the time and the date) or a {@link "https://secure.php.net/manual/en/language.types.string.php" string} with the format
     * described in {@link "http://www.icu-project.org/apiref/icu4c/classSimpleDateFormat.html#details" the ICU documentation}.
     * If NULL, the default style will be used.
     * 
     * @param string|null $locale [optional] 

     * The locale to use, or NULL to use the {@link "https://secure.php.net/manual/en/intl.configuration.php#ini.intl.default-locale" default one}.
     * @return string|false A string with result or FALSE on failure.
     */
    #[TentativeType]
    public static function formatObject($datetime, $format = null, #[LanguageAware(['8.0' => 'string|null'], default: '')] $locale = null): string|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Parse string to a timestamp value
     * @link https://php.net/manual/en/intldateformatter.parse.php
     * @param string $string 

     * string to convert to a time
     * 
     * @param int &$offset [optional] 

     * Position at which to start the parsing in $value (zero-based).
     * If no error occurs before $value is consumed, $parse_pos will contain -1
     * otherwise it will contain the position at which parsing ended (and the error occurred).
     * This variable will contain the end position if the parse fails.
     * If $parse_pos > strlen($value), the parse fails immediately.
     * 
     * @return int|float|false timestamp parsed value
     */
    #[TentativeType]
    public function parse(#[LanguageAware(['8.0' => 'string'], default: '')] $string, &$offset = null): int|float|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Parse string to a field-based time value
     * @link https://php.net/manual/en/intldateformatter.localtime.php
     * @param string $string 

     * string to convert to a time
     * 
     * @param int &$offset [optional] 

     * Position at which to start the parsing in $value (zero-based).
     * If no error occurs before $value is consumed, $parse_pos will contain -1
     * otherwise it will contain the position at which parsing ended .
     * If $parse_pos > strlen($value), the parse fails immediately.
     * 
     * @return array|false Localtime compatible array of integers : contains 24 hour clock value in tm_hour field
     */
    #[TentativeType]
    public function localtime(#[LanguageAware(['8.0' => 'string'], default: '')] $string, &$offset = null): array|false {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the error code from last operation
     * @link https://php.net/manual/en/intldateformatter.geterrorcode.php
     * @return int The error code, one of UErrorCode values. Initial value is U_ZERO_ERROR.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int {}

    /**
     * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

     * Get the error text from the last operation.
     * @link https://php.net/manual/en/intldateformatter.geterrormessage.php
     * @return string Description of the last error.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string {}

    /**
     * @since 8.4
     */
    public function parseToCalendar(string $string, &$offset = null): int|float|false {}
}

class ResourceBundle implements IteratorAggregate, Countable
{
    /**
     * @link https://www.php.net/manual/en/resourcebundle.create.php
     * @param string $locale 
Locale for which the resources should be loaded (locale name, e.g. en_CA).
     * @param string $bundle 
The directory where the data is stored or the name of the .dat file.
     * @param bool $fallback [optional] 
Whether locale should match exactly or fallback to parent locale is allowed.
     */
    #[Pure]
    public function __construct(
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $bundle,
        #[LanguageAware(['8.0' => 'bool'], default: '')] $fallback = true
    ) {}

    /**
     * (PHP >= 5.3.2, PECL intl >= 2.0.0)

     * Create a resource bundle
     * @link https://php.net/manual/en/resourcebundle.create.php
     * @param string $locale 

     * Locale for which the resources should be loaded (locale name, e.g. en_CA).
     * 
     * @param string $bundle 

     * The directory where the data is stored or the name of the .dat file.
     * 
     * @param bool $fallback [optional] 

     * Whether locale should match exactly or fallback to parent locale is allowed.
     * 
     * @return ResourceBundle|null ResourceBundle object or null on error.
     */
    #[TentativeType]
    public static function create(
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $bundle,
        #[LanguageAware(['8.0' => 'bool'], default: '')] $fallback = true
    ): ?ResourceBundle {}

    /**
     * (PHP >= 5.3.2, PECL intl >= 2.0.0)

     * Get data from the bundle
     * @link https://php.net/manual/en/resourcebundle.get.php
     * @param string|int $index 

     * Data index, must be string or integer.
     * 
     * @param bool $fallback
     * @return mixed the data located at the index or NULL on error. Strings, integers and binary data strings
     * are returned as corresponding PHP types, integer array is returned as PHP array. Complex types are
     * returned as ResourceBundle object.
     */
    #[Pure]
    #[TentativeType]
    #[LanguageAware(['8.4' => 'ResourceBundle|array|string|int|null'], default: 'mixed')]
    public function get(#[LanguageAware(['8.4' => 'string|int'], default: '')] $index, #[LanguageAware(['8.0' => 'bool'], default: '')] $fallback = true) {}

    /**
     * (PHP >= 5.3.2, PECL intl >= 2.0.0)

     * Get number of elements in the bundle
     * @link https://php.net/manual/en/resourcebundle.count.php
     * @return int<0,max> number of elements in the bundle.
     */
    #[Pure]
    #[TentativeType]
    public function count(): int {}

    /**
     * (PHP >= 5.3.2, PECL intl >= 2.0.0)

     * Get supported locales
     * @link https://php.net/manual/en/resourcebundle.locales.php
     * @param string $bundle 

     * Path of ResourceBundle for which to get available locales, or
     * empty string for default locales list.
     * 
     * @return array|false the list of locales supported by the bundle.
     */
    #[TentativeType]
    public static function getLocales(#[LanguageAware(['8.0' => 'string'], default: '')] $bundle): array|false {}

    /**
     * (PHP >= 5.3.2, PECL intl >= 2.0.0)

     * Get bundle's last error code.
     * @link https://php.net/manual/en/resourcebundle.geterrorcode.php
     * @return int error code from last bundle object call.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int {}

    /**
     * (PHP >= 5.3.2, PECL intl >= 2.0.0)

     * Get bundle's last error message.
     * @link https://php.net/manual/en/resourcebundle.geterrormessage.php
     * @return string error message from last bundle object's call.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string {}

    /**
     * @return Iterator
     * @since 8.0
     */
    #[Pure]
    public function getIterator(): Iterator {}
}

/**
 * @since 5.4
 */
class Transliterator
{
    public const FORWARD = 0;
    public const REVERSE = 1;

    /**
     * Starting 8.2 $id is readonly to unlock subclassing it
     */
    #[LanguageAware(['8.1' => 'string'], default: '')]
    public readonly string $id;

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Private constructor to deny instantiation
     * @link https://php.net/manual/en/transliterator.construct.php
     */
    final private function __construct() {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Create a transliterator
     * @link https://php.net/manual/en/transliterator.create.php
     * @param string $id 

     * The id.
     * 
     * @param int $direction [optional] 

     * The direction, defaults to
     * Transliterator::FORWARD.
     * May also be set to
     * Transliterator::REVERSE.
     * 
     * @return Transliterator|null a Transliterator object on success,
     * or NULL on failure.
     */
    #[TentativeType]
    public static function create(
        #[LanguageAware(['8.0' => 'string'], default: '')] $id,
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([Transliterator::FORWARD, Transliterator::REVERSE])] $direction = 0
    ): ?Transliterator {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Create transliterator from rules
     * @link https://php.net/manual/en/transliterator.createfromrules.php
     * @param string $rules 

     * The rules.
     * 
     * @param int $direction [optional] 

     * The direction, defaults to
     * {@see Transliterator::FORWARD}.
     * May also be set to
     * {@see Transliterator::REVERSE}.
     * 
     * @return Transliterator|null a Transliterator object on success,
     * or NULL on failure.
     */
    #[TentativeType]
    public static function createFromRules(
        #[LanguageAware(['8.0' => 'string'], default: '')] $rules,
        #[LanguageAware(['8.0' => 'int'], default: '')] #[EV([Transliterator::FORWARD, Transliterator::REVERSE])] $direction = 0
    ): ?Transliterator {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Create an inverse transliterator
     * @link https://php.net/manual/en/transliterator.createinverse.php
     * @return Transliterator|null a Transliterator object on success,
     * or NULL on failure
     */
    #[Pure]
    #[TentativeType]
    public function createInverse(): ?Transliterator {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Get transliterator IDs
     * @link https://php.net/manual/en/transliterator.listids.php
     * @return array|false An array of registered transliterator IDs on success,
     * or FALSE on failure.
     */
    #[TentativeType]
    public static function listIDs(): array|false {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Transliterate a string
     * @link https://php.net/manual/en/transliterator.transliterate.php
     * @param string $string 

     * The string to be transformed.
     * 
     * @param int $start [optional] 

     * The start index (in UTF-16 code units) from which the string will start
     * to be transformed, inclusive. Indexing starts at 0. The text before will
     * be left as is.
     * 
     * @param int $end [optional] 

     * The end index (in UTF-16 code units) until which the string will be
     * transformed, exclusive. Indexing starts at 0. The text after will be
     * left as is.
     * 
     * @return string|false The transfomed string on success, or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function transliterate(
        #[LanguageAware(['8.0' => 'string'], default: '')] $string,
        #[LanguageAware(['8.0' => 'int'], default: '')] $start = 0,
        #[LanguageAware(['8.0' => 'int'], default: '')] $end = -1
    ): string|false {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Get last error code
     * @link https://php.net/manual/en/transliterator.geterrorcode.php
     * @return int|false The error code on success,
     * or FALSE if none exists, or on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int|false {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Get last error message
     * @link https://php.net/manual/en/transliterator.geterrormessage.php
     * @return string|false The error code on success,
     * or FALSE if none exists, or on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string|false {}
}

/**
 * @link https://php.net/manual/en/class.spoofchecker.php
 */
class Spoofchecker
{
    public const SINGLE_SCRIPT_CONFUSABLE = 1;
    public const MIXED_SCRIPT_CONFUSABLE = 2;
    public const WHOLE_SCRIPT_CONFUSABLE = 4;
    public const ANY_CASE = 8;
    public const SINGLE_SCRIPT = 16;
    public const INVISIBLE = 32;
    public const CHAR_LIMIT = 64;
    public const ASCII = 268435456;
    public const HIGHLY_RESTRICTIVE = 805306368;
    public const MODERATELY_RESTRICTIVE = 1073741824;
    public const MINIMALLY_RESTRICTIVE = 1342177280;
    public const UNRESTRICTIVE = 1610612736;
    public const SINGLE_SCRIPT_RESTRICTIVE = 536870912;
    public const MIXED_NUMBERS = 1;
    public const HIDDEN_OVERLAY = 2;
    /**
     * @since 8.4
     */
    public const IGNORE_SPACE = 1;
    /**
     * @since 8.4
     */
    public const CASE_INSENSITIVE = 2;
    /**
     * @since 8.4
     */
    public const ADD_CASE_MAPPINGS = 4;
    /**
     * @since 8.4
     */
    public const SIMPLE_CASE_INSENSITIVE = 6;

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Constructor
     * @link https://php.net/manual/en/spoofchecker.construct.php
     */
    #[Pure]
    public function __construct() {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Checks if a given text contains any suspicious characters
     * @link https://php.net/manual/en/spoofchecker.issuspicious.php
     * @param string $string 

     * 
     * @param string &$errorCode [optional] 

     * 
     * @return bool
     */
    #[TentativeType]
    public function isSuspicious(#[LanguageAware(['8.0' => 'string'], default: '')] $string, &$errorCode = null): bool {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Checks if a given text contains any confusable characters
     * @link https://php.net/manual/en/spoofchecker.areconfusable.php
     * @param string $string1 

     * 
     * @param string $string2 

     * 
     * @param int &$errorCode [optional] 

     * 
     * @return bool
     */
    #[TentativeType]
    public function areConfusable(
        #[LanguageAware(['8.0' => 'string'], default: '')] $string1,
        #[LanguageAware(['8.0' => 'string'], default: '')] $string2,
        &$errorCode = null
    ): bool {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Locales to use when running checks
     * @link https://php.net/manual/en/spoofchecker.setallowedlocales.php
     * @param string $locales 

     * 
     * @return void
     */
    #[TentativeType]
    public function setAllowedLocales(#[LanguageAware(['8.0' => 'string'], default: '')] $locales): void {}

    /**
     * (PHP >= 5.4.0, PECL intl >= 2.0.0)

     * Set the checks to run
     * @link https://php.net/manual/en/spoofchecker.setchecks.php
     * @param int $checks 

     * 
     * @return void
     */
    #[TentativeType]
    public function setChecks(#[LanguageAware(['8.0' => 'int'], default: '')] $checks): void {}

    /**
     * @param int $level
     */
    #[TentativeType]
    public function setRestrictionLevel(#[LanguageAware(['8.0' => 'int'], default: '')] $level): void {}

    /**
     * @since 8.4
     */
    public function setAllowedChars(string $pattern, int $patternOptions = 0): void {}
}

/**
 * @since 5.5
 */
class IntlGregorianCalendar extends IntlCalendar
{
    /**
     * @link https://www.php.net/manual/en/intlgregoriancalendar.construct
     * @param int $timezoneOrYear [optional]
     * @param int $localeOrMonth [optional]
     * @param int $day [optional]
     * @param int $hour [optional]
     * @param int $minute [optional]
     * @param int $second [optional]
     */
    public function __construct($timezoneOrYear, $localeOrMonth, $day, $hour, $minute, $second) {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * @param mixed $timeZone
     * @param string $locale
     * @return IntlGregorianCalendar
     */
    public static function createInstance($timeZone = null, $locale = null) {}

    /**
     * @param float $timestamp
     */
    #[TentativeType]
    public function setGregorianChange(#[LanguageAware(['8.0' => 'float'], default: '')] $timestamp): bool {}

    /**
     * @return float
     */
    #[Pure]
    #[TentativeType]
    public function getGregorianChange(): float {}

    /**
     * @param int $year
     * @return bool
     */
    #[Pure]
    #[TentativeType]
    public function isLeapYear(#[LanguageAware(['8.0' => 'int'], default: '')] $year): bool {}

    /**
     * @since 8.3
     */
    public static function createFromDate(int $year, int $month, int $dayOfMonth): static {}

    /**
     * @since 8.3
     */
    public static function createFromDateTime(int $year, int $month, int $dayOfMonth, int $hour, int $minute, ?int $second = null): static {}
}

/**
 * @since 5.5
 */
class IntlCalendar
{
    /* Constants */
    public const FIELD_ERA = 0;
    public const FIELD_YEAR = 1;
    public const FIELD_MONTH = 2;
    public const FIELD_WEEK_OF_YEAR = 3;
    public const FIELD_WEEK_OF_MONTH = 4;
    public const FIELD_DATE = 5;
    public const FIELD_DAY_OF_YEAR = 6;
    public const FIELD_DAY_OF_WEEK = 7;
    public const FIELD_DAY_OF_WEEK_IN_MONTH = 8;
    public const FIELD_AM_PM = 9;
    public const FIELD_HOUR = 10;
    public const FIELD_HOUR_OF_DAY = 11;
    public const FIELD_MINUTE = 12;
    public const FIELD_SECOND = 13;
    public const FIELD_MILLISECOND = 14;
    public const FIELD_ZONE_OFFSET = 15;
    public const FIELD_DST_OFFSET = 16;
    public const FIELD_YEAR_WOY = 17;
    public const FIELD_DOW_LOCAL = 18;
    public const FIELD_EXTENDED_YEAR = 19;
    public const FIELD_JULIAN_DAY = 20;
    public const FIELD_MILLISECONDS_IN_DAY = 21;
    public const FIELD_IS_LEAP_MONTH = 22;
    public const FIELD_FIELD_COUNT = 23;
    public const FIELD_DAY_OF_MONTH = 5;
    public const DOW_SUNDAY = 1;
    public const DOW_MONDAY = 2;
    public const DOW_TUESDAY = 3;
    public const DOW_WEDNESDAY = 4;
    public const DOW_THURSDAY = 5;
    public const DOW_FRIDAY = 6;
    public const DOW_SATURDAY = 7;
    public const DOW_TYPE_WEEKDAY = 0;
    public const DOW_TYPE_WEEKEND = 1;
    public const DOW_TYPE_WEEKEND_OFFSET = 2;
    public const DOW_TYPE_WEEKEND_CEASE = 3;
    public const WALLTIME_FIRST = 1;
    public const WALLTIME_LAST = 0;
    public const WALLTIME_NEXT_VALID = 2;

    /* Methods */

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Add a (signed) amount of time to a field
     * @link https://secure.php.net/manual/en/intlcalendar.add.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}.
     * These are integer values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @param int $value 
The signed amount to add to the current field. If the amount is positive, the instant will be moved forward; if it is negative, the instant wil be moved into the past. The unit is implicit to the field type.
     * For instance, hours for IntlCalendar::FIELD_HOUR_OF_DAY.
     * @return bool Returns TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function add(
        #[LanguageAware(['8.0' => 'int'], default: '')] $field,
        #[LanguageAware(['8.0' => 'int'], default: '')] $value
    ): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Whether this object's time is after that of the passed object
     * https://secure.php.net/manual/en/intlcalendar.after.php
     * @param IntlCalendar $other 
The calendar whose time will be checked against this object's time.
     * @return bool
     * Returns TRUE if this object's current time is after that of the
     * calendar argument's time. Returns FALSE otherwise.
     * Also returns FALSE on failure. You can use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or
     * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to detect error conditions.
     */
    #[Pure]
    #[TentativeType]
    public function after(IntlCalendar $other): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Whether this object's time is before that of the passed object
     * @link https://secure.php.net/manual/en/intlcalendar.before.php
     * @param IntlCalendar $other 
 The calendar whose time will be checked against this object's time.
     * @return bool
     * Returns TRUE if this object's current time is before that of the
     * calendar argument's time. Returns FALSE otherwise.
     * Also returns FALSE on failure. You can use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or
     * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to detect error conditions.
     */
    #[Pure]
    #[TentativeType]
    public function before(IntlCalendar $other): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Clear a field or all fields
     * @link https://secure.php.net/manual/en/intlcalendar.clear.php
     * @param int $field [optional] 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return bool Returns TRUE on success or FALSE on failure. Failure can only occur is invalid arguments are provided.
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public function clear(#[LanguageAware(['8.0' => 'int|null'], default: '')] $field = null) {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Private constructor for disallowing instantiation
     * @link https://secure.php.net/manual/en/intlcalendar.construct.php
     */
    private function __construct() {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Create a new IntlCalendar
     * @link https://secure.php.net/manual/en/intlcalendar.createinstance.php
     * @param mixed $timezone [optional] 
 

     * The timezone to use.
     * 
     *
     * 

     * 

     * 

     * NULL, in which case the default timezone will be used, as specified in
     * the ini setting {@link https://secure.php.net/manual/en/datetime.configuration.php#ini.date.timezone date.timezone} or
     * through the function  {@link https://secure.php.net/manual/en/function.date-default-timezone-set.php date_default_timezone_set()} and as
     * returned by {@link https://secure.php.net/manual/en/function.date-default-timezone-get.php date_default_timezone_get()}.
     * 
     * 
     * 

     * 

     * An {@link https://secure.php.net/manual/en/class.intltimezone.php IntlTimeZone}, which will be used directly.
     * 
     * 
     * 

     * 

     * A {@link https://secure.php.net/manual/en/class.datetimezone.php DateTimeZone}. Its identifier will be extracted
     * and an ICU timezone object will be created; the timezone will be backed
     * by ICU's database, not PHP's.
     * 
     * 
     * 

     * 

     * A {@link https://secure.php.net/manual/en/language.types.string.php string}, which should be a valid ICU timezone identifier.
     * See  IntlTimeZone::createTimeZoneIDEnumeration(). Raw
     * offsets such as "GMT+08:30" are also accepted.
     * 
     * 
     * 
     * 

     * @param string|null $locale [optional] 

     * A locale to use or NULL to use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.default-locale the default locale}.
     * 
     * @return IntlCalendar|null
     * The created {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} instance or NULL on
     * failure.
     */
    #[TentativeType]
    public static function createInstance($timezone = null, #[LanguageAware(['8.0' => 'string|null'], default: '')] $locale = null): ?IntlCalendar {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Compare time of two IntlCalendar objects for equality
     * @link https://secure.php.net/manual/en/intlcalendar.equals.php
     * @param IntlCalendar $other
     * @return bool 

     * Returns TRUE if the current time of both this and the passed in
     * {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} object are the same, or FALSE
     * otherwise. The value FALSE can also be returned on failure. This can only
     * happen if bad arguments are passed in. In any case, the two cases can be
     * distinguished by calling  {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()}.
     * 
     */
    #[Pure]
    #[TentativeType]
    public function equals(#[LanguageAware(['8.0' => 'IntlCalendar'], default: '')] $other): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Calculate difference between given time and this object's time
     * @link https://secure.php.net/manual/en/intlcalendar.fielddifference.php
     * @param float $timestamp 

     * The time against which to compare the quantity represented by the
     * field. For the result to be positive, the time
     * given for this parameter must be ahead of the time of the object the
     * method is being invoked on.
     * 
     * @param int $field 

     * The field that represents the quantity being compared.
     * 
     *
     * 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return int|false Returns a (signed) difference of time in the unit associated with the
     * specified field or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function fieldDifference(
        #[LanguageAware(['8.0' => 'float'], default: '')] $timestamp,
        #[LanguageAware(['8.0' => 'int'], default: '')] $field
    ): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a2)

     * Create an IntlCalendar from a DateTime object or string
     * @link https://secure.php.net/manual/en/intlcalendar.fromdatetime.php
     * @param mixed $datetime 

     * A {@link https://secure.php.net/manual/en/class.datetime.php DateTime} object or a {@link https://secure.php.net/manual/en/language.types.string.php string} that
     * can be passed to  {@link https://secure.php.net/manual/en/datetime.construct.php DateTime::__construct()}.
     * 
     * @param $locale [optional]
     * @return IntlCalendar|null
     * The created {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} object or NULL in case of
     * failure. If a {@link https://secure.php.net/manual/en/language.types.string.php string} is passed, any exception that occurs
     * inside the {@link https://secure.php.net/manual/en/class.datetime.php DateTime} constructor is propagated.
     */
    #[TentativeType]
    public static function fromDateTime(
        #[LanguageAware(['8.0' => 'DateTime|string'], default: '')] $datetime,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] #[ElementAvailable(from: '8.0')] $locale
    ): ?IntlCalendar {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the value for a field
     * @link https://secure.php.net/manual/en/intlcalendar.get.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return int|false An integer with the value of the time field.
     */
    #[Pure]
    #[TentativeType]
    public function get(#[LanguageAware(['8.0' => 'int'], default: '')] $field): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * The maximum value for a field, considering the object's current time
     * @link https://secure.php.net/manual/en/intlcalendar.getactualmaximum.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return int|false
     * An {@link https://secure.php.net/manual/en/language.types.integer.php int} representing the maximum value in the units associated
     * with the given field or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getActualMaximum(#[LanguageAware(['8.0' => 'int'], default: '')] $field): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * The minimum value for a field, considering the object's current time
     * @link https://secure.php.net/manual/en/intlcalendar.getactualminimum.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}.
     * These are integer values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return int|false
     * An {@link https://secure.php.net/manual/en/language.types.integer.php int} representing the minimum value in the field's
     * unit or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getActualMinimum(#[LanguageAware(['8.0' => 'int'], default: '')] $field): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get array of locales for which there is data
     * @link https://secure.php.net/manual/en/intlcalendar.getavailablelocales.php
     * @return string[] An array of strings, one for which locale.
     */
    #[TentativeType]
    public static function getAvailableLocales(): array {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Tell whether a day is a weekday, weekend or a day that has a transition between the two
     * @param int $dayOfWeek 

     * One of the constants IntlCalendar::DOW_SUNDAY,
     * IntlCalendar::DOW_MONDAY, ...,
     * IntlCalendar::DOW_SATURDAY.
     * 
     * @return int|false
     * Returns one of the constants
     * IntlCalendar::DOW_TYPE_WEEKDAY,
     * IntlCalendar::DOW_TYPE_WEEKEND,
     * IntlCalendar::DOW_TYPE_WEEKEND_OFFSET or
     * IntlCalendar::DOW_TYPE_WEEKEND_CEASE or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getDayOfWeekType(#[LanguageAware(['8.0' => 'int'], default: '')] $dayOfWeek): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get last error code on the object
     * @link https://secure.php.net/manual/en/intlcalendar.geterrorcode.php
     * @return int|false An ICU error code indicating either success, failure or a warning.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get last error message on the object
     * @link https://secure.php.net/manual/en/intlcalendar.geterrormessage.php
     * @return string|false The error message associated with last error that occurred in a function call on this object, or a string indicating the non-existance of an error.
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the first day of the week for the calendar's locale
     * @link https://secure.php.net/manual/en/intlcalendar.getfirstdayofweek.php
     * @return int|false
     * One of the constants IntlCalendar::DOW_SUNDAY,
     * IntlCalendar::DOW_MONDAY, ...,
     * IntlCalendar::DOW_SATURDAY or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getFirstDayOfWeek(): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the largest local minimum value for a field
     * @link https://secure.php.net/manual/en/intlcalendar.getgreatestminimum.php
     * @param int $field
     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * @return int|false
     * An {@link https://secure.php.net/manual/en/language.types.integer.php int} representing a field value, in the field's
     * unit, or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getGreatestMinimum(#[LanguageAware(['8.0' => 'int'], default: '')] $field): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get set of locale keyword values
     * @param string $keyword 

     * The locale keyword for which relevant values are to be queried. Only
     * 'calendar' is supported.
     * 
     * @param string $locale 

     * The locale onto which the keyword/value pair are to be appended.
     * 
     * @param bool $onlyCommon
     * 

     * Whether to show only the values commonly used for the specified locale.
     * 
     * @return Iterator|false An iterator that yields strings with the locale keyword values or FALSE on failure.
     */
    #[TentativeType]
    public static function getKeywordValuesForLocale(
        #[LanguageAware(['8.0' => 'string'], default: '')] $keyword,
        #[LanguageAware(['8.0' => 'string'], default: '')] $locale,
        #[LanguageAware(['8.0' => 'bool'], default: '')] $onlyCommon
    ): IntlIterator|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the smallest local maximum for a field
     * @link https://secure.php.net/manual/en/intlcalendar.getleastmaximum.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return int|false
     * An {@link https://secure.php.net/manual/en/language.types.integer.ph int} representing a field value in the field's
     * unit or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getLeastMaximum(#[LanguageAware(['8.0' => 'int'], default: '')] $field): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the locale associated with the object
     * @link https://secure.php.net/manual/en/intlcalendar.getlocale.php
     * @param int $type 

     * Whether to fetch the actual locale (the locale from which the calendar
     * data originates, with Locale::ACTUAL_LOCALE) or the
     * valid locale, i.e., the most specific locale supported by ICU relatively
     * to the requested locale – see Locale::VALID_LOCALE.
     * From the most general to the most specific, the locales are ordered in
     * this fashion – actual locale, valid locale, requested locale.
     * 
     * @return string|false
     */
    #[Pure]
    #[TentativeType]
    public function getLocale(#[LanguageAware(['8.0' => 'int'], default: '')] $type): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the global maximum value for a field
     * @link https://secure.php.net/manual/en/intlcalendar.getmaximum.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return int|false
     */
    #[Pure]
    #[TentativeType]
    public function getMaximum(#[LanguageAware(['8.0' => 'int'], default: '')] $field): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get minimal number of days the first week in a year or month can have
     * @link https://secure.php.net/manual/en/intlcalendar.getminimaldaysinfirstweek.php
     * @return int|false
     * An {@link https://secure.php.net/manual/en/language.types.integer.php  int} representing a number of days or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getMinimalDaysInFirstWeek(): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the global minimum value for a field
     * @link https://secure.php.net/manual/en/intlcalendar.getminimum.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return int|false
     * An int representing a value for the given field in the field's unit or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getMinimum(#[LanguageAware(['8.0' => 'int'], default: '')] $field): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get number representing the current time
     * @return float A float representing a number of milliseconds since the epoch, not counting leap seconds.
     */
    #[TentativeType]
    public static function getNow(): float {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get behavior for handling repeating wall time
     * @link https://secure.php.net/manual/en/intlcalendar.getrepeatedwalltimeoption.php
     * @return int
     * One of the constants IntlCalendar::WALLTIME_FIRST or
     * IntlCalendar::WALLTIME_LAST.
     */
    #[Pure]
    #[TentativeType]
    public function getRepeatedWallTimeOption(): int {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get behavior for handling skipped wall time
     * @link https://secure.php.net/manual/en/intlcalendar.getskippedwalltimeoption.php
     * @return int
     * One of the constants IntlCalendar::WALLTIME_FIRST,
     * IntlCalendar::WALLTIME_LAST or
     * IntlCalendar::WALLTIME_NEXT_VALID.
     */
    #[Pure]
    #[TentativeType]
    public function getSkippedWallTimeOption(): int {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get time currently represented by the object
     * @return float|false
     * A {@link https://secure.php.net/manual/en/language.types.float.php float} representing the number of milliseconds elapsed since the
     * reference time (1 Jan 1970 00:00:00 UTC).
     */
    #[Pure]
    #[TentativeType]
    public function getTime(): float|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the object's timezone
     * @link https://secure.php.net/manual/en/intlcalendar.gettimezone.php
     * @return IntlTimeZone|false
     * An {@link https://secure.php.net/manual/en/class.intltimezone.php IntlTimeZone} object corresponding to the one used
     * internally in this object.
     */
    #[Pure]
    #[TentativeType]
    public function getTimeZone(): IntlTimeZone|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the calendar type
     * @link https://secure.php.net/manual/en/intlcalendar.gettype.php
     * @return string
     * A {@link https://secure.php.net/manual/en/language.types.string.php string} representing the calendar type, such as
     * 'gregorian', 'islamic', etc.
     */
    #[Pure]
    #[TentativeType]
    public function getType(): string {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get time of the day at which weekend begins or ends
     * @link https://secure.php.net/manual/en/intlcalendar.getweekendtransition.php
     * @param string $dayOfWeek 

     * One of the constants IntlCalendar::DOW_SUNDAY,
     * IntlCalendar::DOW_MONDAY, ...,
     * IntlCalendar::DOW_SATURDAY.
     * 
     * @return int|false
     * The number of milliseconds into the day at which the the weekend begins or
     * ends or FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function getWeekendTransition(#[LanguageAware(['8.0' => 'int'], default: '')] $dayOfWeek): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Whether the object's time is in Daylight Savings Time
     * @link https://secure.php.net/manual/en/intlcalendar.indaylighttime.php
     * @return bool
     * Returns TRUE if the date is in Daylight Savings Time, FALSE otherwise.
     * The value FALSE may also be returned on failure, for instance after
     * specifying invalid field values on non-lenient mode; use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or query
     * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to disambiguate.
     */
    #[Pure]
    #[TentativeType]
    public function inDaylightTime(): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Whether another calendar is equal but for a different time
     * @link https://secure.php.net/manual/en/intlcalendar.isequivalentto.php
     * @param IntlCalendar $other The other calendar against which the comparison is to be made.
     * @return bool
     * Assuming there are no argument errors, returns TRUE iif the calendars are equivalent except possibly for their set time.
     */
    #[Pure]
    #[TentativeType]
    public function isEquivalentTo(IntlCalendar $other): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Whether date/time interpretation is in lenient mode
     * @link https://secure.php.net/manual/en/intlcalendar.islenient.php
     * @return bool
     * A {@link https://secure.php.net/manual/en/language.types.boolean.php bool} representing whether the calendar is set to lenient mode.
     */
    #[Pure]
    #[TentativeType]
    public function isLenient(): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Whether a certain date/time is in the weekend
     * @link https://secure.php.net/manual/en/intlcalendar.isweekend.php
     * @param float|null $timestamp [optional] 

     * An optional timestamp representing the number of milliseconds since the
     * epoch, excluding leap seconds. If NULL, this object's current time is
     * used instead.
     * 
     * @return bool
     * 
 A {@link https://secure.php.net/manual/en/language.types.boolean.php bool} indicating whether the given or this object's time occurs
     * in a weekend.
     * 
     * 

     * The value FALSE may also be returned on failure, for instance after giving
     * a date out of bounds on non-lenient mode; use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or query
     * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to disambiguate.
     */
    #[Pure]
    #[TentativeType]
    public function isWeekend(#[LanguageAware(['8.0' => 'float|null'], default: '')] $timestamp = null): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Add value to field without carrying into more significant fields
     * @link https://secure.php.net/manual/en/intlcalendar.roll.php
     * @param int $field
     * 
One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time
     * {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @param mixed $value 

     * The (signed) amount to add to the field, TRUE for rolling up (adding
     * 1), or FALSE for rolling down (subtracting
     * 1).
     * 
     * @return bool Returns TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function roll(#[LanguageAware(['8.0' => 'int'], default: '')] $field, $value): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Whether a field is set
     * @link https://secure.php.net/manual/en/intlcalendar.isset.php
     * @param int $field 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time
     * {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}.
     * These are integer values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @return bool Assuming there are no argument errors, returns TRUE iif the field is set.
     */
    #[TentativeType]
    public function PS_UNRESERVE_PREFIX_isSet(#[LanguageAware(['8.0' => 'int'], default: '')] $field): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Set a time field or several common fields at once
     * @link https://secure.php.net/manual/en/intlcalendar.set.php
     * @param int $year 

     * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
     * values between 0 and
     * IntlCalendar::FIELD_COUNT.
     * 
     * @param int $month 

     * The new value for IntlCalendar::FIELD_MONTH.
     * 
     * @param int $dayOfMonth [optional] 

     * The new value for IntlCalendar::FIELD_DAY_OF_MONTH.
     * The month sequence is zero-based, i.e., January is represented by 0,
     * February by 1, ..., December is 11 and Undecember (if the calendar has
     * it) is 12.
     * 
     * @param int $hour [optional]
     * 

     * The new value for IntlCalendar::FIELD_HOUR_OF_DAY.
     * 
     * @param int $minute [optional]
     * 

     * The new value for IntlCalendar::FIELD_MINUTE.
     * 
     * @param int $second [optional] 

     * The new value for IntlCalendar::FIELD_SECOND.
     * 
     * @return bool Returns TRUE on success and FALSE on failure.
     */
    public function set($year, $month, $dayOfMonth = null, $hour = null, $minute = null, $second = null) {}

    /**
     * (PHP 5 >= 5.5.0 PECL intl >= 3.0.0a1)

     * Set a time field or several common fields at once
     * @link https://secure.php.net/manual/en/intlcalendar.set.php
     * @param int $field One of the IntlCalendar date/time field constants. These are integer values between 0 and IntlCalendar::FIELD_COUNT.
     * @param int $value The new value of the given field.
     * @return bool Returns TRUE on success and FALSE on failure.
     * @since 5.5
     */
    public function set($field, $value) {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Set the day on which the week is deemed to start
     * @link https://secure.php.net/manual/en/intlcalendar.setfirstdayofweek.php
     * @param int $dayOfWeek 

     * One of the constants IntlCalendar::DOW_SUNDAY,
     * IntlCalendar::DOW_MONDAY, ...,
     * IntlCalendar::DOW_SATURDAY.
     * 
     * @return bool Returns TRUE on success. Failure can only happen due to invalid parameters.
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public function setFirstDayOfWeek(#[LanguageAware(['8.0' => 'int'], default: '')] $dayOfWeek) {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Set whether date/time interpretation is to be lenient
     * @link https://secure.php.net/manual/en/intlcalendar.setlenient.php
     * @param bool $lenient 

     * Use TRUE to activate the lenient mode; FALSE otherwise.
     * 
     * @return bool Returns TRUE on success. Failure can only happen due to invalid parameters.
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public function setLenient(#[LanguageAware(['8.0' => 'bool'], default: '')] $lenient) {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Set behavior for handling repeating wall times at negative timezone offset transitions
     * @link https://secure.php.net/manual/en/intlcalendar.setrepeatedwalltimeoption.php
     * @param int $option 

     * One of the constants IntlCalendar::WALLTIME_FIRST or
     * IntlCalendar::WALLTIME_LAST.
     * 
     * @return bool
     * Returns TRUE on success. Failure can only happen due to invalid parameters.
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public function setRepeatedWallTimeOption(#[LanguageAware(['8.0' => 'int'], default: '')] $option) {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Set behavior for handling skipped wall times at positive timezone offset transitions
     * @link https://secure.php.net/manual/en/intlcalendar.setskippedwalltimeoption.php
     * @param int $option 

     * One of the constants IntlCalendar::WALLTIME_FIRST,
     * IntlCalendar::WALLTIME_LAST or
     * IntlCalendar::WALLTIME_NEXT_VALID.
     * 
     * @return bool
     * 

     * Returns TRUE on success. Failure can only happen due to invalid parameters.
     * 
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public function setSkippedWallTimeOption(#[LanguageAware(['8.0' => 'int'], default: '')] $option) {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Set the calendar time in milliseconds since the epoch
     * @link https://secure.php.net/manual/en/intlcalendar.settime.php
     * @param float $timestamp 

     * An instant represented by the number of number of milliseconds between
     * such instant and the epoch, ignoring leap seconds.
     * 
     * @return bool
     * Returns TRUE on success and FALSE on failure.
     */
    #[TentativeType]
    public function setTime(#[LanguageAware(['8.0' => 'float'], default: '')] $timestamp): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Set the timezone used by this calendar
     * @link https://secure.php.net/manual/en/intlcalendar.settimezone.php
     * @param mixed $timezone 

     * The new timezone to be used by this calendar. It can be specified in the
     * following ways:
     *
     * 

     * 

     * 

     * NULL, in which case the default timezone will be used, as specified in
     * the ini setting {@link https://secure.php.net/manual/en/datetime.configuration.php#ini.date.timezone date.timezone} or
     * through the function  {@link https://secure.php.net/manual/en/function.date-default-timezone-set.php date_default_timezone_set()} and as
     * returned by  {@link https://secure.php.net/manual/en/function.date-default-timezone-get.php date_default_timezone_get()}.
     * 
     * 
     * 

     * 

     * An {@link https://secure.php.net/manual/en/class.intltimezone.php IntlTimeZone}, which will be used directly.
     * 
     * 
     * 

     * 

     * A {@link https://secure.php.net/manual/en/class.datetimezone.php DateTimeZone}. Its identifier will be extracted
     * and an ICU timezone object will be created; the timezone will be backed
     * by ICU's database, not PHP's.
     * 
     * 
     * 

     * 

     * A {@link https://secure.php.net/manual/en/language.types.string.php string}, which should be a valid ICU timezone identifier.
     * See  b>IntlTimeZone::createTimeZoneIDEnumeration(). Raw
     * offsets such as "GMT+08:30" are also accepted.
     * 
     * 
     * 
     * @return bool Returns TRUE on success and FALSE on failure.
     */
    #[TentativeType]
    public function setTimeZone($timezone): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a2)

     * Convert an IntlCalendar into a DateTime object
     * @link https://secure.php.net/manual/en/intlcalendar.todatetime.php
     * @return DateTime|false
     * A {@link https://secure.php.net/manual/en/class.datetime.php DateTime} object with the same timezone as this
     * object (though using PHP's database instead of ICU's) and the same time,
     * except for the smaller precision (second precision instead of millisecond).
     * Returns FALSE on failure.
     */
    #[Pure]
    #[TentativeType]
    public function toDateTime(): DateTime|false {}

    /**
     * @link https://www.php.net/manual/en/intlcalendar.setminimaldaysinfirstweek.php
     * @param int $days
     * @return bool
     */
    #[LanguageAware(['8.4' => 'true'], default: 'bool')]
    #[TentativeType]
    public function setMinimalDaysInFirstWeek(#[LanguageAware(['8.0' => 'int'], default: '')] $days) {}

    /**
     * @since 8.3
     */
    public function setDate(int $year, int $month, int $dayOfMonth): void {}

    /**
     * @since 8.3
     */
    public function setDateTime(int $year, int $month, int $dayOfMonth, int $hour, int $minute, ?int $second = null): void {}
}

/**
 * @since 5.5
 */
class IntlIterator implements Iterator
{
    #[TentativeType]
    public function current(): mixed {}

    #[TentativeType]
    public function key(): mixed {}

    #[TentativeType]
    public function next(): void {}

    #[TentativeType]
    public function rewind(): void {}

    #[TentativeType]
    public function valid(): bool {}
}

/**
 * @since 5.5
 */
class IntlException extends Exception {}

/**
 * @since 5.5
 */
class IntlTimeZone
{
    /* Constants */
    public const DISPLAY_SHORT = 1;
    public const DISPLAY_LONG = 2;
    public const DISPLAY_SHORT_GENERIC = 3;
    public const DISPLAY_LONG_GENERIC = 4;
    public const DISPLAY_SHORT_GMT = 5;
    public const DISPLAY_LONG_GMT = 6;
    public const DISPLAY_SHORT_COMMONLY_USED = 7;
    public const DISPLAY_GENERIC_LOCATION = 8;
    public const TYPE_ANY = 0;
    public const TYPE_CANONICAL = 1;
    public const TYPE_CANONICAL_LOCATION = 2;

    /* Methods */

    private function __construct() {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the number of IDs in the equivalency group that includes the given ID
     * @link https://secure.php.net/manual/en/intltimezone.countequivalentids.php
     * @param string $timezoneId
     * @return int|false number of IDs or FALSE on failure
     */
    #[TentativeType]
    public static function countEquivalentIDs(#[LanguageAware(['8.0' => 'string'], default: '')] $timezoneId): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Create a new copy of the default timezone for this host
     * @link https://secure.php.net/manual/en/intltimezone.createdefault.php
     * @return IntlTimeZone
     */
    #[TentativeType]
    public static function createDefault(): IntlTimeZone {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get an enumeration over time zone IDs associated with the given country or offset
     * @link https://secure.php.net/manual/en/intltimezone.createenumeration.php
     * @param mixed $countryOrRawOffset [optional]
     * @return IntlIterator|false an iterator or FALSE on failure
     */
    #[TentativeType]
    public static function createEnumeration($countryOrRawOffset): IntlIterator|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Create a timezone object for the given ID
     * @link https://secure.php.net/manual/en/intltimezone.createtimezone.php
     * @param string $timezoneId
     * @return IntlTimeZone|null a timezone object or NULL on failure
     */
    #[TentativeType]
    public static function createTimeZone(#[LanguageAware(['8.0' => 'string'], default: '')] $timezoneId): ?IntlTimeZone {}

    /**
     * (PHP 5 >=5.5.0)

     * Get an enumeration over system time zone IDs with the given filter conditions
     * @link https://secure.php.net/manual/en/intltimezone.createtimezoneidenumeration.php
     * @param int $type
     * @param string|null $region [optional]
     * @param int $rawOffset [optional]
     * @return IntlIterator|false an iterator or FALSE on failure
     */
    #[TentativeType]
    public static function createTimeZoneIDEnumeration(
        #[LanguageAware(['8.0' => 'int'], default: '')] $type,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $region = null,
        #[LanguageAware(['8.0' => 'int|null'], default: '')] $rawOffset = null
    ): IntlIterator|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Create a timezone object from DateTimeZone
     * @link https://secure.php.net/manual/en/intltimezone.fromdatetimezone.php
     * @param DateTimeZone $timezone
     * @return IntlTimeZone|null a timezone object or NULL on failure
     */
    #[TentativeType]
    public static function fromDateTimeZone(#[LanguageAware(['8.0' => 'DateTimeZone'], default: '')] $timezone): ?IntlTimeZone {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID
     * @link https://secure.php.net/manual/en/intltimezone.getcanonicalid.php
     * @param string $timezoneId
     * @param bool &$isSystemId [optional]
     * @return string|false the timezone ID or FALSE on failure
     */
    #[TentativeType]
    public static function getCanonicalID(#[LanguageAware(['8.0' => 'string'], default: '')] $timezoneId, &$isSystemId): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get a name of this time zone suitable for presentation to the user
     * @param bool $dst [optional]
     * @param int $style [optional]
     * @param string $locale [optional]
     * @return string|false the timezone name or FALSE on failure
     */
    #[Pure]
    #[TentativeType]
    public function getDisplayName(
        #[LanguageAware(['8.0' => 'bool'], default: '')] $dst = false,
        #[LanguageAware(['8.0' => 'int'], default: '')] $style = 2,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $locale
    ): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the amount of time to be added to local standard time to get local wall clock time
     * @link https://secure.php.net/manual/en/intltimezone.getequivalentid.php
     * @return int
     */
    #[Pure]
    #[TentativeType]
    public function getDSTSavings(): int {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get an ID in the equivalency group that includes the given ID
     * @link https://secure.php.net/manual/en/intltimezone.getequivalentid.php
     * @param string $timezoneId
     * @param int $offset
     * @return string|false the time zone ID or FALSE on failure
     */
    #[TentativeType]
    public static function getEquivalentID(
        #[LanguageAware(['8.0' => 'string'], default: '')] $timezoneId,
        #[LanguageAware(['8.0' => 'int'], default: '')] $offset
    ): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get last error code on the object
     * @link https://secure.php.net/manual/en/intltimezone.geterrorcode.php
     * @return int|false
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get last error message on the object
     * @link https://secure.php.net/manual/en/intltimezone.geterrormessage.php
     * @return string|false
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Create GMT (UTC) timezone
     * @link https://secure.php.net/manual/en/intltimezone.getgmt.php
     * @return IntlTimeZone
     */
    #[TentativeType]
    public static function getGMT(): IntlTimeZone {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get timezone ID
     * @return string|false
     */
    #[Pure]
    #[TentativeType]
    public function getID(): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the time zone raw and GMT offset for the given moment in time
     * @link https://secure.php.net/manual/en/intltimezone.getoffset.php
     * @param float $timestamp
     *   moment in time for which to return offsets, in units of milliseconds from
     *   January 1, 1970 0:00 GMT, either GMT time or local wall time, depending on
     *   `local'.
     * @param bool $local
     *   if true, `date' is local wall time; otherwise it is in GMT time.
     * @param int &$rawOffset
     *   output parameter to receive the raw offset, that is, the offset not
     *   including DST adjustments
     * @param int &$dstOffset
     *   output parameter to receive the DST offset, that is, the offset to be added
     *   to `rawOffset' to obtain the total offset between local and GMT time. If
     *   DST is not in effect, this value is zero; otherwise it is a positive value,
     *   typically one hour.
     * @return bool boolean indication of success
     */
    #[TentativeType]
    public function getOffset(
        #[LanguageAware(['8.0' => 'float'], default: '')] $timestamp,
        #[LanguageAware(['8.0' => 'bool'], default: '')] $local,
        &$rawOffset,
        &$dstOffset
    ): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the raw GMT offset (before taking daylight savings time into account
     * @link https://secure.php.net/manual/en/intltimezone.getrawoffset.php
     * @return int
     */
    #[Pure]
    #[TentativeType]
    public function getRawOffset(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the region code associated with the given system time zone ID
     * @link https://secure.php.net/manual/en/intltimezone.getregion.php
     * @param string $timezoneId
     * @return string|false region or FALSE on failure
     */
    #[TentativeType]
    public static function getRegion(#[LanguageAware(['8.0' => 'string'], default: '')] $timezoneId): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Get the timezone data version currently used by ICU
     * @link https://secure.php.net/manual/en/intltimezone.gettzdataversion.php
     * @return string|false
     */
    #[TentativeType]
    public static function getTZDataVersion(): string|false {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the "unknown" time zone
     * @link https://secure.php.net/manual/en/intltimezone.getunknown.php
     * @return IntlTimeZone
     */
    #[TentativeType]
    public static function getUnknown(): IntlTimeZone {}

    /**
     * (PHP 7 >=7.1.0)

     * Translates a system timezone (e.g. "America/Los_Angeles") into a Windows
     * timezone (e.g. "Pacific Standard Time").
     * @link https://secure.php.net/manual/en/intltimezone.getwindowsid.php
     * @param string $timezoneId
     * @return string|false the Windows timezone or FALSE on failure
     * @since 7.1
     */
    #[TentativeType]
    public static function getWindowsID(string $timezoneId): string|false {}

    /**
     * @link https://www.php.net/manual/en/intltimezone.getidforwindowsid.php
     * @param string $timezoneId
     * @param string|null $region
     * @return string|false the Windows timezone or FALSE on failure
     * @since 7.1
     */
    #[TentativeType]
    public static function getIDForWindowsID(string $timezoneId, ?string $region = null): string|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Check if this zone has the same rules and offset as another zone
     * @link https://secure.php.net/manual/en/intltimezone.hassamerules.php
     * @param IntlTimeZone $other
     * @return bool
     */
    #[Pure]
    #[TentativeType]
    public function hasSameRules(IntlTimeZone $other): bool {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Convert to DateTimeZone object
     * @link https://secure.php.net/manual/en/intltimezone.todatetimezone.php
     * @return DateTimeZone|false the DateTimeZone object or FALSE on failure
     */
    #[Pure]
    #[TentativeType]
    public function toDateTimeZone(): DateTimeZone|false {}

    /**
     * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

     * Check if this time zone uses daylight savings time
     * @link https://secure.php.net/manual/en/intltimezone.usedaylighttime.php
     * @return bool
     */
    #[TentativeType]
    public function useDaylightTime(): bool {}

    /**
     * @since 8.4
     */
    public static function getIanaID(string $timezoneId): string|false {}
}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Create a collator
 * @link https://php.net/manual/en/collator.create.php
 * @param string $locale 

 * The locale containing the required collation rules. Special values for
 * locales can be passed in - if null is passed for the locale, the
 * default locale collation rules will be used. If empty string ("") or
 * "root" are passed, UCA rules will be used.
 * 
 * @return Collator|null Return new instance of Collator object, or NULL
 * on error.
 */
#[Pure]
function collator_create(string $locale): ?Collator {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Compare two Unicode strings
 * @link https://php.net/manual/en/collator.compare.php
 * @param Collator $object
 * @param string $string1 

 * The first string to compare.
 * 
 * @param string $string2 

 * The second string to compare.
 * 
 * @return int|false Return comparison result:

 * 

 * 

 * 1 if string1 is greater than
 * string2 ;
 * 
 * 

 * 0 if string1 is equal to
 * string2;
 * 
 * 

 * -1 if string1 is less than
 * string2 .
 * 
 * On error
 * boolean
 * FALSE
 * is returned.
 */
#[Pure]
function collator_compare(Collator $object, string $string1, string $string2): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get collation attribute value
 * @link https://php.net/manual/en/collator.getattribute.php
 * @param Collator $object
 * @param int $attribute 

 * Attribute to get value for.
 * 
 * @return int|false Attribute value, or boolean FALSE on error.
 */
#[Pure]
function collator_get_attribute(Collator $object, int $attribute): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set collation attribute
 * @link https://php.net/manual/en/collator.setattribute.php
 * @param Collator $object
 * @param int $attribute 
Attribute.
 * @param int $value 

 * Attribute value.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function collator_set_attribute(Collator $object, int $attribute, int $value): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get current collation strength
 * @link https://php.net/manual/en/collator.getstrength.php
 * @param Collator $object
 * @return int current collation strength
 */
#[Pure]
function collator_get_strength(Collator $object): int {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set collation strength
 * @link https://php.net/manual/en/collator.setstrength.php
 * @param Collator $object
 * @param int $strength 
Strength to set.
 * 

 * Possible values are:
 * Collator::PRIMARY
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
#[LanguageAware(['8.4' => 'true'], default: 'bool')]
function collator_set_strength(Collator $object, int $strength) {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Sort array using specified collator
 * @link https://php.net/manual/en/collator.sort.php
 * @param Collator $object
 * @param string[] &$array 

 * Array of strings to sort.
 * 
 * @param int $flags 

 * Optional sorting type, one of the following:
 * 
 * 

 * Collator::SORT_REGULAR
 * - compare items normally (don't change types)
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function collator_sort(Collator $object, array &$array, int $flags = 0): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Sort array using specified collator and sort keys
 * @link https://php.net/manual/en/collator.sortwithsortkeys.php
 * @param Collator $object
 * @param string[] &$array 
Array of strings to sort
 * @return bool TRUE on success or FALSE on failure.
 */
function collator_sort_with_sort_keys(
    Collator $object,
    array &$array,
    #[ElementAvailable(from: '5.3', to: '5.6')] $sort_flags = []
): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Sort array maintaining index association
 * @link https://php.net/manual/en/collator.asort.php
 * @param Collator $object
 * @param string[] &$array 
Array of strings to sort.
 * @param int $flags 

 * Optional sorting type, one of the following:
 * Collator::SORT_REGULAR
 * - compare items normally (don't change types)
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function collator_asort(Collator $object, array &$array, int $flags = 0): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the locale name of the collator
 * @link https://php.net/manual/en/collator.getlocale.php
 * @param Collator $object
 * @param int $type 

 * You can choose between valid and actual locale (
 * Locale::VALID_LOCALE and
 * Locale::ACTUAL_LOCALE,
 * respectively). The default is the actual locale.
 * 
 * @return string|false Real locale name from which the collation data comes. If the collator was
 * instantiated from rules or an error occurred, returns
 * boolean FALSE.
 */
#[Pure]
function collator_get_locale(Collator $object, int $type): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get collator's last error code
 * @link https://php.net/manual/en/collator.geterrorcode.php
 * @param Collator $object
 * @return int|false Error code returned by the last Collator API function call.
 */
#[Pure(true)]
function collator_get_error_code(Collator $object): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get text for collator's last error code
 * @link https://php.net/manual/en/collator.geterrormessage.php
 * @param Collator $object
 * @return string|false Description of an error occurred in the last Collator API function call.
 */
#[Pure]
function collator_get_error_message(Collator $object): string|false {}

/**
 * (PHP 5 >= 5.3.2, PHP 7, PECL intl >= 1.0.3)

 * Get sorting key for a string
 * @link https://php.net/manual/en/collator.getsortkey.php
 * @param Collator $object
 * @param string $string 

 * The string to produce the key from.
 * 
 * @return string|false the collation key for the string. Collation keys can be compared directly instead of strings.
 */
#[Pure]
function collator_get_sort_key(
    Collator $object,
    string $string,
    #[ElementAvailable(from: '5.3', to: '5.6')] $arg3
): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Create a number formatter
 * @link https://php.net/manual/en/numberformatter.create.php
 * @param string $locale 

 * Locale in which the number would be formatted (locale name, e.g. en_CA).
 * 
 * @param int $style 

 * Style of the formatting, one of the
 * format style constants. If
 * NumberFormatter::PATTERN_DECIMAL
 * or NumberFormatter::PATTERN_RULEBASED
 * is passed then the number format is opened using the given pattern,
 * which must conform to the syntax described in
 * ICU DecimalFormat
 * documentation or
 * ICU RuleBasedNumberFormat
 * documentation, respectively.
 * 
 * @param string|null $pattern [optional] 

 * Pattern string if the chosen style requires a pattern.
 * 
 * @return NumberFormatter|null NumberFormatter object or NULL on error.
 */
#[Pure]
function numfmt_create(string $locale, int $style, #[LanguageAware(['8.0' => 'string|null'], default: 'string')] $pattern = null): ?NumberFormatter {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Format a number
 * @link https://php.net/manual/en/numberformatter.format.php
 * @param NumberFormatter $formatter
 * @param int|float $num 

 * The value to format. Can be integer or float,
 * other values will be converted to a numeric value.
 * 
 * @param int $type 

 * The
 * formatting type to use.
 * 
 * @return string|false the string containing formatted value, or FALSE on error.
 */
#[Pure]
function numfmt_format(NumberFormatter $formatter, int|float $num, int $type = 0): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Parse a number
 * @link https://php.net/manual/en/numberformatter.parse.php
 * @param NumberFormatter $formatter
 * @param string $string
 * @param int $type [optional] 

 * The
 * formatting type to use. By default,
 * NumberFormatter::TYPE_DOUBLE is used.
 * 
 * @param int &$offset [optional] 

 * Offset in the string at which to begin parsing. On return, this value
 * will hold the offset at which parsing ended.
 * 
 * @return int|float|false The value of the parsed number or FALSE on error.
 */
#[Pure]
function numfmt_parse(NumberFormatter $formatter, string $string, int $type = NumberFormatter::TYPE_DOUBLE, &$offset = null): int|float|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Format a currency value
 * @link https://php.net/manual/en/numberformatter.formatcurrency.php
 * @param NumberFormatter $formatter
 * @param float $amount 

 * The numeric currency value.
 * 
 * @param string $currency 

 * The 3-letter ISO 4217 currency code indicating the currency to use.
 * 
 * @return string|false String representing the formatted currency value.
 */
#[Pure]
function numfmt_format_currency(NumberFormatter $formatter, float $amount, string $currency): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Parse a currency number
 * @link https://php.net/manual/en/numberformatter.parsecurrency.php
 * @param NumberFormatter $formatter
 * @param string $string
 * @param string &$currency 

 * Parameter to receive the currency name (3-letter ISO 4217 currency
 * code).
 * 
 * @param int &$offset [optional] 

 * Offset in the string at which to begin parsing. On return, this value
 * will hold the offset at which parsing ended.
 * 
 * @return float|false The parsed numeric value or FALSE on error.
 */
function numfmt_parse_currency(NumberFormatter $formatter, string $string, &$currency, &$offset = null): float|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set an attribute
 * @link https://php.net/manual/en/numberformatter.setattribute.php
 * @param NumberFormatter $formatter
 * @param int $attribute 

 * Attribute specifier - one of the
 * numeric attribute constants.
 * 
 * @param int|float $value 

 * The attribute value.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function numfmt_set_attribute(NumberFormatter $formatter, int $attribute, int|float $value): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get an attribute
 * @link https://php.net/manual/en/numberformatter.getattribute.php
 * @param NumberFormatter $formatter
 * @param int $attribute 

 * Attribute specifier - one of the
 * numeric attribute constants.
 * 
 * @return int|float|false Return attribute value on success, or FALSE on error.
 */
#[Pure]
function numfmt_get_attribute(NumberFormatter $formatter, int $attribute): int|float|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set a text attribute
 * @link https://php.net/manual/en/numberformatter.settextattribute.php
 * @param NumberFormatter $formatter
 * @param int $attribute 

 * Attribute specifier - one of the
 * text attribute
 * constants.
 * 
 * @param string $value 

 * Text for the attribute value.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function numfmt_set_text_attribute(NumberFormatter $formatter, int $attribute, string $value): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get a text attribute
 * @link https://php.net/manual/en/numberformatter.gettextattribute.php
 * @param NumberFormatter $formatter
 * @param int $attribute 

 * Attribute specifier - one of the
 * text attribute constants.
 * 
 * @return string|false Return attribute value on success, or FALSE on error.
 */
#[Pure]
function numfmt_get_text_attribute(NumberFormatter $formatter, int $attribute): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set a symbol value
 * @link https://php.net/manual/en/numberformatter.setsymbol.php
 * @param NumberFormatter $formatter
 * @param int $symbol 

 * Symbol specifier, one of the
 * format symbol constants.
 * 
 * @param string $value 

 * Text for the symbol.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function numfmt_set_symbol(NumberFormatter $formatter, int $symbol, string $value): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get a symbol value
 * @link https://php.net/manual/en/numberformatter.getsymbol.php
 * @param NumberFormatter $formatter
 * @param int $symbol 

 * Symbol specifier, one of the
 * format symbol constants.
 * 
 * @return string|false The symbol string or FALSE on error.
 */
#[Pure]
function numfmt_get_symbol(NumberFormatter $formatter, int $symbol): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set formatter pattern
 * @link https://php.net/manual/en/numberformatter.setpattern.php
 * @param NumberFormatter $formatter
 * @param string $pattern 

 * Pattern in syntax described in
 * ICU DecimalFormat
 * documentation.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function numfmt_set_pattern(NumberFormatter $formatter, string $pattern): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get formatter pattern
 * @link https://php.net/manual/en/numberformatter.getpattern.php
 * @param NumberFormatter $formatter
 * @return string|false Pattern string that is used by the formatter, or FALSE if an error happens.
 */
#[Pure]
function numfmt_get_pattern(NumberFormatter $formatter): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get formatter locale
 * @link https://php.net/manual/en/numberformatter.getlocale.php
 * @param NumberFormatter $formatter
 * @param int $type 

 * You can choose between valid and actual locale (
 * Locale::VALID_LOCALE,
 * Locale::ACTUAL_LOCALE,
 * respectively). The default is the actual locale.
 * 
 * @return string|false The locale name used to create the formatter.
 */
#[Pure]
function numfmt_get_locale(NumberFormatter $formatter, int $type = 0): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get formatter's last error code.
 * @link https://php.net/manual/en/numberformatter.geterrorcode.php
 * @param NumberFormatter $formatter
 * @return int error code from last formatter call.
 */
#[Pure(true)]
function numfmt_get_error_code(NumberFormatter $formatter): int {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get formatter's last error message.
 * @link https://php.net/manual/en/numberformatter.geterrormessage.php
 * @param NumberFormatter $formatter
 * @return string error message from last formatter call.
 */
#[Pure(true)]
function numfmt_get_error_message(NumberFormatter $formatter): string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Normalizes the input provided and returns the normalized string
 * @link https://php.net/manual/en/normalizer.normalize.php
 * @param string $string 
The input string to normalize
 * @param int $form [optional] 
One of the normalization forms.
 * @return string|false The normalized string or FALSE if an error occurred.
 */
#[Pure]
function normalizer_normalize(string $string, int $form = Normalizer::FORM_C): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Checks if the provided string is already in the specified normalization
 * form.
 * @link https://php.net/manual/en/normalizer.isnormalized.php
 * @param string $string 
The input string to normalize
 * @param int $form [optional] 

 * One of the normalization forms.
 * 
 * @return bool TRUE if normalized, FALSE otherwise or if there an error
 */
#[Pure]
function normalizer_is_normalized(string $string, int $form = Normalizer::FORM_C): bool {}

/**
 * Gets the default locale value from the intl global 'default_locale'
 * @link https://php.net/manual/en/function.locale-get-default.php
 * @return string a string with the current Locale.
 */
#[Pure]
function locale_get_default(): string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set the default runtime Locale
 * @link https://php.net/manual/en/function.locale-set-default.php
 * @param string $locale 

 * The new Locale name. A comprehensive list of the supported locales is
 * available at .
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
#[LanguageAware(['8.4' => 'true'], default: 'bool')]
function locale_set_default(string $locale) {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Gets the primary language for the input locale
 * @link https://php.net/manual/en/locale.getprimarylanguage.php
 * @param string $locale 

 * The locale to extract the primary language code from
 * 
 * @return string|null The language code associated with the language or NULL in case of error.
 */
#[Pure]
function locale_get_primary_language(string $locale): ?string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Gets the script for the input locale
 * @link https://php.net/manual/en/locale.getscript.php
 * @param string $locale 

 * The locale to extract the script code from
 * 
 * @return string|null The script subtag for the locale or NULL if not present
 */
#[Pure]
function locale_get_script(string $locale): ?string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Gets the region for the input locale
 * @link https://php.net/manual/en/locale.getregion.php
 * @param string $locale 

 * The locale to extract the region code from
 * 
 * @return string|null The region subtag for the locale or NULL if not present
 */
#[Pure]
function locale_get_region(string $locale): ?string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Gets the keywords for the input locale
 * @link https://php.net/manual/en/locale.getkeywords.php
 * @param string $locale 

 * The locale to extract the keywords from
 * 
 * @return array|false|null Associative array containing the keyword-value pairs for this locale
 */
#[Pure]
function locale_get_keywords(string $locale): array|false|null {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns an appropriately localized display name for script of the input locale
 * @link https://php.net/manual/en/locale.getdisplayscript.php
 * @param string $locale 

 * The locale to return a display script for
 * 
 * @param string|null $displayLocale 

 * Optional format locale to use to display the script name
 * 
 * @return string|false Display name of the script for the $locale in the format appropriate for
 * $in_locale.
 */
#[Pure]
function locale_get_display_script(
    string $locale,
    #[ElementAvailable(from: '5.3', to: '5.6')] ?string $displayLocale,
    #[ElementAvailable(from: '7.0')] ?string $displayLocale = null
): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns an appropriately localized display name for region of the input locale
 * @link https://php.net/manual/en/locale.getdisplayregion.php
 * @param string $locale 

 * The locale to return a display region for.
 * 
 * @param string|null $displayLocale 

 * Optional format locale to use to display the region name
 * 
 * @return string|false display name of the region for the $locale in the format appropriate for
 * $in_locale.
 */
#[Pure]
function locale_get_display_region(
    string $locale,
    #[ElementAvailable(from: '5.3', to: '5.6')] ?string $displayLocale,
    #[ElementAvailable(from: '7.0')] ?string $displayLocale = null
): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns an appropriately localized display name for the input locale
 * @link https://php.net/manual/en/locale.getdisplayname.php
 * @param string $locale 

 * The locale to return a display name for.
 * 
 * @param string|null $displayLocale 
optional format locale
 * @return string|false Display name of the locale in the format appropriate for $in_locale.
 */
#[Pure]
function locale_get_display_name(
    string $locale,
    #[ElementAvailable(from: '5.3', to: '5.6')] ?string $displayLocale,
    #[ElementAvailable(from: '7.0')] ?string $displayLocale = null
): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns an appropriately localized display name for language of the inputlocale
 * @link https://php.net/manual/en/locale.getdisplaylanguage.php
 * @param string $locale 

 * The locale to return a display language for
 * 
 * @param string|null $displayLocale 

 * Optional format locale to use to display the language name
 * 
 * @return string|false display name of the language for the $locale in the format appropriate for
 * $in_locale.
 */
#[Pure]
function locale_get_display_language(
    string $locale,
    #[ElementAvailable(from: '5.3', to: '5.6')] ?string $displayLocale,
    #[ElementAvailable(from: '7.0')] ?string $displayLocale = null
): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns an appropriately localized display name for variants of the input locale
 * @link https://php.net/manual/en/locale.getdisplayvariant.php
 * @param string $locale 

 * The locale to return a display variant for
 * 
 * @param string|null $displayLocale 

 * Optional format locale to use to display the variant name
 * 
 * @return string|false Display name of the variant for the $locale in the format appropriate for
 * $in_locale.
 */
#[Pure]
function locale_get_display_variant(
    string $locale,
    #[ElementAvailable(from: '5.3', to: '5.6')] ?string $displayLocale,
    #[ElementAvailable(from: '7.0')] ?string $displayLocale = null
): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns a correctly ordered and delimited locale ID
 * @link https://php.net/manual/en/locale.composelocale.php
 * @param string[] $subtags 

 * an array containing a list of key-value pairs, where the keys identify
 * the particular locale ID subtags, and the values are the associated
 * subtag values.
 * 

 * The 'variant' and 'private' subtags can take maximum 15 values
 * whereas 'extlang' can take maximum 3 values.e.g. Variants are allowed
 * with the suffix ranging from 0-14. Hence the keys for the input array
 * can be variant0, variant1, ...,variant14. In the returned locale id,
 * the subtag is ordered by suffix resulting in variant0 followed by
 * variant1 followed by variant2 and so on.
 * 
 * 

 * The 'variant', 'private' and 'extlang' multiple values can be specified both
 * as array under specific key (e.g. 'variant') and as multiple numbered keys
 * (e.g. 'variant0', 'variant1', etc.).
 * 
 * 

 * @return string|false The corresponding locale identifier.
 */
#[Pure]
function locale_compose(array $subtags): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns a key-value array of locale ID subtag elements.
 * @link https://php.net/manual/en/locale.parselocale.php
 * @param string $locale 

 * The locale to extract the subtag array from. Note: The 'variant' and
 * 'private' subtags can take maximum 15 values whereas 'extlang' can take
 * maximum 3 values.
 * 
 * @return string[]|null an array containing a list of key-value pairs, where the keys
 * identify the particular locale ID subtags, and the values are the
 * associated subtag values. The array will be ordered as the locale id
 * subtags e.g. in the locale id if variants are '-varX-varY-varZ' then the
 * returned array will have variant0=>varX , variant1=>varY ,
 * variant2=>varZ
 */
#[Pure]
function locale_parse(string $locale): ?array {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Gets the variants for the input locale
 * @link https://php.net/manual/en/locale.getallvariants.php
 * @param string $locale 

 * The locale to extract the variants from
 * 
 * @return array|null The array containing the list of all variants subtag for the locale
 * or NULL if not present
 */
#[Pure]
function locale_get_all_variants(string $locale): ?array {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Checks if a language tag filter matches with locale
 * @link https://php.net/manual/en/locale.filtermatches.php
 * @param string $languageTag 

 * The language tag to check
 * 
 * @param string $locale 

 * The language range to check against
 * 
 * @param bool $canonicalize 

 * If true, the arguments will be converted to canonical form before
 * matching.
 * 
 * @return bool|null TRUE if $locale matches $langtag FALSE otherwise.
 */
#[Pure]
function locale_filter_matches(
    string $languageTag,
    string $locale,
    #[ElementAvailable(from: '5.3', to: '5.6')] bool $canonicalize,
    #[ElementAvailable(from: '7.0')] bool $canonicalize = false
): ?bool {}

/**
 * Canonicalize the locale string
 * @param string $locale
 *
 * @return null|string
 */
#[Pure]
function locale_canonicalize(string $locale): ?string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Searches the language tag list for the best match to the language
 * @link https://php.net/manual/en/locale.lookup.php
 * @param string[] $languageTag 

 * An array containing a list of language tags to compare to
 * locale. Maximum 100 items allowed.
 * 
 * @param string $locale 

 * The locale to use as the language range when matching.
 * 
 * @param bool $canonicalize 

 * If true, the arguments will be converted to canonical form before
 * matching.
 * 
 * @param string|null $defaultLocale 

 * The locale to use if no match is found.
 * 
 * @return string|null The closest matching language tag or default value.
 */
#[Pure]
function locale_lookup(
    array $languageTag,
    string $locale,
    #[ElementAvailable(from: '5.3', to: '5.6')] bool $canonicalize,
    #[ElementAvailable(from: '5.3', to: '5.6')] ?string $defaultLocale,
    #[ElementAvailable(from: '7.0')] bool $canonicalize = false,
    #[ElementAvailable(from: '7.0')] ?string $defaultLocale = null,
): ?string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Tries to find out best available locale based on HTTP "Accept-Language" header
 * @link https://php.net/manual/en/locale.acceptfromhttp.php
 * @param string $header 

 * The string containing the "Accept-Language" header according to format in RFC 2616.
 * 
 * @return string|false The corresponding locale identifier.
 */
#[Pure]
function locale_accept_from_http(string $header): string|false {}

/**
 * Constructs a new message formatter
 * @param string $locale
 * @param string $pattern
 * @return MessageFormatter|null
 */
#[Pure]
function msgfmt_create(string $locale, string $pattern): ?MessageFormatter {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Format the message
 * @link https://php.net/manual/en/messageformatter.format.php
 * @param MessageFormatter $formatter
 * @param array $values 

 * Arguments to insert into the format string
 * 
 * @return string|false The formatted string, or FALSE if an error occurred
 */
#[Pure]
function msgfmt_format(MessageFormatter $formatter, array $values): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Quick format message
 * @link https://php.net/manual/en/messageformatter.formatmessage.php
 * @param string $locale 

 * The locale to use for formatting locale-dependent parts
 * 
 * @param string $pattern 

 * The pattern string to insert things into.
 * The pattern uses an 'apostrophe-friendly' syntax; it is run through
 * umsg_autoQuoteApostrophe
 * before being interpreted.
 * 
 * @param array $values 

 * The array of values to insert into the format string
 * 
 * @return string|false The formatted pattern string or FALSE if an error occurred
 */
#[Pure]
function msgfmt_format_message(string $locale, string $pattern, array $values): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Parse input string according to pattern
 * @link https://php.net/manual/en/messageformatter.parse.php
 * @param MessageFormatter $formatter
 * @param string $string 

 * The string to parse
 * 
 * @return array|false An array containing the items extracted, or FALSE on error
 */
#[Pure]
function msgfmt_parse(MessageFormatter $formatter, string $string): array|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Quick parse input string
 * @link https://php.net/manual/en/messageformatter.parsemessage.php
 * @param string $locale 

 * The locale to use for parsing locale-dependent parts
 * 
 * @param string $pattern 

 * The pattern with which to parse the value.
 * 
 * @param string $message 

 * The string to parse, conforming to the pattern.
 * 
 * @return array|false An array containing items extracted, or FALSE on error
 */
#[Pure]
function msgfmt_parse_message(string $locale, string $pattern, string $message): array|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set the pattern used by the formatter
 * @link https://php.net/manual/en/messageformatter.setpattern.php
 * @param MessageFormatter $formatter
 * @param string $pattern 

 * The pattern string to use in this message formatter.
 * The pattern uses an 'apostrophe-friendly' syntax; it is run through
 * umsg_autoQuoteApostrophe
 * before being interpreted.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function msgfmt_set_pattern(MessageFormatter $formatter, string $pattern): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the pattern used by the formatter
 * @link https://php.net/manual/en/messageformatter.getpattern.php
 * @param MessageFormatter $formatter
 * @return string|false The pattern string for this message formatter
 */
#[Pure]
function msgfmt_get_pattern(MessageFormatter $formatter): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the locale for which the formatter was created.
 * @link https://php.net/manual/en/messageformatter.getlocale.php
 * @param MessageFormatter $formatter
 * @return string The locale name
 */
#[Pure]
function msgfmt_get_locale(MessageFormatter $formatter): string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the error code from last operation
 * @link https://php.net/manual/en/messageformatter.geterrorcode.php
 * @param MessageFormatter $formatter
 * @return int The error code, one of UErrorCode values. Initial value is U_ZERO_ERROR.
 */
#[Pure(true)]
function msgfmt_get_error_code(MessageFormatter $formatter): int {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the error text from the last operation
 * @link https://php.net/manual/en/messageformatter.geterrormessage.php
 * @param MessageFormatter $formatter
 * @return string Description of the last error.
 */
#[Pure(true)]
function msgfmt_get_error_message(MessageFormatter $formatter): string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Create a date formatter
 * @link https://php.net/manual/en/intldateformatter.create.php
 * @param string|null $locale 

 * Locale to use when formatting or parsing.
 * 
 * @param int $dateType 

 * Date type to use (none,
 * short, medium,
 * long, full).
 * This is one of the
 * IntlDateFormatter constants.
 * 
 * @param int $timeType 

 * Time type to use (none,
 * short, medium,
 * long, full).
 * This is one of the
 * IntlDateFormatter constants.
 * 
 * @param string|null $timezone [optional] 

 * Time zone ID, default is system default.
 * 
 * @param IntlCalendar|int|null $calendar [optional] 

 * Calendar to use for formatting or parsing; default is Gregorian.
 * This is one of the
 * IntlDateFormatter calendar constants.
 * 
 * @param string|null $pattern [optional] 

 * Optional pattern to use when formatting or parsing.
 * Possible patterns are documented at http://userguide.icu-project.org/formatparse/datetime.
 * 
 * @return IntlDateFormatter|null
 */
#[Pure]
function datefmt_create(
    ?string $locale,
    #[ElementAvailable(from: '5.3', to: '8.0')] int $dateType,
    #[ElementAvailable(from: '8.1')] int $dateType = 0,
    #[ElementAvailable(from: '5.3', to: '8.0')] int $timeType,
    #[ElementAvailable(from: '8.1')] int $timeType = 0,
    $timezone = null,
    IntlCalendar|int|null $calendar = null,
    #[LanguageAware(['8.0' => 'string|null'], default: 'string')] $pattern = null
): ?IntlDateFormatter {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the datetype used for the IntlDateFormatter
 * @link https://php.net/manual/en/intldateformatter.getdatetype.php
 * @param IntlDateFormatter $formatter
 * @return int|false The current date type value of the formatter.
 */
#[Pure]
function datefmt_get_datetype(IntlDateFormatter $formatter): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the timetype used for the IntlDateFormatter
 * @link https://php.net/manual/en/intldateformatter.gettimetype.php
 * @param IntlDateFormatter $formatter
 * @return int|false The current date type value of the formatter.
 */
#[Pure]
function datefmt_get_timetype(IntlDateFormatter $formatter): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the calendar type used for the IntlDateFormatter
 * @link https://php.net/manual/en/intldateformatter.getcalendar.php
 * @param IntlDateFormatter $formatter
 * @return int|false The calendar being used by the formatter.
 */
#[Pure]
function datefmt_get_calendar(IntlDateFormatter $formatter): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * sets the calendar used to the appropriate calendar, which must be
 * @link https://php.net/manual/en/intldateformatter.setcalendar.php
 * @param IntlDateFormatter $formatter $mf
 * @param IntlCalendar|int|null $calendar 

 * The calendar to use.
 * Default is IntlDateFormatter::GREGORIAN.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function datefmt_set_calendar(IntlDateFormatter $formatter, IntlCalendar|int|null $calendar): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the locale used by formatter
 * @link https://php.net/manual/en/intldateformatter.getlocale.php
 * @param IntlDateFormatter $formatter
 * @param int $type [optional]
 * @return string|false the locale of this formatter or 'false' if error
 */
#[Pure]
function datefmt_get_locale(
    IntlDateFormatter $formatter,
    #[ElementAvailable(from: '8.0')] int $type = ULOC_ACTUAL_LOCALE
): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the timezone-id used for the IntlDateFormatter
 * @link https://php.net/manual/en/intldateformatter.gettimezoneid.php
 * @param IntlDateFormatter $formatter
 * @return string|false ID string for the time zone used by this formatter.
 */
#[Pure]
function datefmt_get_timezone_id(IntlDateFormatter $formatter): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 3.0.0)

 * Get copy of formatter's calendar object
 * @link https://secure.php.net/manual/en/intldateformatter.getcalendarobject.php
 * @param IntlDateFormatter $formatter
 * @return IntlCalendar|false|null A copy of the internal calendar object used by this formatter.
 */
#[Pure]
function datefmt_get_calendar_object(IntlDateFormatter $formatter): IntlCalendar|false|null {}

/**
 * (PHP 5 >= 5.5.0, PECL intl >= 3.0.0)

 *  Get formatter's timezone
 * @link https://secure.php.net/manual/en/intldateformatter.gettimezone.php
 * @param IntlDateFormatter $formatter
 * @return IntlTimeZone|false The associated IntlTimeZone object or FALSE on failure.
 */
#[Pure]
function datefmt_get_timezone(IntlDateFormatter $formatter): IntlTimeZone|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Sets the time zone to use
 * @link https://php.net/manual/en/intldateformatter.settimezoneid.php
 * @param MessageFormatter $mf
 * @param string $zone 

 * The time zone ID string of the time zone to use.
 * If NULL or the empty string, the default time zone for the runtime is used.
 * 
 * @return bool TRUE on success or FALSE on failure.
 * @removed 7.0
 * @see datefmt_set_timezone()
 */
#[Deprecated(replacement: "datefmt_set_timezone(%parametersList%)", since: "5.5")]
function datefmt_set_timezone_id(MessageFormatter $mf, $zone) {}

/**
 * (PHP 5 >= 5.5.0, PECL intl >= 3.0.0)

 * Sets formatter's timezone
 * @link https://php.net/manual/en/intldateformatter.settimezone.php
 * @param IntlDateFormatter $formatter
 * @param IntlTimeZone|DateTimeZone|string|null $timezone 

 * The timezone to use for this formatter. This can be specified in the
 * following forms:
 * 

 * 

 * 

 * NULL, in which case the default timezone will be used, as specified in
 * the ini setting {@link "https://secure.php.net/manual/en/datetime.configuration.php#ini.date.timezone" date.timezone} or
 * through the function  {@link "https://secure.php.net/manual/en/function.date-default-timezone-set.php" date_default_timezone_set()} and as
 * returned by {@link "https://secure.php.net/manual/en/function.date-default-timezone-get.php" date_default_timezone_get()}.
 * 
 * 
 * 

 * 

 * An {@link "https://secure.php.net/manual/en/class.intltimezone.php" IntlTimeZone}, which will be used directly.
 * 
 * 
 * 

 * 

 * A {@link "https://secure.php.net/manual/en/class.datetimezone.php" DateTimeZone}. Its identifier will be extracted
 * and an ICU timezone object will be created; the timezone will be backed
 * by ICU's database, not PHP's.
 * 
 * 
 * 

 * 

 * A {@link "https://secure.php.net/manual/en/language.types.string.php" string}, which should be a valid ICU timezone identifier.
 * See IntlTimeZone::createTimeZoneIDEnumeration(). Raw offsets such as "GMT+08:30" are also accepted.
 * 
 * 
 * 
 * 

 * @return bool|null TRUE on success or FALSE on failure.
 */
#[LanguageAware(['8.3' => 'bool'], default: 'bool|null')]
function datefmt_set_timezone(IntlDateFormatter $formatter, $timezone) {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the pattern used for the IntlDateFormatter
 * @link https://php.net/manual/en/intldateformatter.getpattern.php
 * @param IntlDateFormatter $formatter
 * @return string|false The pattern string being used to format/parse.
 */
#[Pure]
function datefmt_get_pattern(IntlDateFormatter $formatter): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set the pattern used for the IntlDateFormatter
 * @link https://php.net/manual/en/intldateformatter.setpattern.php
 * @param IntlDateFormatter $formatter
 * @param string $pattern 

 * New pattern string to use.
 * Possible patterns are documented at http://userguide.icu-project.org/formatparse/datetime.
 * 
 * @return bool TRUE on success or FALSE on failure.
 * Bad formatstrings are usually the cause of the failure.
 */
function datefmt_set_pattern(IntlDateFormatter $formatter, string $pattern): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the lenient used for the IntlDateFormatter
 * @link https://php.net/manual/en/intldateformatter.islenient.php
 * @param IntlDateFormatter $formatter
 * @return bool TRUE if parser is lenient, FALSE if parser is strict. By default the parser is lenient.
 */
#[Pure]
function datefmt_is_lenient(IntlDateFormatter $formatter): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Set the leniency of the parser
 * @link https://php.net/manual/en/intldateformatter.setlenient.php
 * @param IntlDateFormatter $formatter
 * @param bool $lenient 

 * Sets whether the parser is lenient or not, default is TRUE (lenient).
 * 
 * @return void
 */
function datefmt_set_lenient(
    IntlDateFormatter $formatter,
    #[ElementAvailable(from: '8.0')] bool $lenient
): void {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Format the date/time value as a string
 * @link https://php.net/manual/en/intldateformatter.format.php
 * @param IntlDateFormatter $formatter
 * @param object|array|string|int|float $datetime 

 * Value to format. This may be a DateTime object,
 * an integer representing a Unix timestamp value (seconds
 * since epoch, UTC) or an array in the format output by
 * localtime.
 * 
 * @return string|false The formatted string or, if an error occurred, FALSE.
 */
#[Pure]
function datefmt_format(
    #[LanguageAware(['8.0' => 'IntlDateFormatter'], default: '')] #[ElementAvailable(from: '5.3', to: '7.4')] $formatter = null,
    #[LanguageAware(['8.0' => 'IntlDateFormatter'], default: '')] #[ElementAvailable(from: '8.0')] $formatter,
    #[ElementAvailable(from: '5.3', to: '7.4')] $datetime = null,
    #[ElementAvailable(from: '8.0')] $datetime
): string|false {}

/**
 * (PHP 5 >= 5.5.0, PECL intl >= 3.0.0)

 * Formats an object
 * @link https://secure.php.net/manual/en/intldateformatter.formatobject.php
 * @param IntlCalendar|DateTimeInterface $datetime 

 * An object of type IntlCalendar or DateTime. The timezone information in the object will be used.
 * 
 * @param array|int|string|null $format [optional] 

 * How to format the date/time. This can either be an {https://secure.php.net/manual/en/language.types.array.php array}  with
 * two elements (first the date style, then the time style, these being one
 * of the constants IntlDateFormatter::NONE,
 * IntlDateFormatter::SHORT,
 * IntlDateFormatter::MEDIUM,
 * IntlDateFormatter::LONG,
 * IntlDateFormatter::FULL), a long with
 * the value of one of these constants (in which case it will be used both
 * for the time and the date) or a {@link https://secure.php.net/manual/en/language.types.string.php} with the format
 * described in {@link http://www.icu-project.org/apiref/icu4c/classSimpleDateFormat.html#details the ICU documentation}
 * documentation. If NULL, the default style will be used.
 * 
 * @param string|null $locale [optional] 

 * The locale to use, or NULL to use the default one.
 * @return string|false The formatted string or, if an error occurred, FALSE.
 */
#[Pure]
function datefmt_format_object($datetime, $format = null, ?string $locale = null): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Parse string to a timestamp value
 * @link https://php.net/manual/en/intldateformatter.parse.php
 * @param IntlDateFormatter $formatter
 * @param string $string 

 * string to convert to a time
 * 
 * @param int &$offset [optional] 

 * Position at which to start the parsing in $value (zero-based).
 * If no error occurs before $value is consumed, $parse_pos will contain -1
 * otherwise it will contain the position at which parsing ended (and the error occurred).
 * This variable will contain the end position if the parse fails.
 * If $parse_pos > strlen($value), the parse fails immediately.
 * 
 * @return int|float|false timestamp parsed value
 */
function datefmt_parse(IntlDateFormatter $formatter, string $string, &$offset = null): int|float|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Parse string to a field-based time value
 * @link https://php.net/manual/en/intldateformatter.localtime.php
 * @param IntlDateFormatter $formatter
 * @param string $string 

 * string to convert to a time
 * 
 * @param int &$offset [optional] 

 * Position at which to start the parsing in $value (zero-based).
 * If no error occurs before $value is consumed, $parse_pos will contain -1
 * otherwise it will contain the position at which parsing ended .
 * If $parse_pos > strlen($value), the parse fails immediately.
 * 
 * @return array|false Localtime compatible array of integers : contains 24 hour clock value in tm_hour field
 */
function datefmt_localtime(IntlDateFormatter $formatter, string $string, &$offset = null): array|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the error code from last operation
 * @link https://php.net/manual/en/intldateformatter.geterrorcode.php
 * @param IntlDateFormatter $formatter
 * @return int The error code, one of UErrorCode values. Initial value is U_ZERO_ERROR.
 */
#[Pure(true)]
function datefmt_get_error_code(IntlDateFormatter $formatter): int {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the error text from the last operation.
 * @link https://php.net/manual/en/intldateformatter.geterrormessage.php
 * @param IntlDateFormatter $formatter
 * @return string Description of the last error.
 */
#[Pure(true)]
function datefmt_get_error_message(IntlDateFormatter $formatter): string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get string length in grapheme units
 * @link https://php.net/manual/en/function.grapheme-strlen.php
 * @param string $string 

 * The string being measured for length. It must be a valid UTF-8 string.
 * 
 * @return int|false|null The length of the string on success, and 0 if the string is empty.
 */
#[Pure]
function grapheme_strlen(string $string): int|false|null {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Find position (in grapheme units) of first occurrence of a string
 * @link https://php.net/manual/en/function.grapheme-strpos.php
 * @param string $haystack 

 * The string to look in. Must be valid UTF-8.
 * 
 * @param string $needle 

 * The string to look for. Must be valid UTF-8.
 * 
 * @param int $offset [optional] 

 * The optional $offset parameter allows you to specify where in $haystack to
 * start searching as an offset in grapheme units (not bytes or characters).
 * The position returned is still relative to the beginning of haystack
 * regardless of the value of $offset.
 * 
 * @return int|false the position as an integer. If needle is not found, strpos() will return boolean FALSE.
 */
#[Pure]
function grapheme_strpos(string $haystack, string $needle, int $offset = 0): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Find position (in grapheme units) of first occurrence of a case-insensitive string
 * @link https://php.net/manual/en/function.grapheme-stripos.php
 * @param string $haystack 

 * The string to look in. Must be valid UTF-8.
 * 
 * @param string $needle 

 * The string to look for. Must be valid UTF-8.
 * 
 * @param int $offset [optional] 

 * The optional $offset parameter allows you to specify where in haystack to
 * start searching as an offset in grapheme units (not bytes or characters).
 * The position returned is still relative to the beginning of haystack
 * regardless of the value of $offset.
 * 
 * @return int|false the position as an integer. If needle is not found, grapheme_stripos() will return boolean FALSE.
 */
#[Pure]
function grapheme_stripos(string $haystack, string $needle, int $offset = 0): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Find position (in grapheme units) of last occurrence of a string
 * @link https://php.net/manual/en/function.grapheme-strrpos.php
 * @param string $haystack 

 * The string to look in. Must be valid UTF-8.
 * 
 * @param string $needle 

 * The string to look for. Must be valid UTF-8.
 * 
 * @param int $offset [optional] 

 * The optional $offset parameter allows you to specify where in $haystack to
 * start searching as an offset in grapheme units (not bytes or characters).
 * The position returned is still relative to the beginning of haystack
 * regardless of the value of $offset.
 * 
 * @return int|false the position as an integer. If needle is not found, grapheme_strrpos() will return boolean FALSE.
 */
#[Pure]
function grapheme_strrpos(string $haystack, string $needle, int $offset = 0): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Find position (in grapheme units) of last occurrence of a case-insensitive string
 * @link https://php.net/manual/en/function.grapheme-strripos.php
 * @param string $haystack 

 * The string to look in. Must be valid UTF-8.
 * 
 * @param string $needle 

 * The string to look for. Must be valid UTF-8.
 * 
 * @param int $offset [optional] 

 * The optional $offset parameter allows you to specify where in $haystack to
 * start searching as an offset in grapheme units (not bytes or characters).
 * The position returned is still relative to the beginning of haystack
 * regardless of the value of $offset.
 * 
 * @return int|false the position as an integer. If needle is not found, grapheme_strripos() will return boolean FALSE.
 */
#[Pure]
function grapheme_strripos(string $haystack, string $needle, int $offset = 0): int|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Return part of a string
 * @link https://php.net/manual/en/function.grapheme-substr.php
 * @param string $string 

 * The input string. Must be valid UTF-8.
 * 
 * @param int $offset 

 * Start position in default grapheme units.
 * If $start is non-negative, the returned string will start at the
 * $start'th position in $string, counting from zero. If $start is negative,
 * the returned string will start at the $start'th grapheme unit from the
 * end of string.
 * 
 * @param int|null $length [optional] 

 * Length in grapheme units.
 * If $length is given and is positive, the string returned will contain
 * at most $length grapheme units beginning from $start (depending on the
 * length of string). If $length is given and is negative, then
 * that many grapheme units will be omitted from the end of string (after the
 * start position has been calculated when a start is negative). If $start
 * denotes a position beyond this truncation, FALSE will be returned.
 * 
 * @return string|false 
the extracted part of $string,

 * or FALSE if $length is negative and $start denotes a position beyond truncation $length,

 * or also FALSE if $start denotes a position beyond $string length
 */
#[Pure]
function grapheme_substr(string $string, int $offset, ?int $length = null): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns part of haystack string from the first occurrence of needle to the end of haystack.
 * @link https://php.net/manual/en/function.grapheme-strstr.php
 * @param string $haystack 

 * The input string. Must be valid UTF-8.
 * 
 * @param string $needle 

 * The string to look for. Must be valid UTF-8.
 * 
 * @param bool $beforeNeedle [optional] 

 * If TRUE, grapheme_strstr() returns the part of the
 * haystack before the first occurrence of the needle (excluding the needle).
 * 
 * @return string|false the portion of string, or FALSE if needle is not found.
 */
#[Pure]
function grapheme_strstr(string $haystack, string $needle, bool $beforeNeedle = false): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Returns part of haystack string from the first occurrence of case-insensitive needle to the end of haystack.
 * @link https://php.net/manual/en/function.grapheme-stristr.php
 * @param string $haystack 

 * The input string. Must be valid UTF-8.
 * 
 * @param string $needle 

 * The string to look for. Must be valid UTF-8.
 * 
 * @param bool $beforeNeedle [optional] 

 * If TRUE, grapheme_strstr() returns the part of the
 * haystack before the first occurrence of the needle (excluding needle).
 * 
 * @return string|false the portion of $haystack, or FALSE if $needle is not found.
 */
#[Pure]
function grapheme_stristr(string $haystack, string $needle, bool $beforeNeedle = false): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Function to extract a sequence of default grapheme clusters from a text buffer, which must be encoded in UTF-8.
 * @link https://php.net/manual/en/function.grapheme-extract.php
 * @param string $haystack 

 * String to search.
 * 
 * @param int $size 

 * Maximum number items - based on the $extract_type - to return.
 * 
 * @param int $type 

 * Defines the type of units referred to by the $size parameter:
 * 
 * 

 * GRAPHEME_EXTR_COUNT (default) - $size is the number of default
 * grapheme clusters to extract.
 * GRAPHEME_EXTR_MAXBYTES - $size is the maximum number of bytes
 * returned.
 * GRAPHEME_EXTR_MAXCHARS - $size is the maximum number of UTF-8
 * characters returned.
 * 
 * @param int $offset [optional] 

 * Starting position in $haystack in bytes - if given, it must be zero or a
 * positive value that is less than or equal to the length of $haystack in
 * bytes. If $start does not point to the first byte of a UTF-8
 * character, the start position is moved to the next character boundary.
 * 
 * @param int &$next [optional] 

 * Reference to a value that will be set to the next starting position.
 * When the call returns, this may point to the first byte position past the end of the string.
 * 
 * @return string|false A string starting at offset $start and ending on a default grapheme cluster
 * boundary that conforms to the $size and $extract_type specified.
 */
function grapheme_extract(string $haystack, int $size, int $type = 0, int $offset = 0, &$next = null): string|false {}

/**
 * (PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.2, PHP 7, PECL idn >= 0.1)

 * Convert domain name to IDNA ASCII form.
 * @link https://php.net/manual/en/function.idn-to-ascii.php
 * @param string $domain 

 * Domain to convert. In PHP 5 must be UTF-8 encoded.
 * If e.g. an ISO-8859-1 (aka Western Europe latin1) encoded string is
 * passed it will be converted into an ACE encoded "xn--" string.
 * It will not be the one you expected though!
 * 
 * @param int $flags [optional] 

 * Conversion options - combination of IDNA_* constants (except IDNA_ERROR_* constants).
 * 
 * @param int $variant [optional] 

 * Either INTL_IDNA_VARIANT_2003 for IDNA 2003 or INTL_IDNA_VARIANT_UTS46 for UTS #46.
 * 
 * @param array &$idna_info [optional] 

 * This parameter can be used only if INTL_IDNA_VARIANT_UTS46 was used for variant.
 * In that case, it will be filled with an array with the keys 'result',
 * the possibly illegal result of the transformation, 'isTransitionalDifferent',
 * a boolean indicating whether the usage of the transitional mechanisms of UTS #46
 * either has or would have changed the result and 'errors',
 * which is an int representing a bitset of the error constants IDNA_ERROR_*.
 * 
 * @return string|false The ACE encoded version of the domain name or FALSE on failure.
 */
function idn_to_ascii(string $domain, int $flags = 0, int $variant = INTL_IDNA_VARIANT_UTS46, &$idna_info): string|false {}

/**
 * (PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.2, PHP 7, PECL idn >= 0.1)

 * Convert domain name from IDNA ASCII to Unicode.
 * @link https://php.net/manual/en/function.idn-to-utf8.php
 * @param string $domain 

 * Domain to convert in IDNA ASCII-compatible format.
 * The ASCII encoded domain name. Looks like "xn--..." if the it originally contained non-ASCII characters.
 * 
 * @param int $flags [optional] 

 * Conversion options - combination of IDNA_* constants (except IDNA_ERROR_* constants).
 * 
 * @param int $variant [optional] 

 * Either INTL_IDNA_VARIANT_2003 for IDNA 2003 or INTL_IDNA_VARIANT_UTS46 for UTS #46.
 * 
 * @param array &$idna_info [optional] 

 * This parameter can be used only if INTL_IDNA_VARIANT_UTS46 was used for variant.
 * In that case, it will be filled with an array with the keys 'result',
 * the possibly illegal result of the transformation, 'isTransitionalDifferent',
 * a boolean indicating whether the usage of the transitional mechanisms of UTS #46
 * either has or would have changed the result and 'errors',
 * which is an int representing a bitset of the error constants IDNA_ERROR_*.
 * 
 * @return string|false The UTF-8 encoded version of the domain name or FALSE on failure.
 * RFC 3490 4.2 states though "ToUnicode never fails. If any step fails, then the original input
 * sequence is returned immediately in that step."
 */
function idn_to_utf8(string $domain, int $flags = 0, int $variant = INTL_IDNA_VARIANT_UTS46, &$idna_info): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Create a new IntlCalendar
 * @link https://secure.php.net/manual/en/intlcalendar.createinstance.php
 * @param IntlTimeZone|DateTimeZone|string|null $timezone [optional] 
 

 * The timezone to use.
 * 
 *
 * 

 * 

 * 

 * NULL, in which case the default timezone will be used, as specified in
 * the ini setting {@link https://secure.php.net/manual/en/datetime.configuration.php#ini.date.timezone date.timezone} or
 * through the function  {@link https://secure.php.net/manual/en/function.date-default-timezone-set.php date_default_timezone_set()} and as
 * returned by {@link https://secure.php.net/manual/en/function.date-default-timezone-get.php date_default_timezone_get()}.
 * 
 * 
 * 

 * 

 * An {@link https://secure.php.net/manual/en/class.intltimezone.php IntlTimeZone}, which will be used directly.
 * 
 * 
 * 

 * 

 * A {@link https://secure.php.net/manual/en/class.datetimezone.php DateTimeZone}. Its identifier will be extracted
 * and an ICU timezone object will be created; the timezone will be backed
 * by ICU's database, not PHP's.
 * 
 * 
 * 

 * 

 * A {@link https://secure.php.net/manual/en/language.types.string.php string}, which should be a valid ICU timezone identifier.
 * See  IntlTimeZone::createTimeZoneIDEnumeration(). Raw
 * offsets such as "GMT+08:30" are also accepted.
 * 
 * 
 * 
 * 

 * @param string|null $locale [optional] 

 * A locale to use or NULL to use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.default-locale the default locale}.
 * 
 * @return IntlCalendar|null
 * The created {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} instance or NULL on
 * failure.
 * @since 5.5
 */
#[Pure]
function intlcal_create_instance($timezone = null, ?string $locale = null): ?IntlCalendar {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get set of locale keyword values
 * @param string $keyword 

 * The locale keyword for which relevant values are to be queried. Only
 * 'calendar' is supported.
 * 
 * @param string $locale 

 * The locale onto which the keyword/value pair are to be appended.
 * 
 * @param bool $onlyCommon
 * 

 * Whether to show only the values commonly used for the specified locale.
 * 
 * @return IntlIterator|false An iterator that yields strings with the locale keyword values or FALSE on failure.
 * @since 5.5
 */
#[Pure]
function intlcal_get_keyword_values_for_locale(string $keyword, string $locale, bool $onlyCommon): IntlIterator|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get number representing the current time
 * @link https://secure.php.net/manual/en/intlcalendar.getnow.php
 * @return float A float representing a number of milliseconds since the epoch, not counting leap seconds.
 * @since 5.5
 */
#[Pure(true)]
function intlcal_get_now(): float {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get array of locales for which there is data
 * @link https://secure.php.net/manual/en/intlcalendar.getavailablelocales.php
 * @return string[] An array of strings, one for which locale.
 * @since 5.5
 */
#[Pure]
function intlcal_get_available_locales(): array {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the value for a field
 * @link https://secure.php.net/manual/en/intlcalendar.get.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int An integer with the value of the time field.
 * @since 5.5
 */
#[Pure]
function intl_get($calendar, $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get time currently represented by the object
 * @param IntlCalendar $calendar 
The calendar whose time will be checked against this object's time.
 * @return float
 * A {@link https://secure.php.net/manual/en/language.types.float.php float} representing the number of milliseconds elapsed since the
 * reference time (1 Jan 1970 00:00:00 UTC).
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'float|false'], default: 'float')]
function intlcal_get_time(IntlCalendar $calendar) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Set the calendar time in milliseconds since the epoch
 * @link https://secure.php.net/manual/en/intlcalendar.settime.php
 * @param IntlCalendar $calendar 

 * The IntlCalendar resource.
 * 
 * @param float $timestamp 

 * An instant represented by the number of number of milliseconds between
 * such instant and the epoch, ignoring leap seconds.
 * 
 * @return bool
 * Returns TRUE on success and FALSE on failure.
 * @since 5.5
 */
function intlcal_set_time(IntlCalendar $calendar, float $timestamp): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Add a (signed) amount of time to a field
 * @link https://secure.php.net/manual/en/intlcalendar.add.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}.
 * These are integer values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @param int $value 
The signed amount to add to the current field. If the amount is positive, the instant will be moved forward; if it is negative, the instant wil be moved into the past. The unit is implicit to the field type.
 * For instance, hours for IntlCalendar::FIELD_HOUR_OF_DAY.
 * @return bool Returns TRUE on success or FALSE on failure.
 * @since 5.5
 */
function intlcal_add(IntlCalendar $calendar, int $field, int $value): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Set the timezone used by this calendar
 * @link https://secure.php.net/manual/en/intlcalendar.settimezone.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param IntlTimeZone|DateTimeZone|string|null $timezone 

 * The new timezone to be used by this calendar. It can be specified in the
 * following ways:
 *
 * 

 * 

 * 

 * NULL, in which case the default timezone will be used, as specified in
 * the ini setting {@link https://secure.php.net/manual/en/datetime.configuration.php#ini.date.timezone date.timezone} or
 * through the function  {@link https://secure.php.net/manual/en/function.date-default-timezone-set.php date_default_timezone_set()} and as
 * returned by  {@link https://secure.php.net/manual/en/function.date-default-timezone-get.php date_default_timezone_get()}.
 * 
 * 
 * 

 * 

 * An {@link https://secure.php.net/manual/en/class.intltimezone.php IntlTimeZone}, which will be used directly.
 * 
 * 
 * 

 * 

 * A {@link https://secure.php.net/manual/en/class.datetimezone.php DateTimeZone}. Its identifier will be extracted
 * and an ICU timezone object will be created; the timezone will be backed
 * by ICU's database, not PHP's.
 * 
 * 
 * 

 * 

 * A {@link https://secure.php.net/manual/en/language.types.string.php string}, which should be a valid ICU timezone identifier.
 * See  IntlTimeZone::createTimeZoneIDEnumeration(). Raw
 * offsets such as "GMT+08:30" are also accepted.
 * 
 * 
 * 
 * @return bool Returns TRUE on success and FALSE on failure.
 * @since 5.5
 */
function intlcal_set_time_zone(IntlCalendar $calendar, $timezone): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Whether this object's time is after that of the passed object
 * https://secure.php.net/manual/en/intlcalendar.after.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param IntlCalendar $other 
The calendar whose time will be checked against this object's time.
 * @return bool
 * Returns TRUE if this object's current time is after that of the
 * calendar argument's time. Returns FALSE otherwise.
 * Also returns FALSE on failure. You can use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or
 * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to detect error conditions.
 * @since 5.5
 */
#[Pure]
function intlcal_after(IntlCalendar $calendar, IntlCalendar $other): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Whether this object's time is before that of the passed object
 * @link https://secure.php.net/manual/en/intlcalendar.before.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param IntlCalendar $other 
 The calendar whose time will be checked against this object's time.
 * @return bool
 * 

 * Returns TRUE if this object's current time is before that of the
 * calendar argument's time. Returns FALSE otherwise.
 * Also returns FALSE on failure. You can use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or
 * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to detect error conditions.
 * 
 * @since 5.5
 */
#[Pure]
function intlcal_before(IntlCalendar $calendar, IntlCalendar $other): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Set a time field or several common fields at once
 * @link https://secure.php.net/manual/en/intlcalendar.set.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $year 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @param int $month 

 * The new value for IntlCalendar::FIELD_MONTH.
 * 
 * @param int $dayOfMonth [optional] 

 * The new value for IntlCalendar::FIELD_DAY_OF_MONTH.
 * The month sequence is zero-based, i.e., January is represented by 0,
 * February by 1, ..., December is 11 and Undecember (if the calendar has
 * it) is 12.
 * 
 * @param int $hour [optional]
 * 

 * The new value for IntlCalendar::FIELD_HOUR_OF_DAY.
 * 
 * @param int $minute [optional]
 * 

 * The new value for IntlCalendar::FIELD_MINUTE.
 * 
 * @param int $second [optional] 

 * The new value for IntlCalendar::FIELD_SECOND.
 * 
 * @return bool Returns TRUE on success and FALSE on failure.
 * @since 5.5
 */
#[LanguageAware(['8.3' => 'true'], default: 'bool')]
#[Deprecated( reason: 'use IntlCalendar::set(), IntlCalendar::setDate(), or IntlCalendar::setDateTime() instead', since: '8.4' )]
function intlcal_set(IntlCalendar $calendar, int $year, int $month, int $dayOfMonth, int $hour, int $minute, int $second) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Add value to field without carrying into more significant fields
 * @link https://secure.php.net/manual/en/intlcalendar.roll.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 
One of the
 * {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time
 * {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}.
 * These are integer values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @param int|bool $value 

 * The (signed) amount to add to the field, TRUE for rolling up (adding
 * 1), or FALSE for rolling down (subtracting
 * 1).
 * 
 * @return bool Returns TRUE on success or FALSE on failure.
 * @since 5.5
 */
function intlcal_roll(
    IntlCalendar $calendar,
    int $field,
    #[ElementAvailable(from: '5.3', to: '7.4')] $value = null,
    #[ElementAvailable(from: '8.0')] $value
): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Clear a field or all fields
 * @link https://secure.php.net/manual/en/intlcalendar.clear.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int|null $field [optional] 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return bool Returns TRUE on success or FALSE on failure. Failure can only occur is invalid arguments are provided.
 * @since 5.5
 */
#[LanguageAware(['8.3' => 'true'], default: 'bool')]
function intlcal_clear(IntlCalendar $calendar, ?int $field = null): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Calculate difference between given time and this object's time
 * @link https://secure.php.net/manual/en/intlcalendar.fielddifference.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param float $timestamp 

 * The time against which to compare the quantity represented by the
 * field. For the result to be positive, the time
 * given for this parameter must be ahead of the time of the object the
 * method is being invoked on.
 * 
 * @param int $field 

 * The field that represents the quantity being compared.
 * 
 *
 * 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int Returns a (signed) difference of time in the unit associated with the
 * specified field or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_field_difference(IntlCalendar $calendar, float $timestamp, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * The maximum value for a field, considering the object's current time
 * @link https://secure.php.net/manual/en/intlcalendar.getactualmaximum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int
 * An {@link https://secure.php.net/manual/en/language.types.integer.php int} representing the maximum value in the units associated
 * with the given field or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_actual_maximum(IntlCalendar $calendar, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * The minimum value for a field, considering the object's current time
 * @link https://secure.php.net/manual/en/intlcalendar.getactualminimum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}.
 * These are integer values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int
 * An {@link https://secure.php.net/manual/en/language.types.integer.php int} representing the minimum value in the field's
 * unit or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_actual_minimum(IntlCalendar $calendar, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * @link https://secure.php.net/manual/en/intlcalendar.getdayofweektype.php
 * Tell whether a day is a weekday, weekend or a day that has a transition between the two
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $dayOfWeek 

 * One of the constants IntlCalendar::DOW_SUNDAY,
 * IntlCalendar::DOW_MONDAY, ...,
 * IntlCalendar::DOW_SATURDAY.
 * 
 * @return int
 * Returns one of the constants
 * IntlCalendar::DOW_TYPE_WEEKDAY,
 * IntlCalendar::DOW_TYPE_WEEKEND,
 * IntlCalendar::DOW_TYPE_WEEKEND_OFFSET or
 * IntlCalendar::DOW_TYPE_WEEKEND_CEASE or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_day_of_week_type(IntlCalendar $calendar, int $dayOfWeek) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the first day of the week for the calendar's locale
 * @link https://secure.php.net/manual/en/intlcalendar.getfirstdayofweek.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return int
 * One of the constants IntlCalendar::DOW_SUNDAY,
 * IntlCalendar::DOW_MONDAY, ...,
 * IntlCalendar::DOW_SATURDAY or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_first_day_of_week(IntlCalendar $calendar) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the largest local minimum value for a field
 * @link https://secure.php.net/manual/en/intlcalendar.getgreatestminimum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * @return int
 * An {@link https://secure.php.net/manual/en/language.types.integer.php int} representing a field value, in the field's
 * unit, or FALSE on failure.
 * @since 5.5
 */
#[Pure]
function intlcal_greates_minimum($calendar, $field) {}

/**
 * (PHP >= 5.5.0, PECL intl >= 3.0.0a1)

 * Gets the value for a specific field.
 * @link https://www.php.net/manual/en/intlcalendar.get.php
 * @param IntlCalendar $calendar 

 * The IntlCalendar resource.
 * 
 * @param int $field 

 * One of the IntlCalendar date/time field constants. These are integer values between 0 and IntlCalendar::FIELD_COUNT.
 * 
 * @return int An integer with the value of the time field.
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get(IntlCalendar $calendar, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the smallest local maximum for a field
 * @link https://secure.php.net/manual/en/intlcalendar.getleastmaximum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int
 * 
An {@link https://secure.php.net/manual/en/language.types.integer.ph int} representing a field value in the field's
 * unit or FALSE on failure.
 * 
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_least_maximum(IntlCalendar $calendar, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the largest local minimum value for a field
 * @link https://secure.php.net/manual/en/intlcalendar.getgreatestminimum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * @return int
 * An {@link https://secure.php.net/manual/en/language.types.integer.php int} representing a field value, in the field's
 * unit, or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_greatest_minimum(IntlCalendar $calendar, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the locale associated with the object
 * @link https://secure.php.net/manual/en/intlcalendar.getlocale.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $type 

 * Whether to fetch the actual locale (the locale from which the calendar
 * data originates, with Locale::ACTUAL_LOCALE) or the
 * valid locale, i.e., the most specific locale supported by ICU relatively
 * to the requested locale – see Locale::VALID_LOCALE.
 * From the most general to the most specific, the locales are ordered in
 * this fashion – actual locale, valid locale, requested locale.
 * 
 * @return string
 * A locale string or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'string|false'], default: 'string')]
function intlcal_get_locale(IntlCalendar $calendar, int $type) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the global maximum value for a field
 * @link https://secure.php.net/manual/en/intlcalendar.getmaximum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int|false
 * @since 5.5
 */
#[Pure]
function intcal_get_maximum($calendar, $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * @link https://secure.php.net/manual/en/intlcalendar.getminimaldaysinfirstweek.php
 * Get minimal number of days the first week in a year or month can have
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return int
 * An {@link https://secure.php.net/manual/en/language.types.integer.php  int} representing a number of days or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_minimal_days_in_first_week(IntlCalendar $calendar) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the global minimum value for a field
 * @link https://secure.php.net/manual/en/intlcalendar.getminimum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int
 * An int representing a value for the given field in the field's unit or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_minimum(IntlCalendar $calendar, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the object's timezone
 * @link https://secure.php.net/manual/en/intlcalendar.gettimezone.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return IntlTimeZone|false
 * An {@link https://secure.php.net/manual/en/class.intltimezone.php IntlTimeZone} object corresponding to the one used
 * internally in this object.
 * @since 5.5
 */
#[Pure]
function intlcal_get_time_zone(IntlCalendar $calendar): IntlTimeZone|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the calendar type
 * @link https://secure.php.net/manual/en/intlcalendar.gettype.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return string
 * A {@link https://secure.php.net/manual/en/language.types.string.php string} representing the calendar type, such as
 * 'gregorian', 'islamic', etc.
 * @since 5.5
 */
#[Pure]
function intlcal_get_type(IntlCalendar $calendar): string {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get time of the day at which weekend begins or ends
 * @link https://secure.php.net/manual/en/intlcalendar.getweekendtransition.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $dayOfWeek 

 * One of the constants IntlCalendar::DOW_SUNDAY,
 * IntlCalendar::DOW_MONDAY, ...,
 * IntlCalendar::DOW_SATURDAY.
 * 
 * @return int
 * The number of milliseconds into the day at which the the weekend begins or
 * ends or FALSE on failure.
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_weekend_transition(IntlCalendar $calendar, int $dayOfWeek) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Whether the object's time is in Daylight Savings Time
 * @link https://secure.php.net/manual/en/intlcalendar.indaylighttime.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return bool
 * Returns TRUE if the date is in Daylight Savings Time, FALSE otherwise.
 * The value FALSE may also be returned on failure, for instance after
 * specifying invalid field values on non-lenient mode; use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or query
 * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to disambiguate.
 * @since 5.5
 */
#[Pure]
function intlcal_in_daylight_time(IntlCalendar $calendar): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Whether date/time interpretation is in lenient mode
 * @link https://secure.php.net/manual/en/intlcalendar.islenient.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return bool
 * A {@link https://secure.php.net/manual/en/language.types.boolean.php bool} representing whether the calendar is set to lenient mode.
 * @since 5.5
 */
#[Pure]
function intlcal_is_lenient(IntlCalendar $calendar): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Whether a field is set
 * @link https://secure.php.net/manual/en/intlcalendar.isset.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return bool Assuming there are no argument errors, returns TRUE iif the field is set.
 * @since 5.5
 */
#[Pure]
function intlcal_is_set(IntlCalendar $calendar, int $field): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the global maximum value for a field
 * @link https://secure.php.net/manual/en/intlcalendar.getmaximum.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $field 

 * One of the {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} date/time {@link https://secure.php.net/manual/en/class.intlcalendar.php#intlcalendar.constants field constants}. These are integer
 * values between 0 and
 * IntlCalendar::FIELD_COUNT.
 * 
 * @return int|false
 * @since 5.5
 */
#[Pure]
#[LanguageAware(['8.0' => 'int|false'], default: 'int')]
function intlcal_get_maximum(IntlCalendar $calendar, int $field) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Whether another calendar is equal but for a different time
 * @link https://secure.php.net/manual/en/intlcalendar.isequivalentto.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param IntlCalendar $other The other calendar against which the comparison is to be made.
 * @return bool
 * Assuming there are no argument errors, returns TRUE iif the calendars are equivalent except possibly for their set time.
 * @since 5.5
 */
#[Pure]
function intlcal_is_equivalent_to(IntlCalendar $calendar, IntlCalendar $other): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Whether a certain date/time is in the weekend
 * @link https://secure.php.net/manual/en/intlcalendar.isweekend.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param float|null $timestamp [optional] 

 * An optional timestamp representing the number of milliseconds since the
 * epoch, excluding leap seconds. If NULL, this object's current time is
 * used instead.
 * 
 * @return bool
 * 
 A {@link https://secure.php.net/manual/en/language.types.boolean.php bool} indicating whether the given or this object's time occurs
 * in a weekend.
 * 
 * 

 * The value FALSE may also be returned on failure, for instance after giving
 * a date out of bounds on non-lenient mode; use {@link https://secure.php.net/manual/en/intl.configuration.php#ini.intl.use-exceptions exceptions} or query
 * {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()} to disambiguate.
 * @since 5.5
 */
#[Pure]
function intlcal_is_weekend(IntlCalendar $calendar, ?float $timestamp = null): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Set the day on which the week is deemed to start
 * @link https://secure.php.net/manual/en/intlcalendar.setfirstdayofweek.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $dayOfWeek 

 * One of the constants IntlCalendar::DOW_SUNDAY,
 * IntlCalendar::DOW_MONDAY, ...,
 * IntlCalendar::DOW_SATURDAY.
 * 
 * @return bool Returns TRUE on success. Failure can only happen due to invalid parameters.
 * @since 5.5
 */
#[LanguageAware(['8.3' => 'true'], default: 'bool')]
function intlcal_set_first_day_of_week(IntlCalendar $calendar, int $dayOfWeek) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Set whether date/time interpretation is to be lenient
 * @link https://secure.php.net/manual/en/intlcalendar.setlenient.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param bool $lenient 

 * Use TRUE to activate the lenient mode; FALSE otherwise.
 * 
 * @return bool Returns TRUE on success. Failure can only happen due to invalid parameters.
 * @since 5.5
 */
#[LanguageAware(['8.3' => 'true'], default: 'bool')]
function intlcal_set_lenient(IntlCalendar $calendar, bool $lenient) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get behavior for handling repeating wall time
 * @link https://secure.php.net/manual/en/intlcalendar.getrepeatedwalltimeoption.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return int
 * One of the constants IntlCalendar::WALLTIME_FIRST or
 * IntlCalendar::WALLTIME_LAST.
 * @since 5.5
 */
#[Pure]
function intlcal_get_repeated_wall_time_option(IntlCalendar $calendar): int {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Compare time of two IntlCalendar objects for equality
 * @link https://secure.php.net/manual/en/intlcalendar.equals.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param IntlCalendar $other
 * @return bool 

 * Returns TRUE if the current time of both this and the passed in
 * {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} object are the same, or FALSE
 * otherwise. The value FALSE can also be returned on failure. This can only
 * happen if bad arguments are passed in. In any case, the two cases can be
 * distinguished by calling  {@link https://secure.php.net/manual/en/function.intl-get-error-code.php intl_get_error_code()}.
 * 
 * @since 5.5
 */
#[Pure]
function intlcal_equals(IntlCalendar $calendar, IntlCalendar $other): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get behavior for handling skipped wall time
 * @link https://secure.php.net/manual/en/intlcalendar.getskippedwalltimeoption.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return int
 * One of the constants IntlCalendar::WALLTIME_FIRST,
 * IntlCalendar::WALLTIME_LAST or
 * IntlCalendar::WALLTIME_NEXT_VALID.
 * @since 5.5
 */
#[Pure]
function intlcal_get_skipped_wall_time_option(IntlCalendar $calendar): int {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Set behavior for handling repeating wall times at negative timezone offset transitions
 * @link https://secure.php.net/manual/en/intlcalendar.setrepeatedwalltimeoption.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $option 

 * One of the constants IntlCalendar::WALLTIME_FIRST or
 * IntlCalendar::WALLTIME_LAST.
 * 
 * @return bool
 * Returns TRUE on success. Failure can only happen due to invalid parameters.
 * @since 5.5
 */
#[LanguageAware(['8.3' => 'true'], default: 'bool')]
function intlcal_set_repeated_wall_time_option(IntlCalendar $calendar, int $option) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Set behavior for handling skipped wall times at positive timezone offset transitions
 * @link https://secure.php.net/manual/en/intlcalendar.setskippedwalltimeoption.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @param int $option 

 * One of the constants IntlCalendar::WALLTIME_FIRST,
 * IntlCalendar::WALLTIME_LAST or
 * IntlCalendar::WALLTIME_NEXT_VALID.
 * 
 * @return bool
 * 

 * Returns TRUE on success. Failure can only happen due to invalid parameters.
 * 
 * @since 5.5
 */
#[LanguageAware(['8.3' => 'true'], default: 'bool')]
function intlcal_set_skipped_wall_time_option(IntlCalendar $calendar, int $option) {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a2)

 * Create an IntlCalendar from a DateTime object or string
 * @link https://secure.php.net/manual/en/intlcalendar.fromdatetime.php
 * @param DateTime|string $datetime 

 * A {@link https://secure.php.net/manual/en/class.datetime.php DateTime} object or a {@link https://secure.php.net/manual/en/language.types.string.php string} that
 * can be passed to  {@link https://secure.php.net/manual/en/datetime.construct.php DateTime::__construct()}.
 * 
 * @param null|string $locale
 * @return IntlCalendar|null
 * The created {@link https://secure.php.net/manual/en/class.intlcalendar.php IntlCalendar} object or NULL in case of
 * failure. If a {@link https://secure.php.net/manual/en/language.types.string.php string} is passed, any exception that occurs
 * inside the {@link https://secure.php.net/manual/en/class.datetime.php DateTime} constructor is propagated.
 * @since 5.5
 */
#[Pure]
function intlcal_from_date_time(
    DateTime|string $datetime,
    #[ElementAvailable(from: '8.0')] ?string $locale = null
): ?IntlCalendar {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a2)

 * Convert an IntlCalendar into a DateTime object
 * @link https://secure.php.net/manual/en/intlcalendar.todatetime.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return DateTime|false
 * A {@link https://secure.php.net/manual/en/class.datetime.php DateTime} object with the same timezone as this
 * object (though using PHP's database instead of ICU's) and the same time,
 * except for the smaller precision (second precision instead of millisecond).
 * Returns FALSE on failure.
 * @since 5.5
 */
#[Pure]
function intlcal_to_date_time(IntlCalendar $calendar): DateTime|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get last error code on the object
 * @link https://secure.php.net/manual/en/intlcalendar.geterrorcode.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return int|false An ICU error code indicating either success, failure or a warning.
 * @since 5.5
 */
#[Pure(true)]
function intlcal_get_error_code(IntlCalendar $calendar): int|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get last error message on the object
 * @link https://secure.php.net/manual/en/intlcalendar.geterrormessage.php
 * @param IntlCalendar $calendar 

 * The calendar object, on the procedural style interface.
 * 
 * @return string|false The error message associated with last error that occurred in a function call on this object, or a string indicating the non-existance of an error.
 * @since 5.5
 */
#[Pure(true)]
function intlcal_get_error_message(IntlCalendar $calendar): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the number of IDs in the equivalency group that includes the given ID
 * @link https://secure.php.net/manual/en/intltimezone.countequivalentids.php
 * @param string $timezoneId
 * @return int|false
 * @since 5.5
 */
#[Pure]
function intltz_count_equivalent_ids(string $timezoneId): int|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Create a new copy of the default timezone for this host
 * @link https://secure.php.net/manual/en/intltimezone.createdefault.php
 * @return IntlTimeZone
 * @since 5.5
 */
#[Pure]
function intlz_create_default() {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * @link https://secure.php.net/manual/en/intltimezone.createenumeration.php
 * @param IntlTimeZone|string|int|float|null $countryOrRawOffset [optional]
 * @return IntlIterator|false
 * @since 5.5
 */
#[Pure]
function intltz_create_enumeration($countryOrRawOffset): IntlIterator|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * @link https://secure.php.net/manual/en/intltimezone.createtimezone.php
 * @param string $timezoneId
 * @return IntlTimeZone|null
 * @since 5.5
 */
#[Pure]
function intltz_create_time_zone(string $timezoneId): ?IntlTimeZone {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * @link https://secure.php.net/manual/en/intltimezone.fromdatetimezone.php
 * @param DateTimeZone $timezone
 * @return IntlTimeZone|null
 * @since 5.5
 */
#[Pure]
function intltz_from_date_time_zone(DateTimeZone $timezone): ?IntlTimeZone {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID
 * @link https://secure.php.net/manual/en/intltimezone.getcanonicalid.php
 * @param string $timezoneId
 * @param bool &$isSystemId [optional]
 * @return string|false
 * @since 5.5
 */
#[Pure]
function intltz_get_canonical_id(string $timezoneId, &$isSystemId): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get a name of this time zone suitable for presentation to the user
 * @param IntlTimeZone $timezone - 

 * The time zone object, on the procedural style interface.
 * 
 * @param bool $dst [optional]
 * @param int $style [optional]
 * @param string|null $locale [optional]
 * @return string|false
 * @since 5.5
 */
#[Pure]
function intltz_get_display_name(IntlTimeZone $timezone, bool $dst = false, int $style = 2, ?string $locale): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the amount of time to be added to local standard time to get local wall clock time
 * @param IntlTimeZone $timezone - 

 * The time zone object, on the procedural style interface.
 * 
 * @return int
 * @link https://secure.php.net/manual/en/intltimezone.getequivalentid.php
 * @since 5.5
 */
#[Pure]
function intltz_get_dst_savings(IntlTimeZone $timezone): int {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get an ID in the equivalency group that includes the given ID
 * @link https://secure.php.net/manual/en/intltimezone.getequivalentid.php
 * @param string $timezoneId
 * @param int $offset
 * @return string|false
 * @since 5.5
 */
#[Pure]
function intltz_get_equivalent_id(string $timezoneId, int $offset): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get last error code on the object
 * @link https://secure.php.net/manual/en/intltimezone.geterrorcode.php
 * @param IntlTimeZone $timezone - 

 * The time zone object, on the procedural style interface.
 * 
 * @return int|false
 * @since 5.5
 */
#[Pure(true)]
function intltz_get_error_code(IntlTimeZone $timezone): int|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get last error message on the object
 * @link https://secure.php.net/manual/en/intltimezone.geterrormessage.php
 * @param IntlTimeZone $timezone - 

 * The time zone object, on the procedural style interface.
 * 
 * @return string|false
 * @since 5.5
 */
#[Pure(true)]
function intltz_get_error_message(IntlTimeZone $timezone): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Create GMT (UTC) timezone
 * @link https://secure.php.net/manual/en/intltimezone.getgmt.php
 * @return IntlTimeZone
 * @since 5.5
 */
#[Pure]
function intltz_getGMT(): IntlTimeZone {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get timezone ID
 * @link https://secure.php.net/manual/en/intltimezone.getid.php
 * @param IntlTimeZone $timezone
 * @return string|false
 * @since 5.5
 */
#[Pure]
function intltz_get_id(IntlTimeZone $timezone): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the time zone raw and GMT offset for the given moment in time
 * @link https://secure.php.net/manual/en/intltimezone.getoffset.php
 * @param IntlTimeZone $timezone
 * @param float $timestamp
 * @param bool $local
 * @param int &$rawOffset
 * @param int &$dstOffset
 * @return bool
 * @since 5.5
 */
#[Pure]
function intltz_get_offset(IntlTimeZone $timezone, float $timestamp, bool $local, &$rawOffset, &$dstOffset): bool {}

/**
 * Get the raw GMT offset (before taking daylight savings time into account
 * @link https://secure.php.net/manual/en/intltimezone.getrawoffset.php
 * @param IntlTimeZone $timezone
 * @return int
 */
#[Pure]
function intltz_get_raw_offset(IntlTimeZone $timezone): int {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Get the timezone data version currently used by ICU
 * @link https://secure.php.net/manual/en/intltimezone.gettzdataversion.php
 * @return string|false
 * @since 5.5
 */
#[Pure]
function intltz_get_tz_data_version(): string|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Check if this zone has the same rules and offset as another zone
 * @link https://secure.php.net/manual/en/intltimezone.hassamerules.php
 * @param IntlTimeZone $timezone
 * @param IntlTimeZone $other
 * @return bool
 * @since 5.5
 */
#[Pure]
function intltz_has_same_rules(
    IntlTimeZone $timezone,
    #[ElementAvailable(from: '5.5', to: '7.4')] IntlTimeZone $other = null,
    #[ElementAvailable(from: '8.0')] IntlTimeZone $other
): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Convert to DateTimeZone object
 * @link https://secure.php.net/manual/en/intltimezone.todatetimezone.php
 * @param IntlTimeZone $timezone
 * @return DateTimeZone|false
 * @since 5.5
 */
#[Pure]
function intltz_to_date_time_zone(IntlTimeZone $timezone): DateTimeZone|false {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * Check if this time zone uses daylight savings time
 * @link https://secure.php.net/manual/en/intltimezone.usedaylighttime.php
 * @param IntlTimeZone $timezone
 * @return bool
 * @since 5.5
 */
#[Pure]
function intltz_use_daylight_time(IntlTimeZone $timezone): bool {}

/**
 * (PHP 5 >=5.5.0 PECL intl >= 3.0.0a1)

 * @param DateTimeZone|IntlTimeZone|string|int|null $timezoneOrYear [optional]
 * @param string|null $localeOrMonth [optional]
 * @param int $day [optional]
 * @param int $hour [optional]
 * @param int $minute [optional]
 * @param int $second [optional]
 * @return IntlGregorianCalendar|null
 * @since 5.5
 */
#[Pure]
#[Deprecated( reason: 'use IntlGregorianCalendar::__construct(), IntlGregorianCalendar::createFromDate(), or IntlGregorianCalendar::createFromDateTime() instead', since: '8.4' )]
function intlgregcal_create_instance($timezoneOrYear, $localeOrMonth, $day, $hour, $minute, $second): ?IntlGregorianCalendar {}

/**
 * @param IntlGregorianCalendar $calendar
 * @param float $timestamp
 * @return bool
 */
function intlgregcal_set_gregorian_change(IntlGregorianCalendar $calendar, float $timestamp): bool {}

/**
 * @param IntlGregorianCalendar $calendar
 * @return float
 */
#[Pure]
function intlgregcal_get_gregorian_change(IntlGregorianCalendar $calendar): float {}

/**
 * @param IntlGregorianCalendar $calendar
 * @param int $year
 * @return bool
 */
#[Pure]
function intlgregcal_is_leap_year(IntlGregorianCalendar $calendar, int $year): bool {}

/**
 * (PHP >= 5.3.2, PECL intl >= 2.0.0)

 * Create a resource bundle
 * @link https://php.net/manual/en/resourcebundle.create.php
 * @param string|null $locale 

 * Locale for which the resources should be loaded (locale name, e.g. en_CA).
 * 
 * @param string|null $bundle 

 * The directory where the data is stored or the name of the .dat file.
 * 
 * @param bool $fallback [optional] 

 * Whether locale should match exactly or fallback to parent locale is allowed.
 * 
 * @return ResourceBundle|null ResourceBundle object or NULL on error.
 */
#[Pure]
function resourcebundle_create(?string $locale, ?string $bundle, bool $fallback = true): ?ResourceBundle {}

/**
 * (PHP >= 5.3.2, PECL intl >= 2.0.0)

 * Get data from the bundle
 * @link https://php.net/manual/en/resourcebundle.get.php
 * @param ResourceBundle $bundle
 * @param string|int $index 

 * Data index, must be string or integer.
 * 
 * @param bool $fallback
 * @return mixed the data located at the index or NULL on error. Strings, integers and binary data strings
 * are returned as corresponding PHP types, integer array is returned as PHP array. Complex types are
 * returned as ResourceBundle object.
 */
#[Pure]
#[LanguageAware(['8.4' => 'ResourceBundle|array|string|int|null'], default: 'mixed')]
function resourcebundle_get(ResourceBundle $bundle, string|int $index, bool $fallback = true) {}

/**
 * (PHP >= 5.3.2, PECL intl >= 2.0.0)

 * Get number of elements in the bundle
 * @link https://php.net/manual/en/resourcebundle.count.php
 * @param ResourceBundle $bundle
 * @return int number of elements in the bundle.
 */
#[Pure]
function resourcebundle_count(ResourceBundle $bundle): int {}

/**
 * (PHP >= 5.3.2, PECL intl >= 2.0.0)

 * Get supported locales
 * @link https://php.net/manual/en/resourcebundle.locales.php
 * @param string $bundle 

 * Path of ResourceBundle for which to get available locales, or
 * empty string for default locales list.
 * 
 * @return array|false the list of locales supported by the bundle.
 */
#[Pure]
function resourcebundle_locales(string $bundle): array|false {}

/**
 * (PHP >= 5.3.2, PECL intl >= 2.0.0)

 * Get bundle's last error code.
 * @link https://php.net/manual/en/resourcebundle.geterrorcode.php
 * @param ResourceBundle $bundle
 * @return int error code from last bundle object call.
 */
#[Pure(true)]
function resourcebundle_get_error_code(ResourceBundle $bundle): int {}

/**
 * (PHP >= 5.3.2, PECL intl >= 2.0.0)

 * Get bundle's last error message.
 * @link https://php.net/manual/en/resourcebundle.geterrormessage.php
 * @param ResourceBundle $bundle
 * @return string error message from last bundle object's call.
 */
#[Pure(true)]
function resourcebundle_get_error_message(ResourceBundle $bundle): string {}

/**
 * (PHP >= 5.4.0, PECL intl >= 2.0.0)

 * Create a transliterator
 * @link https://php.net/manual/en/transliterator.create.php
 * @param string $id 

 * The id.
 * 
 * @param int $direction 

 * The direction, defaults to
 * Transliterator::FORWARD.
 * May also be set to
 * Transliterator::REVERSE.
 * 
 * @return Transliterator|null a Transliterator object on success,
 * or NULL on failure.
 * @since 5.4
 */
#[Pure]
function transliterator_create(string $id, int $direction = 0): ?Transliterator {}

/**
 * (PHP >= 5.4.0, PECL intl >= 2.0.0)

 * Create transliterator from rules
 * @link https://php.net/manual/en/transliterator.createfromrules.php
 * @param string $rules 

 * The rules.
 * 
 * @param int $direction 

 * The direction, defaults to
 * Transliterator::FORWARD.
 * May also be set to
 * Transliterator::REVERSE.
 * 
 * @return Transliterator|null a Transliterator object on success,
 * or NULL on failure.
 * @since 5.4
 */
#[Pure]
function transliterator_create_from_rules(string $rules, int $direction = 0): ?Transliterator {}

/**
 * (PHP >= 5.4.0, PECL intl >= 2.0.0)

 * Get transliterator IDs
 * @link https://php.net/manual/en/transliterator.listids.php
 * @return string[]|false An array of registered transliterator IDs on success,
 * or FALSE on failure.
 * @since 5.4
 */
#[Pure]
function transliterator_list_ids(): array|false {}

/**
 * (PHP >= 5.4.0, PECL intl >= 2.0.0)

 * Create an inverse transliterator
 * @link https://php.net/manual/en/transliterator.createinverse.php
 * @param Transliterator $transliterator
 * @return Transliterator|null a Transliterator object on success,
 * or NULL on failure
 * @since 5.4
 */
#[Pure]
function transliterator_create_inverse(Transliterator $transliterator): ?Transliterator {}

/**
 * (PHP >= 5.4.0, PECL intl >= 2.0.0)

 * Transliterate a string
 * @link https://php.net/manual/en/transliterator.transliterate.php
 * @param Transliterator|string $transliterator
 * @param string $string 

 * The string to be transformed.
 * 
 * @param int $start 

 * The start index (in UTF-16 code units) from which the string will start
 * to be transformed, inclusive. Indexing starts at 0. The text before will
 * be left as is.
 * 
 * @param int $end 

 * The end index (in UTF-16 code units) until which the string will be
 * transformed, exclusive. Indexing starts at 0. The text after will be
 * left as is.
 * 
 * @return string|false The transfomed string on success, or FALSE on failure.
 * @since 5.4
 */
#[Pure]
function transliterator_transliterate(Transliterator|string $transliterator, string $string, int $start = 0, int $end = -1): string|false {}

/**
 * (PHP >= 5.4.0, PECL intl >= 2.0.0)

 * Get last error code
 * @link https://php.net/manual/en/transliterator.geterrorcode.php
 * @param Transliterator $transliterator
 * @return int|false The error code on success,
 * or FALSE if none exists, or on failure.
 * @since 5.4
 */
#[Pure(true)]
function transliterator_get_error_code(Transliterator $transliterator): int|false {}

/**
 * (PHP >= 5.4.0, PECL intl >= 2.0.0)

 * Get last error message
 * @link https://php.net/manual/en/transliterator.geterrormessage.php
 * @param Transliterator $transliterator
 * @return string|false The error code on success,
 * or FALSE if none exists, or on failure.
 * @since 5.4
 */
#[Pure(true)]
function transliterator_get_error_message(Transliterator $transliterator): string|false {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get the last error code
 * @link https://php.net/manual/en/function.intl-get-error-code.php
 * @return int Error code returned by the last API function call.
 */
#[Pure(true)]
function intl_get_error_code(): int {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get description of the last error
 * @link https://php.net/manual/en/function.intl-get-error-message.php
 * @return string Description of an error occurred in the last API function call.
 */
#[Pure(true)]
function intl_get_error_message(): string {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Check whether the given error code indicates failure
 * @link https://php.net/manual/en/function.intl-is-failure.php
 * @param int $errorCode 

 * is a value that returned by functions:
 * intl_get_error_code,
 * collator_get_error_code .
 * 
 * @return bool TRUE if it the code indicates some failure, and FALSE
 * in case of success or a warning.
 */
#[Pure]
function intl_is_failure(int $errorCode): bool {}

/**
 * (PHP 5 >= 5.3.0, PECL intl >= 1.0.0)

 * Get symbolic name for a given error code
 * @link https://php.net/manual/en/function.intl-error-name.php
 * @param int $errorCode 

 * ICU error code.
 * 
 * @return string The returned string will be the same as the name of the error code
 * constant.
 */
#[Pure]
function intl_error_name(int $errorCode): string {}

/**
 * Gets the Decomposition_Mapping property for the given UTF-8 encoded code point
 *
 * @link https://www.php.net/manual/en/normalizer.getrawdecomposition.php
 *
 * @param string $string
 * @param int $form
 * @return string|null
 *
 * @since 7.3
 */
#[Pure]
function normalizer_get_raw_decomposition(string $string, #[ElementAvailable(from: '8.0')] int $form = Normalizer::FORM_C): ?string {}

/**
 * @return IntlTimeZone
 * @since 5.5
 */
#[Pure]
function intltz_create_default(): IntlTimeZone {}

/**
 * @return IntlTimeZone
 * @since 5.5
 */
#[Pure]
function intltz_get_gmt(): IntlTimeZone {}

/**
 * @return IntlTimeZone
 * @since 5.5
 */
#[Pure]
function intltz_get_unknown(): IntlTimeZone {}

/**
 * @param int $type
 * @param null|string $region
 * @param null|int $rawOffset
 * @return IntlIterator|false
 * @since 5.5
 */
#[Pure]
function intltz_create_time_zone_id_enumeration(int $type, ?string $region = null, ?int $rawOffset = null): IntlIterator|false {}

/**
 * @param string $timezoneId
 * @return string|false
 * @since 5.5
 */
#[Pure]
function intltz_get_region(string $timezoneId): string|false {}

/**
 * Set minimal number of days the first week in a year or month can have
 *
 * @link https://www.php.net/manual/en/intlcalendar.setminimaldaysinfirstweek.php
 *
 * @param IntlCalendar $calendar
 * @param int $days
 * @return bool
 *
 * @since 5.5.1
 */
#[LanguageAware(['8.3' => 'true'], default: 'bool')]
function intlcal_set_minimal_days_in_first_week(IntlCalendar $calendar, int $days) {}

function intltz_get_windows_id(string $timezoneId): string|false {}

function intltz_get_id_for_windows_id(string $timezoneId, ?string $region = null): string|false {}

/**
 * @since 8.4
 */
function grapheme_str_split(string $string, int $length = 1): array|false {}

/**
 * @since  8.4
 */
function intltz_get_iana_id(string $timezoneId): string|false {}

/**
 * Limit on locale length, set to 80 in PHP code. Locale names longer
 * than this limit will not be accepted.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('INTL_MAX_LOCALE_LEN', 156);
define('INTL_ICU_VERSION', "74.1");
define('INTL_ICU_DATA_VERSION', "74.1");
define('ULOC_ACTUAL_LOCALE', 0);
define('ULOC_VALID_LOCALE', 1);
define('GRAPHEME_EXTR_COUNT', 0);
define('GRAPHEME_EXTR_MAXBYTES', 1);
define('GRAPHEME_EXTR_MAXCHARS', 2);
define('U_USING_FALLBACK_WARNING', -128);
define('U_ERROR_WARNING_START', -128);
define('U_USING_DEFAULT_WARNING', -127);
define('U_SAFECLONE_ALLOCATED_WARNING', -126);
define('U_STATE_OLD_WARNING', -125);
define('U_STRING_NOT_TERMINATED_WARNING', -124);
define('U_SORT_KEY_TOO_SHORT_WARNING', -123);
define('U_AMBIGUOUS_ALIAS_WARNING', -122);
define('U_DIFFERENT_UCA_VERSION', -121);
define('U_ERROR_WARNING_LIMIT', -119);
define('U_ZERO_ERROR', 0);
define('U_ILLEGAL_ARGUMENT_ERROR', 1);
define('U_MISSING_RESOURCE_ERROR', 2);
define('U_INVALID_FORMAT_ERROR', 3);
define('U_FILE_ACCESS_ERROR', 4);
define('U_INTERNAL_PROGRAM_ERROR', 5);
define('U_MESSAGE_PARSE_ERROR', 6);
define('U_MEMORY_ALLOCATION_ERROR', 7);
define('U_INDEX_OUTOFBOUNDS_ERROR', 8);
define('U_PARSE_ERROR', 9);
define('U_INVALID_CHAR_FOUND', 10);
define('U_TRUNCATED_CHAR_FOUND', 11);
define('U_ILLEGAL_CHAR_FOUND', 12);
define('U_INVALID_TABLE_FORMAT', 13);
define('U_INVALID_TABLE_FILE', 14);
define('U_BUFFER_OVERFLOW_ERROR', 15);
define('U_UNSUPPORTED_ERROR', 16);
define('U_RESOURCE_TYPE_MISMATCH', 17);
define('U_ILLEGAL_ESCAPE_SEQUENCE', 18);
define('U_UNSUPPORTED_ESCAPE_SEQUENCE', 19);
define('U_NO_SPACE_AVAILABLE', 20);
define('U_CE_NOT_FOUND_ERROR', 21);
define('U_PRIMARY_TOO_LONG_ERROR', 22);
define('U_STATE_TOO_OLD_ERROR', 23);
define('U_TOO_MANY_ALIASES_ERROR', 24);
define('U_ENUM_OUT_OF_SYNC_ERROR', 25);
define('U_INVARIANT_CONVERSION_ERROR', 26);
define('U_INVALID_STATE_ERROR', 27);
define('U_COLLATOR_VERSION_MISMATCH', 28);
define('U_USELESS_COLLATOR_ERROR', 29);
define('U_NO_WRITE_PERMISSION', 30);
define('U_STANDARD_ERROR_LIMIT', 32);
define('U_BAD_VARIABLE_DEFINITION', 65536);
define('U_PARSE_ERROR_START', 65536);
define('U_MALFORMED_RULE', 65537);
define('U_MALFORMED_SET', 65538);
define('U_MALFORMED_SYMBOL_REFERENCE', 65539);
define('U_MALFORMED_UNICODE_ESCAPE', 65540);
define('U_MALFORMED_VARIABLE_DEFINITION', 65541);
define('U_MALFORMED_VARIABLE_REFERENCE', 65542);
define('U_MISMATCHED_SEGMENT_DELIMITERS', 65543);
define('U_MISPLACED_ANCHOR_START', 65544);
define('U_MISPLACED_CURSOR_OFFSET', 65545);
define('U_MISPLACED_QUANTIFIER', 65546);
define('U_MISSING_OPERATOR', 65547);
define('U_MISSING_SEGMENT_CLOSE', 65548);
define('U_MULTIPLE_ANTE_CONTEXTS', 65549);
define('U_MULTIPLE_CURSORS', 65550);
define('U_MULTIPLE_POST_CONTEXTS', 65551);
define('U_TRAILING_BACKSLASH', 65552);
define('U_UNDEFINED_SEGMENT_REFERENCE', 65553);
define('U_UNDEFINED_VARIABLE', 65554);
define('U_UNQUOTED_SPECIAL', 65555);
define('U_UNTERMINATED_QUOTE', 65556);
define('U_RULE_MASK_ERROR', 65557);
define('U_MISPLACED_COMPOUND_FILTER', 65558);
define('U_MULTIPLE_COMPOUND_FILTERS', 65559);
define('U_INVALID_RBT_SYNTAX', 65560);
define('U_INVALID_PROPERTY_PATTERN', 65561);
define('U_MALFORMED_PRAGMA', 65562);
define('U_UNCLOSED_SEGMENT', 65563);
define('U_ILLEGAL_CHAR_IN_SEGMENT', 65564);
define('U_VARIABLE_RANGE_EXHAUSTED', 65565);
define('U_VARIABLE_RANGE_OVERLAP', 65566);
define('U_ILLEGAL_CHARACTER', 65567);
define('U_INTERNAL_TRANSLITERATOR_ERROR', 65568);
define('U_INVALID_ID', 65569);
define('U_INVALID_FUNCTION', 65570);
define('U_PARSE_ERROR_LIMIT', 65571);
define('U_UNEXPECTED_TOKEN', 65792);
define('U_FMT_PARSE_ERROR_START', 65792);
define('U_MULTIPLE_DECIMAL_SEPARATORS', 65793);
define('U_MULTIPLE_DECIMAL_SEPERATORS', 65793);
define('U_MULTIPLE_EXPONENTIAL_SYMBOLS', 65794);
define('U_MALFORMED_EXPONENTIAL_PATTERN', 65795);
define('U_MULTIPLE_PERCENT_SYMBOLS', 65796);
define('U_MULTIPLE_PERMILL_SYMBOLS', 65797);
define('U_MULTIPLE_PAD_SPECIFIERS', 65798);
define('U_PATTERN_SYNTAX_ERROR', 65799);
define('U_ILLEGAL_PAD_POSITION', 65800);
define('U_UNMATCHED_BRACES', 65801);
define('U_UNSUPPORTED_PROPERTY', 65802);
define('U_UNSUPPORTED_ATTRIBUTE', 65803);
define('U_FMT_PARSE_ERROR_LIMIT', 65812);
define('U_BRK_INTERNAL_ERROR', 66048);
define('U_BRK_ERROR_START', 66048);
define('U_BRK_HEX_DIGITS_EXPECTED', 66049);
define('U_BRK_SEMICOLON_EXPECTED', 66050);
define('U_BRK_RULE_SYNTAX', 66051);
define('U_BRK_UNCLOSED_SET', 66052);
define('U_BRK_ASSIGN_ERROR', 66053);
define('U_BRK_VARIABLE_REDFINITION', 66054);
define('U_BRK_MISMATCHED_PAREN', 66055);
define('U_BRK_NEW_LINE_IN_QUOTED_STRING', 66056);
define('U_BRK_UNDEFINED_VARIABLE', 66057);
define('U_BRK_INIT_ERROR', 66058);
define('U_BRK_RULE_EMPTY_SET', 66059);
define('U_BRK_UNRECOGNIZED_OPTION', 66060);
define('U_BRK_MALFORMED_RULE_TAG', 66061);
define('U_BRK_ERROR_LIMIT', 66062);
define('U_REGEX_INTERNAL_ERROR', 66304);
define('U_REGEX_ERROR_START', 66304);
define('U_REGEX_RULE_SYNTAX', 66305);
define('U_REGEX_INVALID_STATE', 66306);
define('U_REGEX_BAD_ESCAPE_SEQUENCE', 66307);
define('U_REGEX_PROPERTY_SYNTAX', 66308);
define('U_REGEX_UNIMPLEMENTED', 66309);
define('U_REGEX_MISMATCHED_PAREN', 66310);
define('U_REGEX_NUMBER_TOO_BIG', 66311);
define('U_REGEX_BAD_INTERVAL', 66312);
define('U_REGEX_MAX_LT_MIN', 66313);
define('U_REGEX_INVALID_BACK_REF', 66314);
define('U_REGEX_INVALID_FLAG', 66315);
define('U_REGEX_LOOK_BEHIND_LIMIT', 66316);
define('U_REGEX_SET_CONTAINS_STRING', 66317);
define('U_REGEX_ERROR_LIMIT', 66326);
define('U_IDNA_PROHIBITED_ERROR', 66560);
define('U_IDNA_ERROR_START', 66560);
define('U_IDNA_UNASSIGNED_ERROR', 66561);
define('U_IDNA_CHECK_BIDI_ERROR', 66562);
define('U_IDNA_STD3_ASCII_RULES_ERROR', 66563);
define('U_IDNA_ACE_PREFIX_ERROR', 66564);
define('U_IDNA_VERIFICATION_ERROR', 66565);
define('U_IDNA_LABEL_TOO_LONG_ERROR', 66566);
define('U_IDNA_ZERO_LENGTH_LABEL_ERROR', 66567);
define('U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR', 66568);
define('U_IDNA_ERROR_LIMIT', 66569);
define('U_STRINGPREP_PROHIBITED_ERROR', 66560);
define('U_STRINGPREP_UNASSIGNED_ERROR', 66561);
define('U_STRINGPREP_CHECK_BIDI_ERROR', 66562);
define('U_ERROR_LIMIT', 66818);

/**
 * Prohibit processing of unassigned codepoints in the input for IDN
 * functions and do not check if the input conforms to domain name ASCII rules.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_DEFAULT', 0);

/**
 * Allow processing of unassigned codepoints in the input for IDN functions.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_ALLOW_UNASSIGNED', 1);

/**
 * Check if the input for IDN functions conforms to domain name ASCII rules.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_USE_STD3_RULES', 2);

/**
 * Check whether the input conforms to the BiDi rules.
 * Ignored by the IDNA2003 implementation, which always performs this check.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_CHECK_BIDI', 4);

/**
 * Check whether the input conforms to the CONTEXTJ rules.
 * Ignored by the IDNA2003 implementation, as this check is new in IDNA2008.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_CHECK_CONTEXTJ', 8);

/**
 * Option for nontransitional processing in
 * idn_to_ascii. Transitional processing is activated
 * by default. This option is ignored by the IDNA2003 implementation.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_NONTRANSITIONAL_TO_ASCII', 16);

/**
 * Option for nontransitional processing in
 * idn_to_utf8. Transitional processing is activated
 * by default. This option is ignored by the IDNA2003 implementation.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_NONTRANSITIONAL_TO_UNICODE', 32);

/**
 * Use IDNA 2003 algorithm in {@see idn_to_utf8} and
 * {@see idn_to_ascii}. This is the default.
 * @link https://php.net/manual/en/intl.constants.php
 * @deprecated 7.2 Use {@see INTL_IDNA_VARIANT_UTS46} instead.
 */
define('INTL_IDNA_VARIANT_2003', 0);

/**
 * Use UTS #46 algorithm in idn_to_utf8 and
 * idn_to_ascii.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('INTL_IDNA_VARIANT_UTS46', 1);

/**
 * Errors reported in a bitset returned by the UTS #46 algorithm in
 * idn_to_utf8 and
 * idn_to_ascii.
 * @link https://php.net/manual/en/intl.constants.php
 */
define('IDNA_ERROR_EMPTY_LABEL', 1);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_LABEL_TOO_LONG', 2);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_DOMAIN_NAME_TOO_LONG', 4);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_LEADING_HYPHEN', 8);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_TRAILING_HYPHEN', 16);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_HYPHEN_3_4', 32);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_LEADING_COMBINING_MARK', 64);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_DISALLOWED', 128);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_PUNYCODE', 256);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_LABEL_HAS_DOT', 512);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_INVALID_ACE_LABEL', 1024);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_BIDI', 2048);
/**
 * @link https://secure.php.net/manual/en/migration54.global-constants.php
 * @since 5.4
 */
define('IDNA_ERROR_CONTEXTJ', 4096);

/**
 * @since 5.5
 */
class IntlBreakIterator implements IteratorAggregate
{
    /* Constants */
    public const DONE = -1;
    public const WORD_NONE = 0;
    public const WORD_NONE_LIMIT = 100;
    public const WORD_NUMBER = 100;
    public const WORD_NUMBER_LIMIT = 200;
    public const WORD_LETTER = 200;
    public const WORD_LETTER_LIMIT = 300;
    public const WORD_KANA = 300;
    public const WORD_KANA_LIMIT = 400;
    public const WORD_IDEO = 400;
    public const WORD_IDEO_LIMIT = 500;
    public const LINE_SOFT = 0;
    public const LINE_SOFT_LIMIT = 100;
    public const LINE_HARD = 100;
    public const LINE_HARD_LIMIT = 200;
    public const SENTENCE_TERM = 0;
    public const SENTENCE_TERM_LIMIT = 100;
    public const SENTENCE_SEP = 100;
    public const SENTENCE_SEP_LIMIT = 200;

    /* Methods */
    /**
     * (PHP 5 >=5.5.0)

     * Private constructor for disallowing instantiation
     */
    private function __construct() {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for boundaries of combining character sequences
     * @link https://secure.php.net/manual/en/intlbreakiterator.createcharacterinstance.php
     * @param string $locale
     * @return IntlBreakIterator|null
     */
    #[TentativeType]
    public static function createCharacterInstance(#[LanguageAware(['8.0' => 'string|null'], default: '')] $locale = null): ?IntlBreakIterator {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for boundaries of code points
     * @link https://secure.php.net/manual/en/intlbreakiterator.createcodepointinstance.php
     * @return IntlCodePointBreakIterator
     */
    #[TentativeType]
    public static function createCodePointInstance(): IntlCodePointBreakIterator {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for logically possible line breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createlineinstance.php
     * @param string $locale [optional]
     * @return IntlBreakIterator|null
     */
    #[TentativeType]
    public static function createLineInstance(#[LanguageAware(['8.0' => 'string|null'], default: '')] $locale): ?IntlBreakIterator {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for sentence breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createsentenceinstance.php
     * @param string $locale [optional]
     * @return IntlBreakIterator|null
     */
    #[TentativeType]
    public static function createSentenceInstance(#[LanguageAware(['8.0' => 'string|null'], default: '')] $locale): ?IntlBreakIterator {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for title-casing breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createtitleinstance.php
     * @param string $locale [optional]
     * @return IntlBreakIterator|null
     */
    #[TentativeType]
    public static function createTitleInstance(#[LanguageAware(['8.0' => 'string|null'], default: '')] $locale): ?IntlBreakIterator {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for word breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createwordinstance.php
     * @param string $locale [optional]
     * @return IntlBreakIterator|null
     */
    #[TentativeType]
    public static function createWordInstance(#[LanguageAware(['8.0' => 'string|null'], default: '')] $locale): ?IntlBreakIterator {}

    /**
     * (PHP 5 >=5.5.0)

     * Get index of current position
     * @link https://secure.php.net/manual/en/intlbreakiterator.current.php
     * @return int
     */
    #[Pure]
    #[TentativeType]
    public function current(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Set position to the first character in the text
     * @link https://secure.php.net/manual/en/intlbreakiterator.first.php
     */
    #[TentativeType]
    public function first(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Advance the iterator to the first boundary following specified offset
     * @link https://secure.php.net/manual/en/intlbreakiterator.following.php
     * @param int $offset
     */
    #[TentativeType]
    public function following(#[LanguageAware(['8.0' => 'int'], default: '')] $offset): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Get last error code on the object
     * @link https://secure.php.net/manual/en/intlbreakiterator.geterrorcode.php
     * @return int
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Get last error message on the object
     * @link https://secure.php.net/manual/en/intlbreakiterator.geterrormessage.php
     * @return string
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): string {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the locale associated with the object
     * @link https://secure.php.net/manual/en/intlbreakiterator.getlocale.php
     * @param string $type
     */
    #[Pure]
    #[TentativeType]
    public function getLocale(#[LanguageAware(['8.0' => 'int'], default: '')] $type): string|false {}

    /**
     * (PHP 5 >=5.5.0)

     * Create iterator for navigating fragments between boundaries
     * @link https://secure.php.net/manual/en/intlbreakiterator.getpartsiterator.php
     * @param int $type [optional]
     * 

     * Optional key type. Possible values are:
     * 

     * 

     * {@see IntlPartsIterator::KEY_SEQUENTIAL}
     * - The default. Sequentially increasing integers used as key.
     * 
     * 

     * {@see IntlPartsIterator::KEY_LEFT}
     * - Byte offset left of current part used as key.
     * 
     * 

     * {@see IntlPartsIterator::KEY_RIGHT}
     * - Byte offset right of current part used as key.
     * 
     * 
     */
    #[Pure]
    #[TentativeType]
    public function getPartsIterator(
        #[LanguageAware(['8.3' => 'string', '8.0' => 'int'], default: '')] #[EV([IntlPartsIterator::KEY_SEQUENTIAL, IntlPartsIterator::KEY_LEFT, IntlPartsIterator::KEY_RIGHT])] $type = IntlPartsIterator::KEY_SEQUENTIAL
    ): IntlPartsIterator {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the text being scanned
     * @link https://secure.php.net/manual/en/intlbreakiterator.gettext.php
     */
    #[Pure]
    #[TentativeType]
    public function getText(): ?string {}

    /**
     * (PHP 5 >=5.5.0)

     * Tell whether an offset is a boundary's offset
     * @link https://secure.php.net/manual/en/intlbreakiterator.isboundary.php
     * @param int $offset
     */
    #[Pure]
    #[TentativeType]
    public function isBoundary(#[LanguageAware(['8.0' => 'int'], default: '')] $offset): bool {}

    /**
     * (PHP 5 >=5.5.0)

     * Set the iterator position to index beyond the last character
     * @link https://secure.php.net/manual/en/intlbreakiterator.last.php
     * @return int
     */
    #[TentativeType]
    public function last(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * @link https://secure.php.net/manual/en/intlbreakiterator.next.php
     * @param int $offset [optional]
     * @return int
     */
    #[TentativeType]
    public function next(#[LanguageAware(['8.0' => 'int|null'], default: '')] $offset = null): int {}

    /**
     * (PHP 5 >=5.5.0)

     * @link https://secure.php.net/manual/en/intlbreakiterator.preceding.php
     * @param int $offset
     */
    #[TentativeType]
    public function preceding(#[LanguageAware(['8.0' => 'int'], default: '')] $offset): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Set the iterator position to the boundary immediately before the current
     * @link https://secure.php.net/manual/en/intlbreakiterator.previous.php
     * @return int
     */
    #[TentativeType]
    public function previous(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Set the text being scanned
     * @link https://secure.php.net/manual/en/intlbreakiterator.settext.php
     * @param string $text
     */
    #[TentativeType]
    #[LanguageAware(['8.3' => 'bool'], default: 'bool|null')]
    public function setText(#[LanguageAware(['8.0' => 'string'], default: '')] $text) {}

    /**
     * @since 8.0
     * @return Iterator
     */
    #[Pure]
    public function getIterator(): Iterator {}
}

class IntlRuleBasedBreakIterator extends IntlBreakIterator implements Traversable
{
    /* Methods */
    /**
     * (PHP 5 >=5.5.0)

     * @link https://secure.php.net/manual/en/intlbreakiterator.construct.php
     * @param string $rules
     * @param string $compiled [optional]
     */
    #[Pure]
    public function __construct(
        #[LanguageAware(['8.0' => 'string'], default: '')] $rules,
        #[LanguageAware(['8.0' => 'bool'], default: '')] $compiled = false
    ) {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for boundaries of combining character sequences
     * @link https://secure.php.net/manual/en/intlbreakiterator.createcharacterinstance.php
     * @param string $locale
     * @return IntlRuleBasedBreakIterator
     */
    public static function createCharacterInstance($locale) {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for boundaries of code points
     * @link https://secure.php.net/manual/en/intlbreakiterator.createcodepointinstance.php
     * @return IntlRuleBasedBreakIterator
     */
    public static function createCodePointInstance() {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for logically possible line breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createlineinstance.php
     * @param string $locale [optional]
     * @return IntlRuleBasedBreakIterator
     */
    public static function createLineInstance($locale) {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for sentence breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createsentenceinstance.php
     * @param string $locale [optional]
     * @return IntlRuleBasedBreakIterator
     */
    public static function createSentenceInstance($locale) {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for title-casing breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createtitleinstance.php
     * @param string $locale [optional]
     * @return IntlRuleBasedBreakIterator
     */
    public static function createTitleInstance($locale) {}

    /**
     * (PHP 5 >=5.5.0)

     * Create break iterator for word breaks
     * @link https://secure.php.net/manual/en/intlbreakiterator.createwordinstance.php
     * @param string $locale [optional]
     * @return IntlRuleBasedBreakIterator
     */
    public static function createWordInstance($locale) {}

    /**
     * (PHP 5 >=5.5.0)

     * @link https://secure.php.net/manual/en/intlrulebasedbreakiterator.getbinaryrules.php
     * Get the binary form of compiled rules
     * @return string|false
     */
    #[Pure]
    #[TentativeType]
    public function getBinaryRules(): string|false {}

    /**
     * (PHP 5 >=5.5.0)

     * @link https://secure.php.net/manual/en/intlrulebasedbreakiterator.getrules.php
     * Get the rule set used to create this object
     * @return string|false
     */
    #[Pure]
    #[TentativeType]
    public function getRules(): string|false {}

    /**
     * (PHP 5 >=5.5.0)

     * @link https://secure.php.net/manual/en/intlrulebasedbreakiterator.getrulesstatus.php
     * Get the largest status value from the break rules that determined the current break position
     * @return int
     */
    #[Pure]
    #[TentativeType]
    public function getRuleStatus(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * @link https://secure.php.net/manual/en/intlrulebasedbreakiterator.getrulestatusvec.php
     * Get the status values from the break rules that determined the current break position
     * @return array|false
     */
    #[Pure]
    #[TentativeType]
    public function getRuleStatusVec(): array|false {}
}

/**
 * @link https://www.php.net/manual/en/class.intlpartsiterator.php
 * @since 5.5
 */
class IntlPartsIterator extends IntlIterator implements Iterator
{
    public const KEY_SEQUENTIAL = 0;
    public const KEY_LEFT = 1;
    public const KEY_RIGHT = 2;

    /**
     * @return IntlBreakIterator
     */
    #[Pure]
    #[TentativeType]
    public function getBreakIterator(): IntlBreakIterator {}

    /**
     * @since 8.1
     */
    #[TentativeType]
    public function getRuleStatus(): int {}
}

class IntlCodePointBreakIterator extends IntlBreakIterator implements Traversable
{
    /**
     * (PHP 5 >=5.5.0)

     * Get last code point passed over after advancing or receding the iterator
     * @link https://secure.php.net/manual/en/intlcodepointbreakiterator.getlastcodepoint.php
     * @return int
     */
    #[Pure]
    #[TentativeType]
    public function getLastCodePoint(): int {}
}

class UConverter
{
    /* Constants */
    public const REASON_UNASSIGNED = 0;
    public const REASON_ILLEGAL = 1;
    public const REASON_IRREGULAR = 2;
    public const REASON_RESET = 3;
    public const REASON_CLOSE = 4;
    public const REASON_CLONE = 5;
    public const UNSUPPORTED_CONVERTER = -1;
    public const SBCS = 0;
    public const DBCS = 1;
    public const MBCS = 2;
    public const LATIN_1 = 3;
    public const UTF8 = 4;
    public const UTF16_BigEndian = 5;
    public const UTF16_LittleEndian = 6;
    public const UTF32_BigEndian = 7;
    public const UTF32_LittleEndian = 8;
    public const EBCDIC_STATEFUL = 9;
    public const ISO_2022 = 10;
    public const LMBCS_1 = 11;
    public const LMBCS_2 = 12;
    public const LMBCS_3 = 13;
    public const LMBCS_4 = 14;
    public const LMBCS_5 = 15;
    public const LMBCS_6 = 16;
    public const LMBCS_8 = 17;
    public const LMBCS_11 = 18;
    public const LMBCS_16 = 19;
    public const LMBCS_17 = 20;
    public const LMBCS_18 = 21;
    public const LMBCS_19 = 22;
    public const LMBCS_LAST = 22;
    public const HZ = 23;
    public const SCSU = 24;
    public const ISCII = 25;
    public const US_ASCII = 26;
    public const UTF7 = 27;
    public const BOCU1 = 28;
    public const UTF16 = 29;
    public const UTF32 = 30;
    public const CESU8 = 31;
    public const IMAP_MAILBOX = 32;

    /* Methods */
    /**
     * (PHP 5 >=5.5.0)

     * Create UConverter object
     * @link https://php.net/manual/en/uconverter.construct.php
     * @param string $destination_encoding
     * @param string $source_encoding
     */
    #[Pure]
    public function __construct(
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $destination_encoding = null,
        #[LanguageAware(['8.0' => 'string|null'], default: '')] $source_encoding = null
    ) {}

    /**
     * (PHP 5 >=5.5.0)

     * Convert string from one charset to anothe
     * @link https://php.net/manual/en/uconverter.convert.php
     * @param string $str
     * @param bool $reverse [optional]
     * @return string|false
     */
    #[Pure]
    #[TentativeType]
    public function convert(
        #[LanguageAware(['8.0' => 'string'], default: '')] $str,
        #[LanguageAware(['8.0' => 'bool'], default: '')] $reverse = false
    ): string|false {}

    /**
     * (PHP 5 >=5.5.0)

     * Default "from" callback function
     * @link https://php.net/manual/en/uconverter.fromucallback.php
     * @param int $reason
     * @param string $source
     * @param string $codePoint
     * @param int &$error
     * @return array|string|int|null
     */
    #[TentativeType]
    public function fromUCallback(
        #[LanguageAware(['8.0' => 'int'], default: '')] $reason,
        #[LanguageAware(['8.0' => 'array'], default: '')] $source,
        #[LanguageAware(['8.0' => 'int'], default: '')] $codePoint,
        &$error
    ): array|string|int|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the aliases of the given name
     * @link https://php.net/manual/en/uconverter.getaliases.php
     * @param string $name
     * @return array|false|null
     */
    #[TentativeType]
    public static function getAliases(
        #[ElementAvailable(from: '5.5', to: '5.6')] $name = '',
        #[ElementAvailable(from: '7.0')] #[LanguageAware(['8.0' => 'string'], default: '')] $name
    ): array|false|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the available canonical converter names
     * @link https://php.net/manual/en/uconverter.getavailable.php
     * @return array
     */
    #[TentativeType]
    public static function getAvailable(): array {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the destination encoding
     * @link https://php.net/manual/en/uconverter.getdestinationencoding.php
     * @return string|false|null
     */
    #[Pure]
    #[TentativeType]
    public function getDestinationEncoding(): string|false|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the destination converter type
     * @link https://php.net/manual/en/uconverter.getdestinationtype.php
     * @return int|false|null
     */
    #[Pure]
    #[TentativeType]
    public function getDestinationType(): int|false|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Get last error code on the object
     * @link https://php.net/manual/en/uconverter.geterrorcode.php
     * @return int
     */
    #[Pure]
    #[TentativeType]
    public function getErrorCode(): int {}

    /**
     * (PHP 5 >=5.5.0)

     * Get last error message on the object
     * @link https://php.net/manual/en/uconverter.geterrormessage.php
     * @return string|null
     */
    #[Pure]
    #[TentativeType]
    public function getErrorMessage(): ?string {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the source encoding
     * @link https://php.net/manual/en/uconverter.getsourceencoding.php
     * @return string|false|null
     */
    #[Pure]
    #[TentativeType]
    public function getSourceEncoding(): string|false|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Get the source convertor type
     * @link https://php.net/manual/en/uconverter.getsourcetype.php
     * @return int|false|null
     */
    #[Pure]
    #[TentativeType]
    public function getSourceType(): int|false|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Get standards associated to converter names
     * @link https://php.net/manual/en/uconverter.getstandards.php
     * @return array|null
     */
    #[Pure]
    #[TentativeType]
    public static function getStandards(): ?array {}

    /**
     * (PHP 5 >=5.5.0)

     * Get substitution chars
     * @link https://php.net/manual/en/uconverter.getsubstchars.php
     * @return string|false|null
     */
    #[Pure]
    #[TentativeType]
    public function getSubstChars(): string|false|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Get string representation of the callback reason
     * @link https://php.net/manual/en/uconverter.reasontext.php
     * @param int $reason
     * @return string
     */
    #[Pure]
    #[TentativeType]
    public static function reasonText(
        #[ElementAvailable(from: '5.3', to: '7.4')] $reason = 0,
        #[ElementAvailable(from: '8.0')] int $reason
    ): string {}

    /**
     * (PHP 5 >=5.5.0)

     * Set the destination encoding
     * @link https://php.net/manual/en/uconverter.setdestinationencoding.php
     * @param string $encoding
     * @return bool
     */
    #[TentativeType]
    public function setDestinationEncoding(#[LanguageAware(['8.0' => 'string'], default: '')] $encoding): bool {}

    /**
     * (PHP 5 >=5.5.0)

     * Set the source encoding
     * @link https://php.net/manual/en/uconverter.setsourceencoding.php
     * @param string $encoding
     * @return bool
     */
    #[TentativeType]
    public function setSourceEncoding(#[LanguageAware(['8.0' => 'string'], default: '')] $encoding): bool {}

    /**
     * (PHP 5 >=5.5.0)

     * Set the substitution chars
     * @link https://php.net/manual/en/uconverter.setsubstchars.php
     * @param string $chars
     * @return bool
     */
    #[TentativeType]
    public function setSubstChars(#[LanguageAware(['8.0' => 'string'], default: '')] $chars): bool {}

    /**
     * (PHP 5 >=5.5.0)

     * Default "to" callback function
     * @link https://php.net/manual/en/uconverter.toucallback.php
     * @param int $reason
     * @param string $source
     * @param string $codeUnits
     * @param int &$error
     * @return array|string|int|null
     */
    #[TentativeType]
    public function toUCallback(
        #[LanguageAware(['8.0' => 'int'], default: '')] $reason,
        #[LanguageAware(['8.0' => 'string'], default: '')] $source,
        #[LanguageAware(['8.0' => 'string'], default: '')] $codeUnits,
        &$error
    ): array|string|int|null {}

    /**
     * (PHP 5 >=5.5.0)

     * Convert string from one charset to another
     * @link https://php.net/manual/en/uconverter.transcode.php
     * @param string $str
     * @param string $toEncoding
     * @param string $fromEncoding
     * @param array|null $options
     * @return string|false
     */
    #[TentativeType]
    public static function transcode(
        #[LanguageAware(['8.0' => 'string'], default: '')] $str,
        #[LanguageAware(['8.0' => 'string'], default: '')] $toEncoding,
        #[LanguageAware(['8.0' => 'string'], default: '')] $fromEncoding,
        #[LanguageAware(['8.0' => 'array|null'], default: '')] $options = null
    ): string|false {}
}
// End of intl v.1.1.0
Makes an exact copy of the Imagick object
 * @link https://php.net/manual/en/class.imagick.php
 */
class Imagick implements Iterator, Countable
{
    public const COLOR_BLACK = 11;
    public const COLOR_BLUE = 12;
    public const COLOR_CYAN = 13;
    public const COLOR_GREEN = 14;
    public const COLOR_RED = 15;
    public const COLOR_YELLOW = 16;
    public const COLOR_MAGENTA = 17;
    public const COLOR_OPACITY = 18;
    public const COLOR_ALPHA = 19;
    public const COLOR_FUZZ = 20;
    public const IMAGICK_EXTNUM = 30403;
    public const IMAGICK_EXTVER = "3.4.3";
    public const QUANTUM_RANGE = 65535;
    public const USE_ZEND_MM = 0;
    public const COMPOSITE_DEFAULT = 40;
    public const COMPOSITE_UNDEFINED = 0;
    public const COMPOSITE_NO = 1;
    public const COMPOSITE_ADD = 2;
    public const COMPOSITE_ATOP = 3;
    public const COMPOSITE_BLEND = 4;
    public const COMPOSITE_BUMPMAP = 5;
    public const COMPOSITE_CLEAR = 7;
    public const COMPOSITE_COLORBURN = 8;
    public const COMPOSITE_COLORDODGE = 9;
    public const COMPOSITE_COLORIZE = 10;
    public const COMPOSITE_COPYBLACK = 11;
    public const COMPOSITE_COPYBLUE = 12;
    public const COMPOSITE_COPY = 13;
    public const COMPOSITE_COPYCYAN = 14;
    public const COMPOSITE_COPYGREEN = 15;
    public const COMPOSITE_COPYMAGENTA = 16;
    public const COMPOSITE_COPYOPACITY = 17;
    public const COMPOSITE_COPYRED = 18;
    public const COMPOSITE_COPYYELLOW = 19;
    public const COMPOSITE_DARKEN = 20;
    public const COMPOSITE_DSTATOP = 21;
    public const COMPOSITE_DST = 22;
    public const COMPOSITE_DSTIN = 23;
    public const COMPOSITE_DSTOUT = 24;
    public const COMPOSITE_DSTOVER = 25;
    public const COMPOSITE_DIFFERENCE = 26;
    public const COMPOSITE_DISPLACE = 27;
    public const COMPOSITE_DISSOLVE = 28;
    public const COMPOSITE_EXCLUSION = 29;
    public const COMPOSITE_HARDLIGHT = 30;
    public const COMPOSITE_HUE = 31;
    public const COMPOSITE_IN = 32;
    public const COMPOSITE_LIGHTEN = 33;
    public const COMPOSITE_LUMINIZE = 35;
    public const COMPOSITE_MINUS = 36;
    public const COMPOSITE_MODULATE = 37;
    public const COMPOSITE_MULTIPLY = 38;
    public const COMPOSITE_OUT = 39;
    public const COMPOSITE_OVER = 40;
    public const COMPOSITE_OVERLAY = 41;
    public const COMPOSITE_PLUS = 42;
    public const COMPOSITE_REPLACE = 43;
    public const COMPOSITE_SATURATE = 44;
    public const COMPOSITE_SCREEN = 45;
    public const COMPOSITE_SOFTLIGHT = 46;
    public const COMPOSITE_SRCATOP = 47;
    public const COMPOSITE_SRC = 48;
    public const COMPOSITE_SRCIN = 49;
    public const COMPOSITE_SRCOUT = 50;
    public const COMPOSITE_SRCOVER = 51;
    public const COMPOSITE_SUBTRACT = 52;
    public const COMPOSITE_THRESHOLD = 53;
    public const COMPOSITE_XOR = 54;
    public const COMPOSITE_CHANGEMASK = 6;
    public const COMPOSITE_LINEARLIGHT = 34;
    public const COMPOSITE_DIVIDE = 55;
    public const COMPOSITE_DISTORT = 56;
    public const COMPOSITE_BLUR = 57;
    public const COMPOSITE_PEGTOPLIGHT = 58;
    public const COMPOSITE_VIVIDLIGHT = 59;
    public const COMPOSITE_PINLIGHT = 60;
    public const COMPOSITE_LINEARDODGE = 61;
    public const COMPOSITE_LINEARBURN = 62;
    public const COMPOSITE_MATHEMATICS = 63;
    public const COMPOSITE_MODULUSADD = 2;
    public const COMPOSITE_MODULUSSUBTRACT = 52;
    public const COMPOSITE_MINUSDST = 36;
    public const COMPOSITE_DIVIDEDST = 55;
    public const COMPOSITE_DIVIDESRC = 64;
    public const COMPOSITE_MINUSSRC = 65;
    public const COMPOSITE_DARKENINTENSITY = 66;
    public const COMPOSITE_LIGHTENINTENSITY = 67;
    public const MONTAGEMODE_FRAME = 1;
    public const MONTAGEMODE_UNFRAME = 2;
    public const MONTAGEMODE_CONCATENATE = 3;
    public const STYLE_NORMAL = 1;
    public const STYLE_ITALIC = 2;
    public const STYLE_OBLIQUE = 3;
    public const STYLE_ANY = 4;
    public const FILTER_UNDEFINED = 0;
    public const FILTER_POINT = 1;
    public const FILTER_BOX = 2;
    public const FILTER_TRIANGLE = 3;
    public const FILTER_HERMITE = 4;
    public const FILTER_HANNING = 5;
    public const FILTER_HAMMING = 6;
    public const FILTER_BLACKMAN = 7;
    public const FILTER_GAUSSIAN = 8;
    public const FILTER_QUADRATIC = 9;
    public const FILTER_CUBIC = 10;
    public const FILTER_CATROM = 11;
    public const FILTER_MITCHELL = 12;
    public const FILTER_LANCZOS = 22;
    public const FILTER_BESSEL = 13;
    public const FILTER_SINC = 14;
    public const FILTER_KAISER = 16;
    public const FILTER_WELSH = 17;
    public const FILTER_PARZEN = 18;
    public const FILTER_LAGRANGE = 21;
    public const FILTER_SENTINEL = 31;
    public const FILTER_BOHMAN = 19;
    public const FILTER_BARTLETT = 20;
    public const FILTER_JINC = 13;
    public const FILTER_SINCFAST = 15;
    public const FILTER_ROBIDOUX = 26;
    public const FILTER_LANCZOSSHARP = 23;
    public const FILTER_LANCZOS2 = 24;
    public const FILTER_LANCZOS2SHARP = 25;
    public const FILTER_ROBIDOUXSHARP = 27;
    public const FILTER_COSINE = 28;
    public const FILTER_SPLINE = 29;
    public const FILTER_LANCZOSRADIUS = 30;
    public const IMGTYPE_UNDEFINED = 0;
    public const IMGTYPE_BILEVEL = 1;
    public const IMGTYPE_GRAYSCALE = 2;
    public const IMGTYPE_GRAYSCALEMATTE = 3;
    public const IMGTYPE_PALETTE = 4;
    public const IMGTYPE_PALETTEMATTE = 5;
    public const IMGTYPE_TRUECOLOR = 6;
    public const IMGTYPE_TRUECOLORMATTE = 7;
    public const IMGTYPE_COLORSEPARATION = 8;
    public const IMGTYPE_COLORSEPARATIONMATTE = 9;
    public const IMGTYPE_OPTIMIZE = 10;
    public const IMGTYPE_PALETTEBILEVELMATTE = 11;
    public const RESOLUTION_UNDEFINED = 0;
    public const RESOLUTION_PIXELSPERINCH = 1;
    public const RESOLUTION_PIXELSPERCENTIMETER = 2;
    public const COMPRESSION_UNDEFINED = 0;
    public const COMPRESSION_NO = 1;
    public const COMPRESSION_BZIP = 2;
    public const COMPRESSION_FAX = 6;
    public const COMPRESSION_GROUP4 = 7;
    public const COMPRESSION_JPEG = 8;
    public const COMPRESSION_JPEG2000 = 9;
    public const COMPRESSION_LOSSLESSJPEG = 10;
    public const COMPRESSION_LZW = 11;
    public const COMPRESSION_RLE = 12;
    public const COMPRESSION_ZIP = 13;
    public const COMPRESSION_DXT1 = 3;
    public const COMPRESSION_DXT3 = 4;
    public const COMPRESSION_DXT5 = 5;
    public const COMPRESSION_ZIPS = 14;
    public const COMPRESSION_PIZ = 15;
    public const COMPRESSION_PXR24 = 16;
    public const COMPRESSION_B44 = 17;
    public const COMPRESSION_B44A = 18;
    public const COMPRESSION_LZMA = 19;
    public const COMPRESSION_JBIG1 = 20;
    public const COMPRESSION_JBIG2 = 21;
    public const PAINT_POINT = 1;
    public const PAINT_REPLACE = 2;
    public const PAINT_FLOODFILL = 3;
    public const PAINT_FILLTOBORDER = 4;
    public const PAINT_RESET = 5;
    public const GRAVITY_NORTHWEST = 1;
    public const GRAVITY_NORTH = 2;
    public const GRAVITY_NORTHEAST = 3;
    public const GRAVITY_WEST = 4;
    public const GRAVITY_CENTER = 5;
    public const GRAVITY_EAST = 6;
    public const GRAVITY_SOUTHWEST = 7;
    public const GRAVITY_SOUTH = 8;
    public const GRAVITY_SOUTHEAST = 9;
    public const GRAVITY_FORGET = 0;
    public const GRAVITY_STATIC = 10;
    public const STRETCH_NORMAL = 1;
    public const STRETCH_ULTRACONDENSED = 2;
    public const STRETCH_EXTRACONDENSED = 3;
    public const STRETCH_CONDENSED = 4;
    public const STRETCH_SEMICONDENSED = 5;
    public const STRETCH_SEMIEXPANDED = 6;
    public const STRETCH_EXPANDED = 7;
    public const STRETCH_EXTRAEXPANDED = 8;
    public const STRETCH_ULTRAEXPANDED = 9;
    public const STRETCH_ANY = 10;
    public const ALIGN_UNDEFINED = 0;
    public const ALIGN_LEFT = 1;
    public const ALIGN_CENTER = 2;
    public const ALIGN_RIGHT = 3;
    public const DECORATION_NO = 1;
    public const DECORATION_UNDERLINE = 2;
    public const DECORATION_OVERLINE = 3;
    public const DECORATION_LINETROUGH = 4;
    public const DECORATION_LINETHROUGH = 4;
    public const NOISE_UNIFORM = 1;
    public const NOISE_GAUSSIAN = 2;
    public const NOISE_MULTIPLICATIVEGAUSSIAN = 3;
    public const NOISE_IMPULSE = 4;
    public const NOISE_LAPLACIAN = 5;
    public const NOISE_POISSON = 6;
    public const NOISE_RANDOM = 7;
    public const CHANNEL_UNDEFINED = 0;
    public const CHANNEL_RED = 1;
    public const CHANNEL_GRAY = 1;
    public const CHANNEL_CYAN = 1;
    public const CHANNEL_GREEN = 2;
    public const CHANNEL_MAGENTA = 2;
    public const CHANNEL_BLUE = 4;
    public const CHANNEL_YELLOW = 4;
    public const CHANNEL_ALPHA = 8;
    public const CHANNEL_OPACITY = 8;
    public const CHANNEL_MATTE = 8;
    public const CHANNEL_BLACK = 32;
    public const CHANNEL_INDEX = 32;
    public const CHANNEL_ALL = 134217727;
    public const CHANNEL_DEFAULT = 134217719;
    public const CHANNEL_RGBA = 15;
    public const CHANNEL_TRUEALPHA = 64;
    public const CHANNEL_RGBS = 128;
    public const CHANNEL_GRAY_CHANNELS = 128;
    public const CHANNEL_SYNC = 256;
    public const CHANNEL_COMPOSITES = 47;
    public const METRIC_UNDEFINED = 0;
    public const METRIC_ABSOLUTEERRORMETRIC = 1;
    public const METRIC_MEANABSOLUTEERROR = 2;
    public const METRIC_MEANERRORPERPIXELMETRIC = 3;
    public const METRIC_MEANSQUAREERROR = 4;
    public const METRIC_PEAKABSOLUTEERROR = 5;
    public const METRIC_PEAKSIGNALTONOISERATIO = 6;
    public const METRIC_ROOTMEANSQUAREDERROR = 7;
    public const METRIC_NORMALIZEDCROSSCORRELATIONERRORMETRIC = 8;
    public const METRIC_FUZZERROR = 9;
    public const PIXEL_CHAR = 1;
    public const PIXEL_DOUBLE = 2;
    public const PIXEL_FLOAT = 3;
    public const PIXEL_INTEGER = 4;
    public const PIXEL_LONG = 5;
    public const PIXEL_QUANTUM = 6;
    public const PIXEL_SHORT = 7;
    public const EVALUATE_UNDEFINED = 0;
    public const EVALUATE_ADD = 1;
    public const EVALUATE_AND = 2;
    public const EVALUATE_DIVIDE = 3;
    public const EVALUATE_LEFTSHIFT = 4;
    public const EVALUATE_MAX = 5;
    public const EVALUATE_MIN = 6;
    public const EVALUATE_MULTIPLY = 7;
    public const EVALUATE_OR = 8;
    public const EVALUATE_RIGHTSHIFT = 9;
    public const EVALUATE_SET = 10;
    public const EVALUATE_SUBTRACT = 11;
    public const EVALUATE_XOR = 12;
    public const EVALUATE_POW = 13;
    public const EVALUATE_LOG = 14;
    public const EVALUATE_THRESHOLD = 15;
    public const EVALUATE_THRESHOLDBLACK = 16;
    public const EVALUATE_THRESHOLDWHITE = 17;
    public const EVALUATE_GAUSSIANNOISE = 18;
    public const EVALUATE_IMPULSENOISE = 19;
    public const EVALUATE_LAPLACIANNOISE = 20;
    public const EVALUATE_MULTIPLICATIVENOISE = 21;
    public const EVALUATE_POISSONNOISE = 22;
    public const EVALUATE_UNIFORMNOISE = 23;
    public const EVALUATE_COSINE = 24;
    public const EVALUATE_SINE = 25;
    public const EVALUATE_ADDMODULUS = 26;
    public const EVALUATE_MEAN = 27;
    public const EVALUATE_ABS = 28;
    public const EVALUATE_EXPONENTIAL = 29;
    public const EVALUATE_MEDIAN = 30;
    public const EVALUATE_SUM = 31;
    public const COLORSPACE_UNDEFINED = 0;
    public const COLORSPACE_RGB = 1;
    public const COLORSPACE_GRAY = 2;
    public const COLORSPACE_TRANSPARENT = 3;
    public const COLORSPACE_OHTA = 4;
    public const COLORSPACE_LAB = 5;
    public const COLORSPACE_XYZ = 6;
    public const COLORSPACE_YCBCR = 7;
    public const COLORSPACE_YCC = 8;
    public const COLORSPACE_YIQ = 9;
    public const COLORSPACE_YPBPR = 10;
    public const COLORSPACE_YUV = 11;
    public const COLORSPACE_CMYK = 12;
    public const COLORSPACE_SRGB = 13;
    public const COLORSPACE_HSB = 14;
    public const COLORSPACE_HSL = 15;
    public const COLORSPACE_HWB = 16;
    public const COLORSPACE_REC601LUMA = 17;
    public const COLORSPACE_REC709LUMA = 19;
    public const COLORSPACE_LOG = 21;
    public const COLORSPACE_CMY = 22;
    public const COLORSPACE_LUV = 23;
    public const COLORSPACE_HCL = 24;
    public const COLORSPACE_LCH = 25;
    public const COLORSPACE_LMS = 26;
    public const COLORSPACE_LCHAB = 27;
    public const COLORSPACE_LCHUV = 28;
    public const COLORSPACE_SCRGB = 29;
    public const COLORSPACE_HSI = 30;
    public const COLORSPACE_HSV = 31;
    public const COLORSPACE_HCLP = 32;
    public const COLORSPACE_YDBDR = 33;
    public const COLORSPACE_REC601YCBCR = 18;
    public const COLORSPACE_REC709YCBCR = 20;
    public const VIRTUALPIXELMETHOD_UNDEFINED = 0;
    public const VIRTUALPIXELMETHOD_BACKGROUND = 1;
    public const VIRTUALPIXELMETHOD_CONSTANT = 2;
    public const VIRTUALPIXELMETHOD_EDGE = 4;
    public const VIRTUALPIXELMETHOD_MIRROR = 5;
    public const VIRTUALPIXELMETHOD_TILE = 7;
    public const VIRTUALPIXELMETHOD_TRANSPARENT = 8;
    public const VIRTUALPIXELMETHOD_MASK = 9;
    public const VIRTUALPIXELMETHOD_BLACK = 10;
    public const VIRTUALPIXELMETHOD_GRAY = 11;
    public const VIRTUALPIXELMETHOD_WHITE = 12;
    public const VIRTUALPIXELMETHOD_HORIZONTALTILE = 13;
    public const VIRTUALPIXELMETHOD_VERTICALTILE = 14;
    public const VIRTUALPIXELMETHOD_HORIZONTALTILEEDGE = 15;
    public const VIRTUALPIXELMETHOD_VERTICALTILEEDGE = 16;
    public const VIRTUALPIXELMETHOD_CHECKERTILE = 17;
    public const PREVIEW_UNDEFINED = 0;
    public const PREVIEW_ROTATE = 1;
    public const PREVIEW_SHEAR = 2;
    public const PREVIEW_ROLL = 3;
    public const PREVIEW_HUE = 4;
    public const PREVIEW_SATURATION = 5;
    public const PREVIEW_BRIGHTNESS = 6;
    public const PREVIEW_GAMMA = 7;
    public const PREVIEW_SPIFF = 8;
    public const PREVIEW_DULL = 9;
    public const PREVIEW_GRAYSCALE = 10;
    public const PREVIEW_QUANTIZE = 11;
    public const PREVIEW_DESPECKLE = 12;
    public const PREVIEW_REDUCENOISE = 13;
    public const PREVIEW_ADDNOISE = 14;
    public const PREVIEW_SHARPEN = 15;
    public const PREVIEW_BLUR = 16;
    public const PREVIEW_THRESHOLD = 17;
    public const PREVIEW_EDGEDETECT = 18;
    public const PREVIEW_SPREAD = 19;
    public const PREVIEW_SOLARIZE = 20;
    public const PREVIEW_SHADE = 21;
    public const PREVIEW_RAISE = 22;
    public const PREVIEW_SEGMENT = 23;
    public const PREVIEW_SWIRL = 24;
    public const PREVIEW_IMPLODE = 25;
    public const PREVIEW_WAVE = 26;
    public const PREVIEW_OILPAINT = 27;
    public const PREVIEW_CHARCOALDRAWING = 28;
    public const PREVIEW_JPEG = 29;
    public const RENDERINGINTENT_UNDEFINED = 0;
    public const RENDERINGINTENT_SATURATION = 1;
    public const RENDERINGINTENT_PERCEPTUAL = 2;
    public const RENDERINGINTENT_ABSOLUTE = 3;
    public const RENDERINGINTENT_RELATIVE = 4;
    public const INTERLACE_UNDEFINED = 0;
    public const INTERLACE_NO = 1;
    public const INTERLACE_LINE = 2;
    public const INTERLACE_PLANE = 3;
    public const INTERLACE_PARTITION = 4;
    public const INTERLACE_GIF = 5;
    public const INTERLACE_JPEG = 6;
    public const INTERLACE_PNG = 7;
    public const FILLRULE_UNDEFINED = 0;
    public const FILLRULE_EVENODD = 1;
    public const FILLRULE_NONZERO = 2;
    public const PATHUNITS_UNDEFINED = 0;
    public const PATHUNITS_USERSPACE = 1;
    public const PATHUNITS_USERSPACEONUSE = 2;
    public const PATHUNITS_OBJECTBOUNDINGBOX = 3;
    public const LINECAP_UNDEFINED = 0;
    public const LINECAP_BUTT = 1;
    public const LINECAP_ROUND = 2;
    public const LINECAP_SQUARE = 3;
    public const LINEJOIN_UNDEFINED = 0;
    public const LINEJOIN_MITER = 1;
    public const LINEJOIN_ROUND = 2;
    public const LINEJOIN_BEVEL = 3;
    public const RESOURCETYPE_UNDEFINED = 0;
    public const RESOURCETYPE_AREA = 1;
    public const RESOURCETYPE_DISK = 2;
    public const RESOURCETYPE_FILE = 3;
    public const RESOURCETYPE_MAP = 4;
    public const RESOURCETYPE_MEMORY = 5;
    public const RESOURCETYPE_TIME = 7;
    public const RESOURCETYPE_THROTTLE = 8;
    public const RESOURCETYPE_THREAD = 6;
    public const DISPOSE_UNRECOGNIZED = 0;
    public const DISPOSE_UNDEFINED = 0;
    public const DISPOSE_NONE = 1;
    public const DISPOSE_BACKGROUND = 2;
    public const DISPOSE_PREVIOUS = 3;
    public const INTERPOLATE_UNDEFINED = 0;
    public const INTERPOLATE_AVERAGE = 1;
    public const INTERPOLATE_BICUBIC = 2;
    public const INTERPOLATE_BILINEAR = 3;
    public const INTERPOLATE_FILTER = 4;
    public const INTERPOLATE_INTEGER = 5;
    public const INTERPOLATE_MESH = 6;
    public const INTERPOLATE_NEARESTNEIGHBOR = 7;
    public const INTERPOLATE_SPLINE = 8;
    public const LAYERMETHOD_UNDEFINED = 0;
    public const LAYERMETHOD_COALESCE = 1;
    public const LAYERMETHOD_COMPAREANY = 2;
    public const LAYERMETHOD_COMPARECLEAR = 3;
    public const LAYERMETHOD_COMPAREOVERLAY = 4;
    public const LAYERMETHOD_DISPOSE = 5;
    public const LAYERMETHOD_OPTIMIZE = 6;
    public const LAYERMETHOD_OPTIMIZEPLUS = 8;
    public const LAYERMETHOD_OPTIMIZETRANS = 9;
    public const LAYERMETHOD_COMPOSITE = 12;
    public const LAYERMETHOD_OPTIMIZEIMAGE = 7;
    public const LAYERMETHOD_REMOVEDUPS = 10;
    public const LAYERMETHOD_REMOVEZERO = 11;
    public const LAYERMETHOD_TRIMBOUNDS = 16;
    public const ORIENTATION_UNDEFINED = 0;
    public const ORIENTATION_TOPLEFT = 1;
    public const ORIENTATION_TOPRIGHT = 2;
    public const ORIENTATION_BOTTOMRIGHT = 3;
    public const ORIENTATION_BOTTOMLEFT = 4;
    public const ORIENTATION_LEFTTOP = 5;
    public const ORIENTATION_RIGHTTOP = 6;
    public const ORIENTATION_RIGHTBOTTOM = 7;
    public const ORIENTATION_LEFTBOTTOM = 8;
    public const DISTORTION_UNDEFINED = 0;
    public const DISTORTION_AFFINE = 1;
    public const DISTORTION_AFFINEPROJECTION = 2;
    public const DISTORTION_ARC = 9;
    public const DISTORTION_BILINEAR = 6;
    public const DISTORTION_PERSPECTIVE = 4;
    public const DISTORTION_PERSPECTIVEPROJECTION = 5;
    public const DISTORTION_SCALEROTATETRANSLATE = 3;
    public const DISTORTION_POLYNOMIAL = 8;
    public const DISTORTION_POLAR = 10;
    public const DISTORTION_DEPOLAR = 11;
    public const DISTORTION_BARREL = 14;
    public const DISTORTION_SHEPARDS = 16;
    public const DISTORTION_SENTINEL = 18;
    public const DISTORTION_BARRELINVERSE = 15;
    public const DISTORTION_BILINEARFORWARD = 6;
    public const DISTORTION_BILINEARREVERSE = 7;
    public const DISTORTION_RESIZE = 17;
    public const DISTORTION_CYLINDER2PLANE = 12;
    public const DISTORTION_PLANE2CYLINDER = 13;
    public const LAYERMETHOD_MERGE = 13;
    public const LAYERMETHOD_FLATTEN = 14;
    public const LAYERMETHOD_MOSAIC = 15;
    public const ALPHACHANNEL_ACTIVATE = 1;
    public const ALPHACHANNEL_RESET = 7;
    public const ALPHACHANNEL_SET = 8;
    public const ALPHACHANNEL_UNDEFINED = 0;
    public const ALPHACHANNEL_COPY = 3;
    public const ALPHACHANNEL_DEACTIVATE = 4;
    public const ALPHACHANNEL_EXTRACT = 5;
    public const ALPHACHANNEL_OPAQUE = 6;
    public const ALPHACHANNEL_SHAPE = 9;
    public const ALPHACHANNEL_TRANSPARENT = 10;
    public const SPARSECOLORMETHOD_UNDEFINED = 0;
    public const SPARSECOLORMETHOD_BARYCENTRIC = 1;
    public const SPARSECOLORMETHOD_BILINEAR = 7;
    public const SPARSECOLORMETHOD_POLYNOMIAL = 8;
    public const SPARSECOLORMETHOD_SPEPARDS = 16;
    public const SPARSECOLORMETHOD_VORONOI = 18;
    public const SPARSECOLORMETHOD_INVERSE = 19;
    public const DITHERMETHOD_UNDEFINED = 0;
    public const DITHERMETHOD_NO = 1;
    public const DITHERMETHOD_RIEMERSMA = 2;
    public const DITHERMETHOD_FLOYDSTEINBERG = 3;
    public const FUNCTION_UNDEFINED = 0;
    public const FUNCTION_POLYNOMIAL = 1;
    public const FUNCTION_SINUSOID = 2;
    public const ALPHACHANNEL_BACKGROUND = 2;
    public const FUNCTION_ARCSIN = 3;
    public const FUNCTION_ARCTAN = 4;
    public const ALPHACHANNEL_FLATTEN = 11;
    public const ALPHACHANNEL_REMOVE = 12;
    public const STATISTIC_GRADIENT = 1;
    public const STATISTIC_MAXIMUM = 2;
    public const STATISTIC_MEAN = 3;
    public const STATISTIC_MEDIAN = 4;
    public const STATISTIC_MINIMUM = 5;
    public const STATISTIC_MODE = 6;
    public const STATISTIC_NONPEAK = 7;
    public const STATISTIC_STANDARD_DEVIATION = 8;
    public const MORPHOLOGY_CONVOLVE = 1;
    public const MORPHOLOGY_CORRELATE = 2;
    public const MORPHOLOGY_ERODE = 3;
    public const MORPHOLOGY_DILATE = 4;
    public const MORPHOLOGY_ERODE_INTENSITY = 5;
    public const MORPHOLOGY_DILATE_INTENSITY = 6;
    public const MORPHOLOGY_DISTANCE = 7;
    public const MORPHOLOGY_OPEN = 8;
    public const MORPHOLOGY_CLOSE = 9;
    public const MORPHOLOGY_OPEN_INTENSITY = 10;
    public const MORPHOLOGY_CLOSE_INTENSITY = 11;
    public const MORPHOLOGY_SMOOTH = 12;
    public const MORPHOLOGY_EDGE_IN = 13;
    public const MORPHOLOGY_EDGE_OUT = 14;
    public const MORPHOLOGY_EDGE = 15;
    public const MORPHOLOGY_TOP_HAT = 16;
    public const MORPHOLOGY_BOTTOM_HAT = 17;
    public const MORPHOLOGY_HIT_AND_MISS = 18;
    public const MORPHOLOGY_THINNING = 19;
    public const MORPHOLOGY_THICKEN = 20;
    public const MORPHOLOGY_VORONOI = 21;
    public const MORPHOLOGY_ITERATIVE = 22;
    public const KERNEL_UNITY = 1;
    public const KERNEL_GAUSSIAN = 2;
    public const KERNEL_DIFFERENCE_OF_GAUSSIANS = 3;
    public const KERNEL_LAPLACIAN_OF_GAUSSIANS = 4;
    public const KERNEL_BLUR = 5;
    public const KERNEL_COMET = 6;
    public const KERNEL_LAPLACIAN = 7;
    public const KERNEL_SOBEL = 8;
    public const KERNEL_FREI_CHEN = 9;
    public const KERNEL_ROBERTS = 10;
    public const KERNEL_PREWITT = 11;
    public const KERNEL_COMPASS = 12;
    public const KERNEL_KIRSCH = 13;
    public const KERNEL_DIAMOND = 14;
    public const KERNEL_SQUARE = 15;
    public const KERNEL_RECTANGLE = 16;
    public const KERNEL_OCTAGON = 17;
    public const KERNEL_DISK = 18;
    public const KERNEL_PLUS = 19;
    public const KERNEL_CROSS = 20;
    public const KERNEL_RING = 21;
    public const KERNEL_PEAKS = 22;
    public const KERNEL_EDGES = 23;
    public const KERNEL_CORNERS = 24;
    public const KERNEL_DIAGONALS = 25;
    public const KERNEL_LINE_ENDS = 26;
    public const KERNEL_LINE_JUNCTIONS = 27;
    public const KERNEL_RIDGES = 28;
    public const KERNEL_CONVEX_HULL = 29;
    public const KERNEL_THIN_SE = 30;
    public const KERNEL_SKELETON = 31;
    public const KERNEL_CHEBYSHEV = 32;
    public const KERNEL_MANHATTAN = 33;
    public const KERNEL_OCTAGONAL = 34;
    public const KERNEL_EUCLIDEAN = 35;
    public const KERNEL_USER_DEFINED = 36;
    public const KERNEL_BINOMIAL = 37;
    public const DIRECTION_LEFT_TO_RIGHT = 2;
    public const DIRECTION_RIGHT_TO_LEFT = 1;
    public const NORMALIZE_KERNEL_NONE = 0;
    public const NORMALIZE_KERNEL_VALUE = 8192;
    public const NORMALIZE_KERNEL_CORRELATE = 65536;
    public const NORMALIZE_KERNEL_PERCENT = 4096;

    /**
     * (PECL imagick 2.0.0)

     * Removes repeated portions of images to optimize
     * @link https://php.net/manual/en/imagick.optimizeimagelayers.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function optimizeImageLayers() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the maximum bounding region between images
     * @link https://php.net/manual/en/imagick.compareimagelayers.php
     * @param int $method 

     * One of the layer method constants.
     * 
     * @return Imagick TRUE on success.
     * @throws ImagickException on error.
     */
    public function compareImageLayers($method) {}

    /**
     * (PECL imagick 2.0.0)

     * Quickly fetch attributes
     * @link https://php.net/manual/en/imagick.pingimageblob.php
     * @param string $image 

     * A string containing the image.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function pingImageBlob($image) {}

    /**
     * (PECL imagick 2.0.0)

     * Get basic image attributes in a lightweight manner
     * @link https://php.net/manual/en/imagick.pingimagefile.php
     * @param resource $filehandle 

     * An open filehandle to the image.
     * 
     * @param string $fileName [optional] 

     * Optional filename for this image.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function pingImageFile($filehandle, $fileName = null) {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a vertical mirror image
     * @link https://php.net/manual/en/imagick.transposeimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function transposeImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a horizontal mirror image
     * @link https://php.net/manual/en/imagick.transverseimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function transverseImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Remove edges from the image
     * @link https://php.net/manual/en/imagick.trimimage.php
     * @param float $fuzz 

     * By default target must match a particular pixel color exactly.
     * However, in many cases two colors may differ by a small amount.
     * The fuzz member of image defines how much tolerance is acceptable
     * to consider two colors as the same. This parameter represents the variation
     * on the quantum range.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function trimImage($fuzz) {}

    /**
     * (PECL imagick 2.0.0)

     * Applies wave filter to the image
     * @link https://php.net/manual/en/imagick.waveimage.php
     * @param float $amplitude 

     * The amplitude of the wave.
     * 
     * @param float $length 

     * The length of the wave.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function waveImage($amplitude, $length) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds vignette filter to the image
     * @link https://php.net/manual/en/imagick.vignetteimage.php
     * @param float $blackPoint 

     * The black point.
     * 
     * @param float $whitePoint 

     * The white point
     * 
     * @param int $x 

     * X offset of the ellipse
     * 
     * @param int $y 

     * Y offset of the ellipse
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function vignetteImage($blackPoint, $whitePoint, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Discards all but one of any pixel color
     * @link https://php.net/manual/en/imagick.uniqueimagecolors.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function uniqueImageColors() {}

    /**
     * (PECL imagick 2.0.0)

     * Return if the image has a matte channel
     * @link https://php.net/manual/en/imagick.getimagematte.php
     * @return bool TRUE on success or FALSE on failure.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    #[Pure]
    public function getImageMatte() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image matte channel
     * @link https://php.net/manual/en/imagick.setimagematte.php
     * @param bool $matte 

     * True activates the matte channel and false disables it.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageMatte($matte) {}

    /**
     * Adaptively resize image with data dependent triangulation
     *
     * If legacy is true, the calculations are done with the small rounding bug that existed in Imagick before 3.4.0.

     * If false, the calculations should produce the same results as ImageMagick CLI does.

     * 

     * Note: The behavior of the parameter bestfit changed in Imagick 3.0.0. Before this version given dimensions 400x400 an image of dimensions 200x150 would be left untouched.
     * In Imagick 3.0.0 and later the image would be scaled up to size 400x300 as this is the "best fit" for the given dimensions. If bestfit parameter is used both width and height must be given.
     * @link https://php.net/manual/en/imagick.adaptiveresizeimage.php
     * @param int $columns The number of columns in the scaled image.
     * @param int $rows The number of rows in the scaled image.
     * @param bool $bestfit [optional] Whether to fit the image inside a bounding box.

     *                                 The behavior of the parameter bestfit changed in Imagick 3.0.0. Before this version given dimensions 400x400 an image of dimensions 200x150 would be left untouched. In Imagick 3.0.0 and later the image would be scaled up to size 400x300 as this is the "best fit" for the given dimensions. If bestfit parameter is used both width and height must be given.
     * @param bool $legacy [optional] Added since 3.4.0. Default value FALSE
     * @return bool TRUE on success
     * @throws ImagickException Throws ImagickException on error
     * @since 2.0.0
     */
    public function adaptiveResizeImage($columns, $rows, $bestfit = false, $legacy = false) {}

    /**
     * (PECL imagick 2.0.0)

     * Simulates a pencil sketch
     * @link https://php.net/manual/en/imagick.sketchimage.php
     * @param float $radius 

     * The radius of the Gaussian, in pixels, not counting the center pixel
     * 
     * @param float $sigma 

     * The standard deviation of the Gaussian, in pixels.
     * 
     * @param float $angle 

     * Apply the effect along this angle.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function sketchImage($radius, $sigma, $angle) {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a 3D effect
     * @link https://php.net/manual/en/imagick.shadeimage.php
     * @param bool $gray 

     * A value other than zero shades the intensity of each pixel.
     * 
     * @param float $azimuth 

     * Defines the light source direction.
     * 
     * @param float $elevation 

     * Defines the light source direction.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function shadeImage($gray, $azimuth, $elevation) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the size offset
     * @link https://php.net/manual/en/imagick.getsizeoffset.php
     * @return int the size offset associated with the Imagick object.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getSizeOffset() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the size and offset of the Imagick object
     * @link https://php.net/manual/en/imagick.setsizeoffset.php
     * @param int $columns 

     * The width in pixels.
     * 
     * @param int $rows 

     * The height in pixels.
     * 
     * @param int $offset 

     * The image offset.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setSizeOffset($columns, $rows, $offset) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds adaptive blur filter to image
     * @link https://php.net/manual/en/imagick.adaptiveblurimage.php
     * @param float $radius 

     * The radius of the Gaussian, in pixels, not counting the center pixel.
     * Provide a value of 0 and the radius will be chosen automagically.
     * 
     * @param float $sigma 

     * The standard deviation of the Gaussian, in pixels.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function adaptiveBlurImage($radius, $sigma, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (PECL imagick 2.0.0)

     * Enhances the contrast of a color image
     * @link https://php.net/manual/en/imagick.contraststretchimage.php
     * @param float $black_point 

     * The black point.
     * 
     * @param float $white_point 

     * The white point.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Imagick::CHANNEL_ALL. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function contrastStretchImage($black_point, $white_point, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Adaptively sharpen the image
     * @link https://php.net/manual/en/imagick.adaptivesharpenimage.php
     * @param float $radius 

     * The radius of the Gaussian, in pixels, not counting the center pixel. Use 0 for auto-select.
     * 
     * @param float $sigma 

     * The standard deviation of the Gaussian, in pixels.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function adaptiveSharpenImage($radius, $sigma, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a high-contrast, two-color image
     * @link https://php.net/manual/en/imagick.randomthresholdimage.php
     * @param float $low 

     * The low point
     * 
     * @param float $high 

     * The high point
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function randomThresholdImage($low, $high, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * @param $xRounding
     * @param $yRounding
     * @param $strokeWidth [optional]
     * @param $displace [optional]
     * @param $sizeCorrection [optional]
     * @throws ImagickException on error.
     */
    public function roundCornersImage($xRounding, $yRounding, $strokeWidth, $displace, $sizeCorrection) {}

    /**
     * (PECL imagick 2.0.0)

     * Rounds image corners
     * Alias to {@see Imagick::roundCornersImage}
     * @link https://php.net/manual/en/imagick.roundcorners.php
     * @param float $x_rounding 

     * x rounding
     * 
     * @param float $y_rounding 

     * y rounding
     * 
     * @param float $stroke_width [optional] 

     * stroke width
     * 
     * @param float $displace [optional] 

     * image displace
     * 
     * @param float $size_correction [optional] 

     * size correction
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated(replacement: "%class%->roundCornersImage(%parametersList%)")]
    public function roundCorners($x_rounding, $y_rounding, $stroke_width = 10.0, $displace = 5.0, $size_correction = -6.0) {}

    /**
     * (PECL imagick 2.0.0)

     * Set the iterator position
     * @link https://php.net/manual/en/imagick.setiteratorindex.php
     * @param int $index 

     * The position to set the iterator to
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setIteratorIndex($index) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the index of the current active image
     * @link https://php.net/manual/en/imagick.getiteratorindex.php
     * @return int an integer containing the index of the image in the stack.
     */
    #[Pure]
    public function getIteratorIndex() {}

    /**
     * (PECL imagick 2.0.0)

     * Convenience method for setting crop size and the image geometry
     * @link https://php.net/manual/en/imagick.transformimage.php
     * @param string $crop 

     * A crop geometry string. This geometry defines a subregion of the image to crop.
     * 
     * @param string $geometry 

     * An image geometry string. This geometry defines the final size of the image.
     * 
     * @return Imagick TRUE on success.
     * @throws ImagickException on error.
     */
    public function transformImage($crop, $geometry) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image opacity level
     * @link https://php.net/manual/en/imagick.setimageopacity.php
     * @param float $opacity 

     * The level of transparency: 1.0 is fully opaque and 0.0 is fully
     * transparent.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageOpacity($opacity) {}

    /**
     * (PECL imagick 2.2.2)

     * Performs an ordered dither
     * @link https://php.net/manual/en/imagick.orderedposterizeimage.php
     * @param string $threshold_map 

     * A string containing the name of the threshold dither map to use
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function orderedPosterizeImage($threshold_map, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Simulates a Polaroid picture
     * @link https://php.net/manual/en/imagick.polaroidimage.php
     * @param ImagickDraw $properties 

     * The polaroid properties
     * 
     * @param float $angle 

     * The polaroid angle
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function polaroidImage(ImagickDraw $properties, $angle) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the named image property
     * @link https://php.net/manual/en/imagick.getimageproperty.php
     * @param string $name 

     * name of the property (for example Exif:DateTime)
     * 
     * @return string|false a string containing the image property, false if a
     * property with the given name does not exist.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageProperty($name) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets an image property
     * @link https://php.net/manual/en/imagick.setimageproperty.php
     * @param string $name
     * @param string $value
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageProperty($name, $value) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image interpolate pixel method
     * @link https://php.net/manual/en/imagick.setimageinterpolatemethod.php
     * @param int $method 

     * The method is one of the Imagick::INTERPOLATE_* constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageInterpolateMethod($method) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the interpolation method
     * @link https://php.net/manual/en/imagick.getimageinterpolatemethod.php
     * @return int the interpolate method on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageInterpolateMethod() {}

    /**
     * (PECL imagick 2.0.0)

     * Stretches with saturation the image intensity
     * @link https://php.net/manual/en/imagick.linearstretchimage.php
     * @param float $blackPoint 

     * The image black point
     * 
     * @param float $whitePoint 

     * The image white point
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function linearStretchImage($blackPoint, $whitePoint) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image length in bytes
     * @link https://php.net/manual/en/imagick.getimagelength.php
     * @return int an int containing the current image size.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageLength() {}

    /**
     * (No version information available, might only be in SVN)

     * Set image size
     * @link https://php.net/manual/en/imagick.extentimage.php
     * @param int $width 

     * The new width
     * 
     * @param int $height 

     * The new height
     * 
     * @param int $x 

     * X position for the new size
     * 
     * @param int $y 

     * Y position for the new size
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function extentImage($width, $height, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image orientation
     * @link https://php.net/manual/en/imagick.getimageorientation.php
     * @return int an int on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageOrientation() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image orientation
     * @link https://php.net/manual/en/imagick.setimageorientation.php
     * @param int $orientation 

     * One of the orientation constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageOrientation($orientation) {}

    /**
     * (PECL imagick 2.1.0)

     * Changes the color value of any pixel that matches target
     * @link https://php.net/manual/en/imagick.paintfloodfillimage.php
     * @param mixed $fill 

     * ImagickPixel object or a string containing the fill color
     * 
     * @param float $fuzz 

     * The amount of fuzz. For example, set fuzz to 10 and the color red at
     * intensities of 100 and 102 respectively are now interpreted as the
     * same color for the purposes of the floodfill.
     * 
     * @param mixed $bordercolor 

     * ImagickPixel object or a string containing the border color
     * 
     * @param int $x 

     * X start position of the floodfill
     * 
     * @param int $y 

     * Y start position of the floodfill
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function paintFloodfillImage($fill, $fuzz, $bordercolor, $x, $y, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Replaces colors in the image from a color lookup table. Optional second parameter to replace colors in a specific channel. This method is available if Imagick has been compiled against ImageMagick version 6.3.6 or newer.
     * @link https://php.net/manual/en/imagick.clutimage.php
     * @param Imagick $lookup_table 

     * Imagick object containing the color lookup table
     * 
     * @param int $channel [optional] 

     * The Channeltype
     * constant. When not supplied, default channels are replaced.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     * @since 2.0.0
     */
    public function clutImage(Imagick $lookup_table, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image properties
     * @link https://php.net/manual/en/imagick.getimageproperties.php
     * @param string $pattern [optional] 

     * The pattern for property names.
     * 
     * @param bool $only_names [optional] 

     * Whether to return only property names. If FALSE then also the values are returned
     * 
     * @return array an array containing the image properties or property names.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageProperties($pattern = "*", $only_names = true) {}

    /**
     * (PECL imagick 2.2.0)

     * Returns the image profiles
     * @link https://php.net/manual/en/imagick.getimageprofiles.php
     * @param string $pattern [optional] 

     * The pattern for profile names.
     * 
     * @param bool $include_values [optional] 

     * Whether to return only profile names. If FALSE then only profile names will be returned.
     * 
     * @return array an array containing the image profiles or profile names.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageProfiles($pattern = "*", $include_values = true) {}

    /**
     * (PECL imagick 2.0.1)

     * Distorts an image using various distortion methods
     * @link https://php.net/manual/en/imagick.distortimage.php
     * @param int $method 

     * The method of image distortion. See distortion constants
     * 
     * @param array $arguments 

     * The arguments for this distortion method
     * 
     * @param bool $bestfit 

     * Attempt to resize destination to fit distorted source
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function distortImage($method, array $arguments, $bestfit) {}

    /**
     * (No version information available, might only be in SVN)

     * Writes an image to a filehandle
     * @link https://php.net/manual/en/imagick.writeimagefile.php
     * @param resource $filehandle 

     * Filehandle where to write the image
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function writeImageFile($filehandle) {}

    /**
     * (No version information available, might only be in SVN)

     * Writes frames to a filehandle
     * @link https://php.net/manual/en/imagick.writeimagesfile.php
     * @param resource $filehandle 

     * Filehandle where to write the images
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function writeImagesFile($filehandle) {}

    /**
     * (No version information available, might only be in SVN)

     * Reset image page
     * @link https://php.net/manual/en/imagick.resetimagepage.php
     * @param string $page 

     * The page definition. For example 7168x5147+0+0
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function resetImagePage($page) {}

    /**
     * (No version information available, might only be in SVN)

     * Sets image clip mask
     * @link https://php.net/manual/en/imagick.setimageclipmask.php
     * @param Imagick $clip_mask 

     * The Imagick object containing the clip mask
     * 
     * @return bool TRUE on success.
     */
    public function setImageClipMask(Imagick $clip_mask) {}

    /**
     * (No version information available, might only be in SVN)

     * Gets image clip mask
     * @link https://php.net/manual/en/imagick.getimageclipmask.php
     * @return Imagick an Imagick object containing the clip mask.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageClipMask() {}

    /**
     * (No version information available, might only be in SVN)

     * Animates an image or images
     * @link https://php.net/manual/en/imagick.animateimages.php
     * @param string $x_server 

     * X server address
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function animateImages($x_server) {}

    /**
     * (No version information available, might only be in SVN)

     * Recolors image
     * @link https://php.net/manual/en/imagick.recolorimage.php
     * @param array $matrix 

     * The matrix containing the color values
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function recolorImage(array $matrix) {}

    /**
     * (PECL imagick 2.1.0)

     * Sets font
     * @link https://php.net/manual/en/imagick.setfont.php
     * @param string $font 

     * Font name or a filename
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setFont($font) {}

    /**
     * (PECL imagick 2.1.0)

     * Gets font
     * @link https://php.net/manual/en/imagick.getfont.php
     * @return string|false the string containing the font name or FALSE if not font is set.
     */
    #[Pure]
    public function getFont() {}

    /**
     * (PECL imagick 2.1.0)

     * Sets point size
     * @link https://php.net/manual/en/imagick.setpointsize.php
     * @param float $point_size 

     * Point size
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setPointSize($point_size) {}

    /**
     * (No version information available, might only be in SVN)

     * Gets point size
     * @link https://php.net/manual/en/imagick.getpointsize.php
     * @return float a float containing the point size.
     */
    #[Pure]
    public function getPointSize() {}

    /**
     * (PECL imagick 2.1.0)

     * Merges image layers
     * @link https://php.net/manual/en/imagick.mergeimagelayers.php
     * @param int $layer_method 

     * One of the Imagick::LAYERMETHOD_* constants
     * 
     * @return Imagick Returns an Imagick object containing the merged image.
     * @throws ImagickException
     */
    public function mergeImageLayers($layer_method) {}

    /**
     * (No version information available, might only be in SVN)

     * Sets image alpha channel
     * @link https://php.net/manual/en/imagick.setimagealphachannel.php
     * @param int $mode 

     * One of the Imagick::ALPHACHANNEL_* constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageAlphaChannel($mode) {}

    /**
     * (No version information available, might only be in SVN)

     * Changes the color value of any pixel that matches target
     * @link https://php.net/manual/en/imagick.floodfillpaintimage.php
     * @param mixed $fill 

     * ImagickPixel object or a string containing the fill color
     * 
     * @param float $fuzz 

     * The amount of fuzz. For example, set fuzz to 10 and the color red at intensities of 100 and 102 respectively are now interpreted as the same color.
     * 
     * @param mixed $target 

     * ImagickPixel object or a string containing the target color to paint
     * 
     * @param int $x 

     * X start position of the floodfill
     * 
     * @param int $y 

     * Y start position of the floodfill
     * 
     * @param bool $invert 

     * If TRUE paints any pixel that does not match the target color.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function floodFillPaintImage($fill, $fuzz, $target, $x, $y, $invert, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (No version information available, might only be in SVN)

     * Changes the color value of any pixel that matches target
     * @link https://php.net/manual/en/imagick.opaquepaintimage.php
     * @param mixed $target 

     * ImagickPixel object or a string containing the color to change
     * 
     * @param mixed $fill 

     * The replacement color
     * 
     * @param float $fuzz 

     * The amount of fuzz. For example, set fuzz to 10 and the color red at intensities of 100 and 102 respectively are now interpreted as the same color.
     * 
     * @param bool $invert 

     * If TRUE paints any pixel that does not match the target color.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function opaquePaintImage($target, $fill, $fuzz, $invert, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (No version information available, might only be in SVN)

     * Paints pixels transparent
     * @link https://php.net/manual/en/imagick.transparentpaintimage.php
     * @param mixed $target 

     * The target color to paint
     * 
     * @param float $alpha 

     * The level of transparency: 1.0 is fully opaque and 0.0 is fully transparent.
     * 
     * @param float $fuzz 

     * The amount of fuzz. For example, set fuzz to 10 and the color red at intensities of 100 and 102 respectively are now interpreted as the same color.
     * 
     * @param bool $invert 

     * If TRUE paints any pixel that does not match the target color.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function transparentPaintImage($target, $alpha, $fuzz, $invert) {}

    /**
     * (No version information available, might only be in SVN)

     * Animates an image or images
     * @link https://php.net/manual/en/imagick.liquidrescaleimage.php
     * @param int $width 

     * The width of the target size
     * 
     * @param int $height 

     * The height of the target size
     * 
     * @param float $delta_x 

     * How much the seam can traverse on x-axis.
     * Passing 0 causes the seams to be straight.
     * 
     * @param float $rigidity 

     * Introduces a bias for non-straight seams. This parameter is
     * typically 0.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function liquidRescaleImage($width, $height, $delta_x, $rigidity) {}

    /**
     * (No version information available, might only be in SVN)

     * Enciphers an image
     * @link https://php.net/manual/en/imagick.encipherimage.php
     * @param string $passphrase 

     * The passphrase
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function encipherImage($passphrase) {}

    /**
     * (No version information available, might only be in SVN)

     * Deciphers an image
     * @link https://php.net/manual/en/imagick.decipherimage.php
     * @param string $passphrase 

     * The passphrase
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function decipherImage($passphrase) {}

    /**
     * (No version information available, might only be in SVN)

     * Sets the gravity
     * @link https://php.net/manual/en/imagick.setgravity.php
     * @param int $gravity 

     * The gravity property. Refer to the list of
     * gravity constants.
     * 
     * @return bool No value is returned.
     * @throws ImagickException on error.
     */
    public function setGravity($gravity) {}

    /**
     * (No version information available, might only be in SVN)

     * Gets the gravity
     * @link https://php.net/manual/en/imagick.getgravity.php
     * @return int the gravity property. Refer to the list of
     * gravity constants.
     */
    #[Pure]
    public function getGravity() {}

    /**
     * (PECL imagick 2.2.1)

     * Gets channel range
     * @link https://php.net/manual/en/imagick.getimagechannelrange.php
     * @param int $channel 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return float[] an array containing minima and maxima values of the channel(s).
     * @throws ImagickException on error.
     */
    #[ArrayShape(["minima" => "float", "maxima" => "float"])]
    #[Pure]
    public function getImageChannelRange($channel) {}

    /**
     * (No version information available, might only be in SVN)

     * Gets the image alpha channel
     * @link https://php.net/manual/en/imagick.getimagealphachannel.php
     * @return int a constant defining the current alpha channel value. Refer to this
     * list of alpha channel constants.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageAlphaChannel() {}

    /**
     * (No version information available, might only be in SVN)

     * Gets channel distortions
     * @link https://php.net/manual/en/imagick.getimagechanneldistortions.php
     * @param Imagick $reference 

     * Imagick object containing the reference image
     * 
     * @param int $metric 

     * Refer to this list of metric type constants.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return float a float describing the channel distortion.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageChannelDistortions(Imagick $reference, $metric, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (No version information available, might only be in SVN)

     * Sets the image gravity
     * @link https://php.net/manual/en/imagick.setimagegravity.php
     * @param int $gravity 

     * The gravity property. Refer to the list of
     * gravity constants.
     * 
     * @return bool No value is returned.
     * @throws ImagickException on error.
     */
    public function setImageGravity($gravity) {}

    /**
     * (No version information available, might only be in SVN)

     * Gets the image gravity
     * @link https://php.net/manual/en/imagick.getimagegravity.php
     * @return int the images gravity property. Refer to the list of
     * gravity constants.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageGravity() {}

    /**
     * (No version information available, might only be in SVN)

     * Imports image pixels
     * @link https://php.net/manual/en/imagick.importimagepixels.php
     * @param int $x 

     * The image x position
     * 
     * @param int $y 

     * The image y position
     * 
     * @param int $width 

     * The image width
     * 
     * @param int $height 

     * The image height
     * 
     * @param string $map 

     * Map of pixel ordering as a string. This can be for example RGB.
     * The value can be any combination or order of R = red, G = green, B = blue, A = alpha (0 is transparent),
     * O = opacity (0 is opaque), C = cyan, Y = yellow, M = magenta, K = black, I = intensity (for grayscale), P = pad.
     * 
     * @param int $storage 

     * The pixel storage method.
     * Refer to this list of pixel constants.
     * 
     * @param array $pixels 

     * The array of pixels
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function importImagePixels($x, $y, $width, $height, $map, $storage, array $pixels) {}

    /**
     * (No version information available, might only be in SVN)

     * Removes skew from the image
     * @link https://php.net/manual/en/imagick.deskewimage.php
     * @param float $threshold 

     * Deskew threshold
     * 
     * @return bool
     * @throws ImagickException on error.
     */
    public function deskewImage($threshold) {}

    /**
     * (No version information available, might only be in SVN)

     * Segments an image
     * @link https://php.net/manual/en/imagick.segmentimage.php
     * @param int $COLORSPACE 

     * One of the COLORSPACE constants.
     * 
     * @param float $cluster_threshold 

     * A percentage describing minimum number of pixels
     * contained in hexedra before it is considered valid.
     * 
     * @param float $smooth_threshold 

     * Eliminates noise from the histogram.
     * 
     * @param bool $verbose [optional] 

     * Whether to output detailed information about recognised classes.
     * 
     * @return bool
     * @throws ImagickException on error.
     */
    public function segmentImage($COLORSPACE, $cluster_threshold, $smooth_threshold, $verbose = false) {}

    /**
     * (No version information available, might only be in SVN)

     * Interpolates colors
     * @link https://php.net/manual/en/imagick.sparsecolorimage.php
     * @param int $SPARSE_METHOD 

     * Refer to this list of sparse method constants
     * 
     * @param array $arguments 

     * An array containing the coordinates.
     * The array is in format array(1,1, 2,45)
     * 
     * @param int $channel [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function sparseColorImage($SPARSE_METHOD, array $arguments, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (No version information available, might only be in SVN)

     * Remaps image colors
     * @link https://php.net/manual/en/imagick.remapimage.php
     * @param Imagick $replacement 

     * An Imagick object containing the replacement colors
     * 
     * @param int $DITHER 

     * Refer to this list of dither method constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function remapImage(Imagick $replacement, $DITHER) {}

    /**
     * (No version information available, might only be in SVN)

     * Exports raw image pixels
     * @link https://php.net/manual/en/imagick.exportimagepixels.php
     * @param int $x 

     * X-coordinate of the exported area
     * 
     * @param int $y 

     * Y-coordinate of the exported area
     * 
     * @param int $width 

     * Width of the exported aread
     * 
     * @param int $height 

     * Height of the exported area
     * 
     * @param string $map 

     * Ordering of the exported pixels. For example "RGB".
     * Valid characters for the map are R, G, B, A, O, C, Y, M, K, I and P.
     * 
     * @param int $STORAGE 

     * Refer to this list of pixel type constants
     * 
     * @return int[] an array containing the pixels values.
     * @throws ImagickException on error.
     */
    public function exportImagePixels($x, $y, $width, $height, $map, $STORAGE) {}

    /**
     * (No version information available, might only be in SVN)

     * The getImageChannelKurtosis purpose
     * @link https://php.net/manual/en/imagick.getimagechannelkurtosis.php
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return float[] an array with kurtosis and skewness
     * members.
     * @throws ImagickException on error.
     */
    #[ArrayShape(["kurtosis" => "float", "skewness" => "float"])]
    #[Pure]
    public function getImageChannelKurtosis($channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (No version information available, might only be in SVN)

     * Applies a function on the image
     * @link https://php.net/manual/en/imagick.functionimage.php
     * @param int $function 

     * Refer to this list of function constants
     * 
     * @param array $arguments 

     * Array of arguments to pass to this function.
     * 
     * @param int $channel [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function functionImage($function, array $arguments, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Transform image colorspace
     * @param $COLORSPACE
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function transformImageColorspace($COLORSPACE) {}

    /**
     * (No version information available, might only be in SVN)

     * Replaces colors in the image
     * @link https://php.net/manual/en/imagick.haldclutimage.php
     * @param Imagick $clut 

     * Imagick object containing the Hald lookup image.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function haldClutImage(Imagick $clut, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Adjusts the levels of a particular image channel by scaling the minimum and maximum values to the full quantum range.
     * @param $CHANNEL [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function autoLevelImage($CHANNEL) {}

    /**
     * @link https://www.php.net/manual/en/imagick.blueshiftimage.php
     * @param float $factor [optional]
     * @return bool
     * @throws ImagickException on error.
     */
    public function blueShiftImage($factor) {}

    /**
     * (No version information available, might only be in SVN)

     * Get image artifact
     * @link https://php.net/manual/en/imagick.getimageartifact.php
     * @param string $artifact 

     * The name of the artifact
     * 
     * @return string the artifact value on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageArtifact($artifact) {}

    /**
     * (No version information available, might only be in SVN)

     * Set image artifact
     * @link https://php.net/manual/en/imagick.setimageartifact.php
     * @param string $artifact 

     * The name of the artifact
     * 
     * @param string $value 

     * The value of the artifact
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageArtifact($artifact, $value) {}

    /**
     * (No version information available, might only be in SVN)

     * Delete image artifact
     * @link https://php.net/manual/en/imagick.deleteimageartifact.php
     * @param string $artifact 

     * The name of the artifact to delete
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function deleteImageArtifact($artifact) {}

    /**
     * (PECL imagick 0.9.10-0.9.9)

     * Gets the colorspace
     * @link https://php.net/manual/en/imagick.getcolorspace.php
     * @return int an integer which can be compared against COLORSPACE constants.
     */
    #[Pure]
    public function getColorspace() {}

    /**
     * (No version information available, might only be in SVN)

     * Set colorspace
     * @link https://php.net/manual/en/imagick.setcolorspace.php
     * @param int $COLORSPACE 

     * One of the COLORSPACE constants
     * 
     * @return bool TRUE on success.
     */
    public function setColorspace($COLORSPACE) {}

    /**
     * @param $CHANNEL [optional]
     * @throws ImagickException on error.
     */
    public function clampImage($CHANNEL) {}

    /**
     * @param bool $stack
     * @param int $offset
     * @return Imagick
     * @throws ImagickException on error.
     */
    public function smushImages($stack, $offset) {}

    /**
     * (PECL imagick 2.0.0)

     * The Imagick constructor
     * @link https://php.net/manual/en/imagick.construct.php
     * @param mixed $files 

     * The path to an image to load or an array of paths. Paths can include
     * wildcards for file names, or can be URLs.
     * 
     * @throws ImagickException Throws ImagickException on error.
     */
    public function __construct($files = null) {}

    /**
     * @return string
     */
    public function __toString() {}

    public function count() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a MagickPixelIterator
     * @link https://php.net/manual/en/imagick.getpixeliterator.php
     * @return ImagickPixelIterator an ImagickPixelIterator on success.
     * @throws ImagickException on error.
     * @throws ImagickPixelIteratorException on error.
     */
    #[Pure]
    public function getPixelIterator() {}

    /**
     * (PECL imagick 2.0.0)

     * Get an ImagickPixelIterator for an image section
     * @link https://php.net/manual/en/imagick.getpixelregioniterator.php
     * @param int $x 

     * The x-coordinate of the region.
     * 
     * @param int $y 

     * The y-coordinate of the region.
     * 
     * @param int $columns 

     * The width of the region.
     * 
     * @param int $rows 

     * The height of the region.
     * 
     * @return ImagickPixelIterator an ImagickPixelIterator for an image section.
     * @throws ImagickException on error.
     * @throws ImagickPixelIteratorException on error.
     */
    #[Pure]
    public function getPixelRegionIterator($x, $y, $columns, $rows) {}

    /**
     * (PECL imagick 0.9.0-0.9.9)

     * Reads image from filename
     * @link https://php.net/manual/en/imagick.readimage.php
     * @param string $filename
     * @return bool TRUE on success.
     * @throws ImagickException Throws ImagickException on error.
     */
    public function readImage($filename) {}

    /**
     * @param $filenames
     * @throws ImagickException Throws ImagickException on error.
     */
    public function readImages($filenames) {}

    /**
     * (PECL imagick 2.0.0)

     * Reads image from a binary string
     * @link https://php.net/manual/en/imagick.readimageblob.php
     * @param string $image
     * @param string $filename [optional]
     * @return bool TRUE on success.
     * @throws ImagickException Throws ImagickException on error.
     */
    public function readImageBlob($image, $filename = null) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the format of a particular image
     * @link https://php.net/manual/en/imagick.setimageformat.php
     * @param string $format 

     * String presentation of the image format. Format support
     * depends on the ImageMagick installation.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageFormat($format) {}

    /**
     * Scales the size of an image to the given dimensions. Passing zero as either of the arguments will preserve dimension while scaling.

     * If legacy is true, the calculations are done with the small rounding bug that existed in Imagick before 3.4.0.

     * If false, the calculations should produce the same results as ImageMagick CLI does.
     * @link https://php.net/manual/en/imagick.scaleimage.php
     * @param int $columns
     * @param int $rows
     * @param bool $bestfit [optional] The behavior of the parameter bestfit changed in Imagick 3.0.0. Before this version given dimensions 400x400 an image of dimensions 200x150 would be left untouched. In Imagick 3.0.0 and later the image would be scaled up to size 400x300 as this is the "best fit" for the given dimensions. If bestfit parameter is used both width and height must be given.
     * @param bool $legacy [optional] Added since 3.4.0. Default value FALSE
     * @return bool TRUE on success.
     * @throws ImagickException Throws ImagickException on error
     * @since 2.0.0
     */
    public function scaleImage($columns, $rows, $bestfit = false, $legacy = false) {}

    /**
     * (PECL imagick 0.9.0-0.9.9)

     * Writes an image to the specified filename
     * @link https://php.net/manual/en/imagick.writeimage.php
     * @param string $filename [optional] 

     * Filename where to write the image. The extension of the filename
     * defines the type of the file.
     * Format can be forced regardless of file extension using format: prefix,
     * for example "jpg:test.png".
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function writeImage($filename = null) {}

    /**
     * (PECL imagick 0.9.0-0.9.9)

     * Writes an image or image sequence
     * @link https://php.net/manual/en/imagick.writeimages.php
     * @param string $filename
     * @param bool $adjoin
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function writeImages($filename, $adjoin) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds blur filter to image
     * @link https://php.net/manual/en/imagick.blurimage.php
     * @param float $radius 

     * Blur radius
     * 
     * @param float $sigma 

     * Standard deviation
     * 
     * @param int $channel [optional] 

     * The Channeltype
     * constant. When not supplied, all channels are blurred.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function blurImage($radius, $sigma, $channel = null) {}

    /**
     * Changes the size of an image to the given dimensions and removes any associated profiles.

     * If legacy is true, the calculations are done with the small rounding bug that existed in Imagick before 3.4.0.

     * If false, the calculations should produce the same results as ImageMagick CLI does.

     * 

     * Note: The behavior of the parameter bestfit changed in Imagick 3.0.0. Before this version given dimensions 400x400 an image of dimensions 200x150 would be left untouched. In Imagick 3.0.0 and later the image would be scaled up to size 400x300 as this is the "best fit" for the given dimensions. If bestfit parameter is used both width and height must be given.
     * @link https://php.net/manual/en/imagick.thumbnailimage.php
     * @param int $columns 

     * Image width
     * 
     * @param int $rows 

     * Image height
     * 
     * @param bool $bestfit [optional] 

     * Whether to force maximum values
     * 
     * The behavior of the parameter bestfit changed in Imagick 3.0.0. Before this version given dimensions 400x400 an image of dimensions 200x150 would be left untouched. In Imagick 3.0.0 and later the image would be scaled up to size 400x300 as this is the "best fit" for the given dimensions. If bestfit parameter is used both width and height must be given.
     * @param bool $fill [optional]
     * @param bool $legacy [optional] Added since 3.4.0. Default value FALSE
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     * @since 2.0.0
     */
    public function thumbnailImage($columns, $rows, $bestfit = false, $fill = false, $legacy = false) {}

    /**
     * Creates a cropped thumbnail at the requested size.
     * If legacy is true, uses the incorrect behaviour that was present until Imagick 3.4.0.
     * If false it uses the correct behaviour.
     * @link https://php.net/manual/en/imagick.cropthumbnailimage.php
     * @param int $width The width of the thumbnail
     * @param int $height The Height of the thumbnail
     * @param bool $legacy [optional] Added since 3.4.0. Default value FALSE
     * @return bool TRUE on succes
     * @throws ImagickException Throws ImagickException on error
     * @since 2.0.0
     */
    public function cropThumbnailImage($width, $height, $legacy = false) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the filename of a particular image in a sequence
     * @link https://php.net/manual/en/imagick.getimagefilename.php
     * @return string a string with the filename of the image.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageFilename() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the filename of a particular image
     * @link https://php.net/manual/en/imagick.setimagefilename.php
     * @param string $filename
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageFilename($filename) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the format of a particular image in a sequence
     * @link https://php.net/manual/en/imagick.getimageformat.php
     * @return string a string containing the image format on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageFormat() {}

    /**
     * @link https://secure.php.net/manual/en/imagick.getimagemimetype.php
     * @return string Returns the image mime-type.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageMimeType() {}

    /**
     * (PECL imagick 2.0.0)

     * Removes an image from the image list
     * @link https://php.net/manual/en/imagick.removeimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function removeImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Destroys the Imagick object
     * @link https://php.net/manual/en/imagick.destroy.php
     * @return bool TRUE on success.
     */
    #[Deprecated(replacement: "%class%->clear()")]
    public function destroy() {}

    /**
     * (PECL imagick 2.0.0)

     * Clears all resources associated to Imagick object
     * @link https://php.net/manual/en/imagick.clear.php
     * @return bool TRUE on success.
     */
    public function clear() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image length in bytes
     * @link https://php.net/manual/en/imagick.getimagesize.php
     * @return int an int containing the current image size.
     * @throws ImagickException on error.
     */
    #[Deprecated(replacement: "%class%->getImageLength()")]
    #[Pure]
    public function getImageSize() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image sequence as a blob
     * @link https://php.net/manual/en/imagick.getimageblob.php
     * @return string a string containing the image.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageBlob() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns all image sequences as a blob
     * @link https://php.net/manual/en/imagick.getimagesblob.php
     * @return string a string containing the images. On failure, throws ImagickException on failure
     * @throws ImagickException on failure
     */
    #[Pure]
    public function getImagesBlob() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the Imagick iterator to the first image
     * @link https://php.net/manual/en/imagick.setfirstiterator.php
     * @return bool TRUE on success.
     */
    public function setFirstIterator() {}

    /**
     * (PECL imagick 2.0.1)

     * Sets the Imagick iterator to the last image
     * @link https://php.net/manual/en/imagick.setlastiterator.php
     * @return bool TRUE on success.
     */
    public function setLastIterator() {}

    public function resetIterator() {}

    /**
     * (PECL imagick 2.0.0)

     * Move to the previous image in the object
     * @link https://php.net/manual/en/imagick.previousimage.php
     * @return bool TRUE on success.
     */
    public function previousImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Moves to the next image
     * @link https://php.net/manual/en/imagick.nextimage.php
     * @return bool TRUE on success.
     */
    public function nextImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Checks if the object has a previous image
     * @link https://php.net/manual/en/imagick.haspreviousimage.php
     * @return bool TRUE if the object has more images when traversing the list in the
     * reverse direction, returns FALSE if there are none.
     */
    public function hasPreviousImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Checks if the object has more images
     * @link https://php.net/manual/en/imagick.hasnextimage.php
     * @return bool TRUE if the object has more images when traversing the list in the
     * forward direction, returns FALSE if there are none.
     */
    public function hasNextImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Set the iterator position
     * @link https://php.net/manual/en/imagick.setimageindex.php
     * @param int $index 

     * The position to set the iterator to
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function setImageIndex($index) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the index of the current active image
     * @link https://php.net/manual/en/imagick.getimageindex.php
     * @return int an integer containing the index of the image in the stack.
     */
    #[Deprecated]
    #[Pure]
    public function getImageIndex() {}

    /**
     * (PECL imagick 2.0.0)

     * Adds a comment to your image
     * @link https://php.net/manual/en/imagick.commentimage.php
     * @param string $comment 

     * The comment to add
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function commentImage($comment) {}

    /**
     * (PECL imagick 2.0.0)

     * Extracts a region of the image
     * @link https://php.net/manual/en/imagick.cropimage.php
     * @param int $width 

     * The width of the crop
     * 
     * @param int $height 

     * The height of the crop
     * 
     * @param int $x 

     * The X coordinate of the cropped region's top left corner
     * 
     * @param int $y 

     * The Y coordinate of the cropped region's top left corner
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function cropImage($width, $height, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds a label to an image
     * @link https://php.net/manual/en/imagick.labelimage.php
     * @param string $label 

     * The label to add
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function labelImage($label) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the width and height as an associative array
     * @link https://php.net/manual/en/imagick.getimagegeometry.php
     * @return int[] an array with the width/height of the image.
     * @throws ImagickException on error.
     */
    #[ArrayShape(["width" => "int", "height" => "int"])]
    #[Pure]
    public function getImageGeometry() {}

    /**
     * (PECL imagick 2.0.0)

     * Renders the ImagickDraw object on the current image
     * @link https://php.net/manual/en/imagick.drawimage.php
     * @param ImagickDraw $draw 

     * The drawing operations to render on the image.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function drawImage(ImagickDraw $draw) {}

    /**
     * (No version information available, might only be in SVN)

     * Sets the image compression quality
     * @link https://php.net/manual/en/imagick.setimagecompressionquality.php
     * @param int $quality 

     * The image compression quality as an integer
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageCompressionQuality($quality) {}

    /**
     * (PECL imagick 2.2.2)

     * Gets the current image's compression quality
     * @link https://php.net/manual/en/imagick.getimagecompressionquality.php
     * @return int integer describing the images compression quality
     */
    #[Pure]
    public function getImageCompressionQuality() {}

    /**
     * (PECL imagick 2.0.0)

     * Annotates an image with text
     * @link https://php.net/manual/en/imagick.annotateimage.php
     * @param ImagickDraw $draw_settings 

     * The ImagickDraw object that contains settings for drawing the text
     * 
     * @param float $x 

     * Horizontal offset in pixels to the left of text
     * 
     * @param float $y 

     * Vertical offset in pixels to the baseline of text
     * 
     * @param float $angle 

     * The angle at which to write the text
     * 
     * @param string $text 

     * The string to draw
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function annotateImage(ImagickDraw $draw_settings, $x, $y, $angle, $text) {}

    /**
     * (PECL imagick 2.0.0)

     * Composite one image onto another
     * @link https://php.net/manual/en/imagick.compositeimage.php
     * @param Imagick $composite_object 

     * Imagick object which holds the composite image
     * 
     * @param int $composite Composite operator
     * @param int $x 

     * The column offset of the composited image
     * 
     * @param int $y 

     * The row offset of the composited image
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function compositeImage(Imagick $composite_object, $composite, $x, $y, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Control the brightness, saturation, and hue
     * @link https://php.net/manual/en/imagick.modulateimage.php
     * @param float $brightness
     * @param float $saturation
     * @param float $hue
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function modulateImage($brightness, $saturation, $hue) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the number of unique colors in the image
     * @link https://php.net/manual/en/imagick.getimagecolors.php
     * @return int TRUE on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageColors() {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a composite image
     * @link https://php.net/manual/en/imagick.montageimage.php
     * @param ImagickDraw $draw 

     * The font name, size, and color are obtained from this object.
     * 
     * @param string $tile_geometry 

     * The number of tiles per row and page (e.g. 6x4+0+0).
     * 
     * @param string $thumbnail_geometry 

     * Preferred image size and border size of each thumbnail
     * (e.g. 120x120+4+3>).
     * 
     * @param int $mode 

     * Thumbnail framing mode, see Montage Mode constants.
     * 
     * @param string $frame 

     * Surround the image with an ornamental border (e.g. 15x15+3+3). The
     * frame color is that of the thumbnail's matte color.
     * 
     * @return Imagick TRUE on success.
     * @throws ImagickException on error.
     */
    public function montageImage(ImagickDraw $draw, $tile_geometry, $thumbnail_geometry, $mode, $frame) {}

    /**
     * (PECL imagick 2.0.0)

     * Identifies an image and fetches attributes
     * @link https://php.net/manual/en/imagick.identifyimage.php
     * @param bool $appendRawOutput [optional]
     * @return array Identifies an image and returns the attributes. Attributes include
     * the image width, height, size, and others.
     * @throws ImagickException on error.
     */
    public function identifyImage($appendRawOutput = false) {}

    /**
     * (PECL imagick 2.0.0)

     * Changes the value of individual pixels based on a threshold
     * @link https://php.net/manual/en/imagick.thresholdimage.php
     * @param float $threshold
     * @param int $channel [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function thresholdImage($threshold, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Selects a threshold for each pixel based on a range of intensity
     * @link https://php.net/manual/en/imagick.adaptivethresholdimage.php
     * @param int $width 

     * Width of the local neighborhood.
     * 
     * @param int $height 

     * Height of the local neighborhood.
     * 
     * @param int $offset 

     * The mean offset
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function adaptiveThresholdImage($width, $height, $offset) {}

    /**
     * (PECL imagick 2.0.0)

     * Forces all pixels below the threshold into black
     * @link https://php.net/manual/en/imagick.blackthresholdimage.php
     * @param mixed $threshold 

     * The threshold below which everything turns black
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function blackThresholdImage($threshold) {}

    /**
     * (PECL imagick 2.0.0)

     * Force all pixels above the threshold into white
     * @link https://php.net/manual/en/imagick.whitethresholdimage.php
     * @param mixed $threshold
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function whiteThresholdImage($threshold) {}

    /**
     * (PECL imagick 2.0.0)

     * Append a set of images
     * @link https://php.net/manual/en/imagick.appendimages.php
     * @param bool $stack [optional] 

     * Whether to stack the images vertically.
     * By default (or if FALSE is specified) images are stacked left-to-right.
     * If stack is TRUE, images are stacked top-to-bottom.
     * 
     * @return Imagick Imagick instance on success.
     * @throws ImagickException on error.
     */
    public function appendImages($stack = false) {}

    /**
     * (PECL imagick 2.0.0)

     * Simulates a charcoal drawing
     * @link https://php.net/manual/en/imagick.charcoalimage.php
     * @param float $radius 

     * The radius of the Gaussian, in pixels, not counting the center pixel
     * 
     * @param float $sigma 

     * The standard deviation of the Gaussian, in pixels
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function charcoalImage($radius, $sigma) {}

    /**
     * (PECL imagick 2.0.0)

     * Enhances the contrast of a color image
     * @link https://php.net/manual/en/imagick.normalizeimage.php
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function normalizeImage($channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Simulates an oil painting
     * @link https://php.net/manual/en/imagick.oilpaintimage.php
     * @param float $radius 

     * The radius of the circular neighborhood.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function oilPaintImage($radius) {}

    /**
     * (PECL imagick 2.0.0)

     * Reduces the image to a limited number of color level
     * @link https://php.net/manual/en/imagick.posterizeimage.php
     * @param int $levels
     * @param bool $dither
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function posterizeImage($levels, $dither) {}

    /**
     * (PECL imagick 2.0.0)

     * Radial blurs an image
     * @link https://php.net/manual/en/imagick.radialblurimage.php
     * @param float $angle
     * @param int $channel [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function radialBlurImage($angle, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a simulated 3d button-like effect
     * @link https://php.net/manual/en/imagick.raiseimage.php
     * @param int $width
     * @param int $height
     * @param int $x
     * @param int $y
     * @param bool $raise
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function raiseImage($width, $height, $x, $y, $raise) {}

    /**
     * (PECL imagick 2.0.0)

     * Resample image to desired resolution
     * @link https://php.net/manual/en/imagick.resampleimage.php
     * @param float $x_resolution
     * @param float $y_resolution
     * @param int $filter
     * @param float $blur
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function resampleImage($x_resolution, $y_resolution, $filter, $blur) {}

    /**
     * Scales an image to the desired dimensions with one of these filters:

     * If legacy is true, the calculations are done with the small rounding bug that existed in Imagick before 3.4.0.

     * If false, the calculations should produce the same results as ImageMagick CLI does.

     * 

     * Note: The behavior of the parameter bestfit changed in Imagick 3.0.0. Before this version given dimensions 400x400 an image of dimensions 200x150 would be left untouched.

     * In Imagick 3.0.0 and later the image would be scaled up to size 400x300 as this is the "best fit" for the given dimensions. If bestfit parameter is used both width and height must be given.
     * @link https://php.net/manual/en/imagick.resizeimage.php
     * @param int $columns Width of the image
     * @param int $rows Height of the image
     * @param int $filter Refer to the list of filter constants.
     * @param float $blur The blur factor where > 1 is blurry, < 1 is sharp.
     * @param bool $bestfit [optional] Added since 2.1.0. Added optional fit parameter. This method now supports proportional scaling. Pass zero as either parameter for proportional scaling
     * @param bool $legacy [optional] Added since 3.4.0. Default value FALSE
     * @return bool TRUE on success
     * @throws ImagickException on error.
     * @since 2.0.0
     */
    public function resizeImage($columns, $rows, $filter, $blur, $bestfit = false, $legacy = false) {}

    /**
     * (PECL imagick 2.0.0)

     * Offsets an image
     * @link https://php.net/manual/en/imagick.rollimage.php
     * @param int $x 

     * The X offset.
     * 
     * @param int $y 

     * The Y offset.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function rollImage($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Rotates an image
     * @link https://php.net/manual/en/imagick.rotateimage.php
     * @param mixed $background 

     * The background color
     * 
     * @param float $degrees 

     * The number of degrees to rotate the image
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function rotateImage($background, $degrees) {}

    /**
     * (PECL imagick 2.0.0)

     * Scales an image with pixel sampling
     * @link https://php.net/manual/en/imagick.sampleimage.php
     * @param int $columns
     * @param int $rows
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function sampleImage($columns, $rows) {}

    /**
     * (PECL imagick 2.0.0)

     * Applies a solarizing effect to the image
     * @link https://php.net/manual/en/imagick.solarizeimage.php
     * @param int $threshold
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function solarizeImage($threshold) {}

    /**
     * (PECL imagick 2.0.0)

     * Simulates an image shadow
     * @link https://php.net/manual/en/imagick.shadowimage.php
     * @param float $opacity
     * @param float $sigma
     * @param int $x
     * @param int $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function shadowImage($opacity, $sigma, $x, $y) {}

    /**
     * @param string $key
     * @param string $value
     * @return bool
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function setImageAttribute($key, $value) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image background color
     * @link https://php.net/manual/en/imagick.setimagebackgroundcolor.php
     * @param mixed $background
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageBackgroundColor($background) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image composite operator
     * @link https://php.net/manual/en/imagick.setimagecompose.php
     * @param int $compose
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageCompose($compose) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image compression
     * @link https://php.net/manual/en/imagick.setimagecompression.php
     * @param int $compression 

     * One of the COMPRESSION constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageCompression($compression) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image delay
     * @link https://php.net/manual/en/imagick.setimagedelay.php
     * @param int $delay 

     * The amount of time expressed in 'ticks' that the image should be
     * displayed for. For animated GIFs there are 100 ticks per second, so a
     * value of 20 would be 20/100 of a second aka 1/5th of a second.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageDelay($delay) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image depth
     * @link https://php.net/manual/en/imagick.setimagedepth.php
     * @param int $depth
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageDepth($depth) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image gamma
     * @link https://php.net/manual/en/imagick.setimagegamma.php
     * @param float $gamma
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageGamma($gamma) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image iterations
     * @link https://php.net/manual/en/imagick.setimageiterations.php
     * @param int $iterations 

     * The number of iterations the image should loop over. Set to '0' to loop
     * continuously.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageIterations($iterations) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image matte color
     * @link https://php.net/manual/en/imagick.setimagemattecolor.php
     * @param mixed $matte
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageMatteColor($matte) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the page geometry of the image
     * @link https://php.net/manual/en/imagick.setimagepage.php
     * @param int $width
     * @param int $height
     * @param int $x
     * @param int $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImagePage($width, $height, $x, $y) {}

    /**
     * @param $filename
     * @throws ImagickException on error.
     */
    public function setImageProgressMonitor($filename) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image resolution
     * @link https://php.net/manual/en/imagick.setimageresolution.php
     * @param float $x_resolution
     * @param float $y_resolution
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageResolution($x_resolution, $y_resolution) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image scene
     * @link https://php.net/manual/en/imagick.setimagescene.php
     * @param int $scene
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageScene($scene) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image ticks-per-second
     * @link https://php.net/manual/en/imagick.setimagetickspersecond.php
     * @param int $ticks_per_second 

     * The duration for which an image should be displayed expressed in ticks
     * per second.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageTicksPerSecond($ticks_per_second) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image type
     * @link https://php.net/manual/en/imagick.setimagetype.php
     * @param int $image_type
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageType($image_type) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image units of resolution
     * @link https://php.net/manual/en/imagick.setimageunits.php
     * @param int $units
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageUnits($units) {}

    /**
     * (PECL imagick 2.0.0)

     * Sharpens an image
     * @link https://php.net/manual/en/imagick.sharpenimage.php
     * @param float $radius
     * @param float $sigma
     * @param int $channel [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function sharpenImage($radius, $sigma, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Shaves pixels from the image edges
     * @link https://php.net/manual/en/imagick.shaveimage.php
     * @param int $columns
     * @param int $rows
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function shaveImage($columns, $rows) {}

    /**
     * (PECL imagick 2.0.0)

     * Creating a parallelogram
     * @link https://php.net/manual/en/imagick.shearimage.php
     * @param mixed $background 

     * The background color
     * 
     * @param float $x_shear 

     * The number of degrees to shear on the x axis
     * 
     * @param float $y_shear 

     * The number of degrees to shear on the y axis
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function shearImage($background, $x_shear, $y_shear) {}

    /**
     * (PECL imagick 2.0.0)

     * Splices a solid color into the image
     * @link https://php.net/manual/en/imagick.spliceimage.php
     * @param int $width
     * @param int $height
     * @param int $x
     * @param int $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function spliceImage($width, $height, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Fetch basic attributes about the image
     * @link https://php.net/manual/en/imagick.pingimage.php
     * @param string $filename 

     * The filename to read the information from.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function pingImage($filename) {}

    /**
     * (PECL imagick 2.0.0)

     * Reads image from open filehandle
     * @link https://php.net/manual/en/imagick.readimagefile.php
     * @param resource $filehandle
     * @param string $fileName [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function readImageFile($filehandle, $fileName = null) {}

    /**
     * (PECL imagick 2.0.0)

     * Displays an image
     * @link https://php.net/manual/en/imagick.displayimage.php
     * @param string $servername 

     * The X server name
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function displayImage($servername) {}

    /**
     * (PECL imagick 2.0.0)

     * Displays an image or image sequence
     * @link https://php.net/manual/en/imagick.displayimages.php
     * @param string $servername 

     * The X server name
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function displayImages($servername) {}

    /**
     * (PECL imagick 2.0.0)

     * Randomly displaces each pixel in a block
     * @link https://php.net/manual/en/imagick.spreadimage.php
     * @param float $radius
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function spreadImage($radius) {}

    /**
     * (PECL imagick 2.0.0)

     * Swirls the pixels about the center of the image
     * @link https://php.net/manual/en/imagick.swirlimage.php
     * @param float $degrees
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function swirlImage($degrees) {}

    /**
     * (PECL imagick 2.0.0)

     * Strips an image of all profiles and comments
     * @link https://php.net/manual/en/imagick.stripimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function stripImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns formats supported by Imagick
     * @link https://php.net/manual/en/imagick.queryformats.php
     * @param string $pattern [optional]
     * @return array an array containing the formats supported by Imagick.
     */
    public static function queryFormats($pattern = "*") {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the configured fonts
     * @link https://php.net/manual/en/imagick.queryfonts.php
     * @param string $pattern [optional] 

     * The query pattern
     * 
     * @return array an array containing the configured fonts.
     */
    public static function queryFonts($pattern = "*") {}

    /**
     * (PECL imagick 2.0.0)

     * Returns an array representing the font metrics
     * @link https://php.net/manual/en/imagick.queryfontmetrics.php
     * @param ImagickDraw $properties 

     * ImagickDraw object containing font properties
     * 
     * @param string $text 

     * The text
     * 
     * @param bool $multiline [optional] 

     * Multiline parameter. If left empty it is autodetected
     * 
     * @return array a multi-dimensional array representing the font metrics.
     * @throws ImagickException on error.
     */
    public function queryFontMetrics(ImagickDraw $properties, $text, $multiline = null) {}

    /**
     * (PECL imagick 2.0.0)

     * Hides a digital watermark within the image
     * @link https://php.net/manual/en/imagick.steganoimage.php
     * @param Imagick $watermark_wand
     * @param int $offset
     * @return Imagick TRUE on success.
     * @throws ImagickException on error.
     */
    public function steganoImage(Imagick $watermark_wand, $offset) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds random noise to the image
     * @link https://php.net/manual/en/imagick.addnoiseimage.php
     * @param int $noise_type 

     * The type of the noise. Refer to this list of
     * noise constants.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function addNoiseImage($noise_type, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (PECL imagick 2.0.0)

     * Simulates motion blur
     * @link https://php.net/manual/en/imagick.motionblurimage.php
     * @param float $radius 

     * The radius of the Gaussian, in pixels, not counting the center pixel.
     * 
     * @param float $sigma 

     * The standard deviation of the Gaussian, in pixels.
     * 
     * @param float $angle 

     * Apply the effect along this angle.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * The channel argument affects only if Imagick is compiled against ImageMagick version
     * 6.4.4 or greater.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function motionBlurImage($radius, $sigma, $angle, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * (PECL imagick 2.0.0)

     * Forms a mosaic from images
     * @link https://php.net/manual/en/imagick.mosaicimages.php
     * @return Imagick TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function mosaicImages() {}

    /**
     * (PECL imagick 2.0.0)

     * Method morphs a set of images
     * @link https://php.net/manual/en/imagick.morphimages.php
     * @param int $number_frames 

     * The number of in-between images to generate.
     * 
     * @return Imagick This method returns a new Imagick object on success.
     * Throw an ImagickException on error.
     * @throws ImagickException on error
     * @throws ImagickException on error.
     */
    public function morphImages($number_frames) {}

    /**
     * (PECL imagick 2.0.0)

     * Scales an image proportionally to half its size
     * @link https://php.net/manual/en/imagick.minifyimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function minifyImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Transforms an image
     * @link https://php.net/manual/en/imagick.affinetransformimage.php
     * @param ImagickDraw $matrix 

     * The affine matrix
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function affineTransformImage(ImagickDraw $matrix) {}

    /**
     * (PECL imagick 2.0.0)

     * Average a set of images
     * @link https://php.net/manual/en/imagick.averageimages.php
     * @return Imagick a new Imagick object on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function averageImages() {}

    /**
     * (PECL imagick 2.0.0)

     * Surrounds the image with a border
     * @link https://php.net/manual/en/imagick.borderimage.php
     * @param mixed $bordercolor 

     * ImagickPixel object or a string containing the border color
     * 
     * @param int $width 

     * Border width
     * 
     * @param int $height 

     * Border height
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function borderImage($bordercolor, $width, $height) {}

    /**
     * (PECL imagick 2.0.0)

     * Removes a region of an image and trims
     * @link https://php.net/manual/en/imagick.chopimage.php
     * @param int $width 

     * Width of the chopped area
     * 
     * @param int $height 

     * Height of the chopped area
     * 
     * @param int $x 

     * X origo of the chopped area
     * 
     * @param int $y 

     * Y origo of the chopped area
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function chopImage($width, $height, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Clips along the first path from the 8BIM profile
     * @link https://php.net/manual/en/imagick.clipimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function clipImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Clips along the named paths from the 8BIM profile
     * @link https://php.net/manual/en/imagick.clippathimage.php
     * @param string $pathname 

     * The name of the path
     * 
     * @param bool $inside 

     * If TRUE later operations take effect inside clipping path.
     * Otherwise later operations take effect outside clipping path.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function clipPathImage($pathname, $inside) {}

    /**
     * Alias to {@see Imagick::clipPathImage}
     * @param string $pathname
     * @param string $inside
     * @throws ImagickException on error.
     */
    public function clipImagePath($pathname, $inside) {}

    /**
     * (PECL imagick 2.0.0)

     * Composites a set of images
     * @link https://php.net/manual/en/imagick.coalesceimages.php
     * @return Imagick a new Imagick object on success.
     * @throws ImagickException on error.
     */
    public function coalesceImages() {}

    /**
     * (PECL imagick 2.0.0)

     * Changes the color value of any pixel that matches target
     * @link https://php.net/manual/en/imagick.colorfloodfillimage.php
     * @param mixed $fill 

     * ImagickPixel object containing the fill color
     * 
     * @param float $fuzz 

     * The amount of fuzz. For example, set fuzz to 10 and the color red at
     * intensities of 100 and 102 respectively are now interpreted as the
     * same color for the purposes of the floodfill.
     * 
     * @param mixed $bordercolor 

     * ImagickPixel object containing the border color
     * 
     * @param int $x 

     * X start position of the floodfill
     * 
     * @param int $y 

     * Y start position of the floodfill
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function colorFloodfillImage($fill, $fuzz, $bordercolor, $x, $y) {}

    /**
     * Blends the fill color with each pixel in the image. The 'opacity' color is a per channel strength factor for how strongly the color should be applied.

     * If legacy is true, the behaviour of this function is incorrect, but consistent with how it behaved before Imagick version 3.4.0
     * @link https://php.net/manual/en/imagick.colorizeimage.php
     * @param mixed $colorize 

     * ImagickPixel object or a string containing the colorize color
     * 
     * @param mixed $opacity 

     * ImagickPixel object or an float containing the opacity value.
     * 1.0 is fully opaque and 0.0 is fully transparent.
     * 
     * @param bool $legacy [optional] Added since 3.4.0. Default value FALSE
     * @return bool TRUE on success.
     * @throws ImagickException Throws ImagickException on error
     * @since 2.0.0
     */
    public function colorizeImage($colorize, $opacity, $legacy = false) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the difference in one or more images
     * @link https://php.net/manual/en/imagick.compareimagechannels.php
     * @param Imagick $image 

     * Imagick object containing the image to compare.
     * 
     * @param int $channelType 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @param int $metricType 

     * One of the metric type constants.
     * 
     * @return array Array consisting of new_wand and
     * distortion.
     * @throws ImagickException on error.
     */
    public function compareImageChannels(Imagick $image, $channelType, $metricType) {}

    /**
     * (PECL imagick 2.0.0)

     * Compares an image to a reconstructed image
     * @link https://php.net/manual/en/imagick.compareimages.php
     * @param Imagick $compare 

     * An image to compare to.
     * 
     * @param int $metric 

     * Provide a valid metric type constant. Refer to this
     * list of metric constants.
     * 
     * @return array Array consisting of an Imagick object of the
     * reconstructed image and a float representing the difference.
     * @throws ImagickException Throws ImagickException on error.
     */
    public function compareImages(Imagick $compare, $metric) {}

    /**
     * (PECL imagick 2.0.0)

     * Change the contrast of the image
     * @link https://php.net/manual/en/imagick.contrastimage.php
     * @param bool $sharpen 

     * The sharpen value
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function contrastImage($sharpen) {}

    /**
     * (PECL imagick 2.0.0)

     * Combines one or more images into a single image
     * @link https://php.net/manual/en/imagick.combineimages.php
     * @param int $channelType 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return Imagick TRUE on success.
     * @throws ImagickException on error.
     */
    public function combineImages($channelType) {}

    /**
     * (PECL imagick 2.0.0)

     * Applies a custom convolution kernel to the image
     * @link https://php.net/manual/en/imagick.convolveimage.php
     * @param array $kernel 

     * The convolution kernel
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function convolveImage(array $kernel, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Displaces an image's colormap
     * @link https://php.net/manual/en/imagick.cyclecolormapimage.php
     * @param int $displace 

     * The amount to displace the colormap.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function cycleColormapImage($displace) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns certain pixel differences between images
     * @link https://php.net/manual/en/imagick.deconstructimages.php
     * @return Imagick a new Imagick object on success.
     * @throws ImagickException on error.
     */
    public function deconstructImages() {}

    /**
     * (PECL imagick 2.0.0)

     * Reduces the speckle noise in an image
     * @link https://php.net/manual/en/imagick.despeckleimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function despeckleImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Enhance edges within the image
     * @link https://php.net/manual/en/imagick.edgeimage.php
     * @param float $radius 

     * The radius of the operation.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function edgeImage($radius) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a grayscale image with a three-dimensional effect
     * @link https://php.net/manual/en/imagick.embossimage.php
     * @param float $radius 

     * The radius of the effect
     * 
     * @param float $sigma 

     * The sigma of the effect
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function embossImage($radius, $sigma) {}

    /**
     * (PECL imagick 2.0.0)

     * Improves the quality of a noisy image
     * @link https://php.net/manual/en/imagick.enhanceimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function enhanceImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Equalizes the image histogram
     * @link https://php.net/manual/en/imagick.equalizeimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function equalizeImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Applies an expression to an image
     * @link https://php.net/manual/en/imagick.evaluateimage.php
     * @param int $op 

     * The evaluation operator
     * 
     * @param float $constant 

     * The value of the operator
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function evaluateImage($op, $constant, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * Merges a sequence of images. This is useful for combining Photoshop layers into a single image.
     * This is replaced by:
     * 
     * $im = $im->mergeImageLayers(\Imagick::LAYERMETHOD_FLATTEN)
     * 
     * @link https://php.net/manual/en/imagick.flattenimages.php
     * @return Imagick Returns an Imagick object containing the merged image.
     * @throws ImagickException Throws ImagickException on error.
     * @since 2.0.0
     */
    #[Deprecated]
    public function flattenImages() {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a vertical mirror image
     * @link https://php.net/manual/en/imagick.flipimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function flipImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a horizontal mirror image
     * @link https://php.net/manual/en/imagick.flopimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function flopImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Adds a simulated three-dimensional border
     * @link https://php.net/manual/en/imagick.frameimage.php
     * @param mixed $matte_color 

     * ImagickPixel object or a string representing the matte color
     * 
     * @param int $width 

     * The width of the border
     * 
     * @param int $height 

     * The height of the border
     * 
     * @param int $inner_bevel 

     * The inner bevel width
     * 
     * @param int $outer_bevel 

     * The outer bevel width
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function frameImage($matte_color, $width, $height, $inner_bevel, $outer_bevel) {}

    /**
     * (PECL imagick 2.0.0)

     * Evaluate expression for each pixel in the image
     * @link https://php.net/manual/en/imagick.fximage.php
     * @param string $expression 

     * The expression.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return Imagick TRUE on success.
     * @throws ImagickException on error.
     */
    public function fxImage($expression, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Gamma-corrects an image
     * @link https://php.net/manual/en/imagick.gammaimage.php
     * @param float $gamma 

     * The amount of gamma-correction.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function gammaImage($gamma, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Blurs an image
     * @link https://php.net/manual/en/imagick.gaussianblurimage.php
     * @param float $radius 

     * The radius of the Gaussian, in pixels, not counting the center pixel.
     * 
     * @param float $sigma 

     * The standard deviation of the Gaussian, in pixels.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function gaussianBlurImage($radius, $sigma, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * @link https://www.php.net/manual/en/imagick.getimageattribute.php
     * @param string $key 
The key of the attribute to get.
     * @return string
     */
    #[Deprecated]
    #[Pure]
    public function getImageAttribute($key) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image background color
     * @link https://php.net/manual/en/imagick.getimagebackgroundcolor.php
     * @return ImagickPixel an ImagickPixel set to the background color of the image.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageBackgroundColor() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the chromaticy blue primary point
     * @link https://php.net/manual/en/imagick.getimageblueprimary.php
     * @return float[] Array consisting of "x" and "y" coordinates of point.
     * @throws ImagickException on error.
     */
    #[ArrayShape(["x" => "float", "y" => "float"])]
    #[Pure]
    public function getImageBluePrimary() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image border color
     * @link https://php.net/manual/en/imagick.getimagebordercolor.php
     * @return ImagickPixel TRUE on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageBorderColor() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the depth for a particular image channel
     * @link https://php.net/manual/en/imagick.getimagechanneldepth.php
     * @param int $channel 

     * Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * 
     * @return int TRUE on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageChannelDepth($channel) {}

    /**
     * (PECL imagick 2.0.0)

     * Compares image channels of an image to a reconstructed image
     * @link https://php.net/manual/en/imagick.getimagechanneldistortion.php
     * @param Imagick $reference 

     * Imagick object to compare to.
     * 
     * @param int $channel 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @param int $metric 

     * One of the metric type constants.
     * 
     * @return float TRUE on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageChannelDistortion(Imagick $reference, $channel, $metric) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the extrema for one or more image channels
     * @link https://php.net/manual/en/imagick.getimagechannelextrema.php
     * @param int $channel 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return int[]
     * @throws ImagickException on error.
     */
    #[ArrayShape(["minima" => "int", "maxima" => "int"])]
    #[Deprecated]
    #[Pure]
    public function getImageChannelExtrema($channel) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the mean and standard deviation
     * @link https://php.net/manual/en/imagick.getimagechannelmean.php
     * @param int $channel 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return float[]
     * @throws ImagickException on error.
     */
    #[ArrayShape(["mean" => "float", "standardDeviation" => "float"])]
    #[Pure]
    public function getImageChannelMean($channel) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns statistics for each channel in the image
     * @link https://php.net/manual/en/imagick.getimagechannelstatistics.php
     * @return array
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageChannelStatistics() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the color of the specified colormap index
     * @link https://php.net/manual/en/imagick.getimagecolormapcolor.php
     * @param int $index 

     * The offset into the image colormap.
     * 
     * @return ImagickPixel TRUE on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageColormapColor($index) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image colorspace
     * @link https://php.net/manual/en/imagick.getimagecolorspace.php
     * @return int TRUE on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageColorspace() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the composite operator associated with the image
     * @link https://php.net/manual/en/imagick.getimagecompose.php
     * @return int TRUE on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageCompose() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image delay
     * @link https://php.net/manual/en/imagick.getimagedelay.php
     * @return int the image delay.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageDelay() {}

    /**
     * (PECL imagick 0.9.1-0.9.9)

     * Gets the image depth
     * @link https://php.net/manual/en/imagick.getimagedepth.php
     * @return int The image depth.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageDepth() {}

    /**
     * (PECL imagick 2.0.0)

     * Compares an image to a reconstructed image
     * @link https://php.net/manual/en/imagick.getimagedistortion.php
     * @param Imagick $reference 

     * Imagick object to compare to.
     * 
     * @param int $metric 

     * One of the metric type constants.
     * 
     * @return float the distortion metric used on the image (or the best guess
     * thereof).
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageDistortion(Imagick $reference, $metric) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the extrema for the image
     * @link https://php.net/manual/en/imagick.getimageextrema.php
     * @return int[] an associative array with the keys "min" and "max".
     * @throws ImagickException on error.
     */
    #[ArrayShape(["min" => "int", "max" => "int"])]
    #[Deprecated]
    #[Pure]
    public function getImageExtrema() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image disposal method
     * @link https://php.net/manual/en/imagick.getimagedispose.php
     * @return int the dispose method on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageDispose() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image gamma
     * @link https://php.net/manual/en/imagick.getimagegamma.php
     * @return float the image gamma on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageGamma() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the chromaticy green primary point
     * @link https://php.net/manual/en/imagick.getimagegreenprimary.php
     * @return float[] an array with the keys "x" and "y" on success, throws an ImagickException on failure.
     * @throws ImagickException on failure
     * @throws ImagickException on error.
     */
    #[ArrayShape(["x" => "float", "y" => "float"])]
    #[Pure]
    public function getImageGreenPrimary() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image height
     * @link https://php.net/manual/en/imagick.getimageheight.php
     * @return int the image height in pixels.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageHeight() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image histogram
     * @link https://php.net/manual/en/imagick.getimagehistogram.php
     * @return array the image histogram as an array of ImagickPixel objects.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageHistogram() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image interlace scheme
     * @link https://php.net/manual/en/imagick.getimageinterlacescheme.php
     * @return int the interlace scheme as an integer on success.
     * Trhow an ImagickException on error.
     * @throws ImagickException on error
     */
    #[Deprecated]
    #[Pure]
    public function getImageInterlaceScheme() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image iterations
     * @link https://php.net/manual/en/imagick.getimageiterations.php
     * @return int the image iterations as an integer.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageIterations() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image matte color
     * @link https://php.net/manual/en/imagick.getimagemattecolor.php
     * @return ImagickPixel ImagickPixel object on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageMatteColor() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the page geometry
     * @link https://php.net/manual/en/imagick.getimagepage.php
     * @return int[] the page geometry associated with the image in an array with the
     * keys "width", "height", "x", and "y".
     * @throws ImagickException on error.
     */
    #[ArrayShape(["width" => "int", "height" => "int", "x" => "int", "y" => "int"])]
    #[Pure]
    public function getImagePage() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the color of the specified pixel
     * @link https://php.net/manual/en/imagick.getimagepixelcolor.php
     * @param int $x 

     * The x-coordinate of the pixel
     * 
     * @param int $y 

     * The y-coordinate of the pixel
     * 
     * @return ImagickPixel an ImagickPixel instance for the color at the coordinates given.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImagePixelColor($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the named image profile
     * @link https://php.net/manual/en/imagick.getimageprofile.php
     * @param string $name 

     * The name of the profile to return.
     * 
     * @return string a string containing the image profile.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageProfile($name) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the chromaticity red primary point
     * @link https://php.net/manual/en/imagick.getimageredprimary.php
     * @return float[] the chromaticity red primary point as an array with the keys "x"
     * and "y".
     * Throw an ImagickException on error.
     * @throws ImagickException on error
     */
    #[ArrayShape(["x" => "float", "y" => "float"])]
    #[Pure]
    public function getImageRedPrimary() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image rendering intent
     * @link https://php.net/manual/en/imagick.getimagerenderingintent.php
     * @return int the image rendering intent.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageRenderingIntent() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image X and Y resolution
     * @link https://php.net/manual/en/imagick.getimageresolution.php
     * @return float[] the resolution as an array.
     * @throws ImagickException on error.
     */
    #[ArrayShape(["x" => "float", "y" => "float"])]
    #[Pure]
    public function getImageResolution() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image scene
     * @link https://php.net/manual/en/imagick.getimagescene.php
     * @return int the image scene.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageScene() {}

    /**
     * (PECL imagick 2.0.0)

     * Generates an SHA-256 message digest
     * @link https://php.net/manual/en/imagick.getimagesignature.php
     * @return string a string containing the SHA-256 hash of the file.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageSignature() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image ticks-per-second
     * @link https://php.net/manual/en/imagick.getimagetickspersecond.php
     * @return int the image ticks-per-second.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageTicksPerSecond() {}

    /**
     * (PECL imagick 0.9.10-0.9.9)

     * Gets the potential image type
     * @link https://php.net/manual/en/imagick.getimagetype.php
     * @return int the potential image type.
     * imagick::IMGTYPE_UNDEFINED
     * imagick::IMGTYPE_BILEVEL
     * imagick::IMGTYPE_GRAYSCALE
     * imagick::IMGTYPE_GRAYSCALEMATTE
     * imagick::IMGTYPE_PALETTE
     * imagick::IMGTYPE_PALETTEMATTE
     * imagick::IMGTYPE_TRUECOLOR
     * imagick::IMGTYPE_TRUECOLORMATTE
     * imagick::IMGTYPE_COLORSEPARATION
     * imagick::IMGTYPE_COLORSEPARATIONMATTE
     * imagick::IMGTYPE_OPTIMIZE
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageType() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image units of resolution
     * @link https://php.net/manual/en/imagick.getimageunits.php
     * @return int the image units of resolution.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageUnits() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the virtual pixel method
     * @link https://php.net/manual/en/imagick.getimagevirtualpixelmethod.php
     * @return int the virtual pixel method on success.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageVirtualPixelMethod() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the chromaticity white point
     * @link https://php.net/manual/en/imagick.getimagewhitepoint.php
     * @return float[] the chromaticity white point as an associative array with the keys
     * "x" and "y".
     * @throws ImagickException on error.
     */
    #[ArrayShape(["x" => "float", "y" => "float"])]
    #[Pure]
    public function getImageWhitePoint() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the image width
     * @link https://php.net/manual/en/imagick.getimagewidth.php
     * @return int the image width.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageWidth() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the number of images in the object
     * @link https://php.net/manual/en/imagick.getnumberimages.php
     * @return int the number of images associated with Imagick object.
     */
    #[Pure]
    public function getNumberImages() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the image total ink density
     * @link https://php.net/manual/en/imagick.getimagetotalinkdensity.php
     * @return float the image total ink density of the image.
     * Throw an ImagickException on error.
     * @throws ImagickException on error
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageTotalInkDensity() {}

    /**
     * (PECL imagick 2.0.0)

     * Extracts a region of the image
     * @link https://php.net/manual/en/imagick.getimageregion.php
     * @param int $width 

     * The width of the extracted region.
     * 
     * @param int $height 

     * The height of the extracted region.
     * 
     * @param int $x 

     * X-coordinate of the top-left corner of the extracted region.
     * 
     * @param int $y 

     * Y-coordinate of the top-left corner of the extracted region.
     * 
     * @return Imagick Extracts a region of the image and returns it as a new wand.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImageRegion($width, $height, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a new image as a copy
     * @link https://php.net/manual/en/imagick.implodeimage.php
     * @param float $radius 

     * The radius of the implode
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function implodeImage($radius) {}

    /**
     * (PECL imagick 2.0.0)

     * Adjusts the levels of an image
     * @link https://php.net/manual/en/imagick.levelimage.php
     * @param float $blackPoint 

     * The image black point
     * 
     * @param float $gamma 

     * The gamma value
     * 
     * @param float $whitePoint 

     * The image white point
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function levelImage($blackPoint, $gamma, $whitePoint, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Scales an image proportionally 2x
     * @link https://php.net/manual/en/imagick.magnifyimage.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function magnifyImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Replaces the colors of an image with the closest color from a reference image.
     * @link https://php.net/manual/en/imagick.mapimage.php
     * @param Imagick $map
     * @param bool $dither
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function mapImage(Imagick $map, $dither) {}

    /**
     * (PECL imagick 2.0.0)

     * Changes the transparency value of a color
     * @link https://php.net/manual/en/imagick.mattefloodfillimage.php
     * @param float $alpha 

     * The level of transparency: 1.0 is fully opaque and 0.0 is fully
     * transparent.
     * 
     * @param float $fuzz 

     * The fuzz member of image defines how much tolerance is acceptable to
     * consider two colors as the same.
     * 
     * @param mixed $bordercolor 

     * An ImagickPixel object or string representing the border color.
     * 
     * @param int $x 

     * The starting x coordinate of the operation.
     * 
     * @param int $y 

     * The starting y coordinate of the operation.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function matteFloodfillImage($alpha, $fuzz, $bordercolor, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Applies a digital filter
     * @link https://php.net/manual/en/imagick.medianfilterimage.php
     * @param float $radius 

     * The radius of the pixel neighborhood.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function medianFilterImage($radius) {}

    /**
     * (PECL imagick 2.0.0)

     * Negates the colors in the reference image
     * @link https://php.net/manual/en/imagick.negateimage.php
     * @param bool $gray 

     * Whether to only negate grayscale pixels within the image.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function negateImage($gray, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Change any pixel that matches color
     * @link https://php.net/manual/en/imagick.paintopaqueimage.php
     * @param mixed $target 

     * Change this target color to the fill color within the image. An
     * ImagickPixel object or a string representing the target color.
     * 
     * @param mixed $fill 

     * An ImagickPixel object or a string representing the fill color.
     * 
     * @param float $fuzz 

     * The fuzz member of image defines how much tolerance is acceptable to
     * consider two colors as the same.
     * 
     * @param int $channel [optional] 

     * Provide any channel constant that is valid for your channel mode. To
     * apply to more than one channel, combine channeltype constants using
     * bitwise operators. Refer to this
     * list of channel constants.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function paintOpaqueImage($target, $fill, $fuzz, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Changes any pixel that matches color with the color defined by fill
     * @link https://php.net/manual/en/imagick.painttransparentimage.php
     * @param mixed $target 

     * Change this target color to specified opacity value within the image.
     * 
     * @param float $alpha 

     * The level of transparency: 1.0 is fully opaque and 0.0 is fully
     * transparent.
     * 
     * @param float $fuzz 

     * The fuzz member of image defines how much tolerance is acceptable to
     * consider two colors as the same.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function paintTransparentImage($target, $alpha, $fuzz) {}

    /**
     * (PECL imagick 2.0.0)

     * Quickly pin-point appropriate parameters for image processing
     * @link https://php.net/manual/en/imagick.previewimages.php
     * @param int $preview 

     * Preview type. See Preview type constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function previewImages($preview) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds or removes a profile from an image
     * @link https://php.net/manual/en/imagick.profileimage.php
     * @param string $name
     * @param string $profile
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function profileImage($name, $profile) {}

    /**
     * (PECL imagick 2.0.0)

     * Analyzes the colors within a reference image
     * @link https://php.net/manual/en/imagick.quantizeimage.php
     * @param int $numberColors
     * @param int $colorspace
     * @param int $treedepth
     * @param bool $dither
     * @param bool $measureError
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function quantizeImage($numberColors, $colorspace, $treedepth, $dither, $measureError) {}

    /**
     * (PECL imagick 2.0.0)

     * Analyzes the colors within a sequence of images
     * @link https://php.net/manual/en/imagick.quantizeimages.php
     * @param int $numberColors
     * @param int $colorspace
     * @param int $treedepth
     * @param bool $dither
     * @param bool $measureError
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function quantizeImages($numberColors, $colorspace, $treedepth, $dither, $measureError) {}

    /**
     * (PECL imagick 2.0.0)

     * Smooths the contours of an image
     * @link https://php.net/manual/en/imagick.reducenoiseimage.php
     * @param float $radius
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    #[Deprecated]
    public function reduceNoiseImage($radius) {}

    /**
     * (PECL imagick 2.0.0)

     * Removes the named image profile and returns it
     * @link https://php.net/manual/en/imagick.removeimageprofile.php
     * @param string $name
     * @return string a string containing the profile of the image.
     * @throws ImagickException on error.
     */
    public function removeImageProfile($name) {}

    /**
     * (PECL imagick 2.0.0)

     * Separates a channel from the image
     * @link https://php.net/manual/en/imagick.separateimagechannel.php
     * @param int $channel
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function separateImageChannel($channel) {}

    /**
     * (PECL imagick 2.0.0)

     * Sepia tones an image
     * @link https://php.net/manual/en/imagick.sepiatoneimage.php
     * @param float $threshold
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function sepiaToneImage($threshold) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image bias for any method that convolves an image
     * @link https://php.net/manual/en/imagick.setimagebias.php
     * @param float $bias
     * @return bool TRUE on success.
     */
    public function setImageBias($bias) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image chromaticity blue primary point
     * @link https://php.net/manual/en/imagick.setimageblueprimary.php
     * @param float $x
     * @param float $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageBluePrimary($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image border color
     * @link https://php.net/manual/en/imagick.setimagebordercolor.php
     * @param mixed $border 

     * The border color
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageBorderColor($border) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the depth of a particular image channel
     * @link https://php.net/manual/en/imagick.setimagechanneldepth.php
     * @param int $channel
     * @param int $depth
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageChannelDepth($channel, $depth) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the color of the specified colormap index
     * @link https://php.net/manual/en/imagick.setimagecolormapcolor.php
     * @param int $index
     * @param ImagickPixel $color
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageColormapColor($index, ImagickPixel $color) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image colorspace
     * @link https://php.net/manual/en/imagick.setimagecolorspace.php
     * @param int $colorspace 

     * One of the COLORSPACE constants
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageColorspace($colorspace) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image disposal method
     * @link https://php.net/manual/en/imagick.setimagedispose.php
     * @param int $dispose
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageDispose($dispose) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image size
     * @link https://php.net/manual/en/imagick.setimageextent.php
     * @param int $columns
     * @param int $rows
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageExtent($columns, $rows) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image chromaticity green primary point
     * @link https://php.net/manual/en/imagick.setimagegreenprimary.php
     * @param float $x
     * @param float $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageGreenPrimary($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image compression
     * @link https://php.net/manual/en/imagick.setimageinterlacescheme.php
     * @param int $interlace_scheme
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageInterlaceScheme($interlace_scheme) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds a named profile to the Imagick object
     * @link https://php.net/manual/en/imagick.setimageprofile.php
     * @param string $name
     * @param string $profile
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageProfile($name, $profile) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image chromaticity red primary point
     * @link https://php.net/manual/en/imagick.setimageredprimary.php
     * @param float $x
     * @param float $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageRedPrimary($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image rendering intent
     * @link https://php.net/manual/en/imagick.setimagerenderingintent.php
     * @param int $rendering_intent
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageRenderingIntent($rendering_intent) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image virtual pixel method
     * @link https://php.net/manual/en/imagick.setimagevirtualpixelmethod.php
     * @param int $method
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageVirtualPixelMethod($method) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image chromaticity white point
     * @link https://php.net/manual/en/imagick.setimagewhitepoint.php
     * @param float $x
     * @param float $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImageWhitePoint($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Adjusts the contrast of an image
     * @link https://php.net/manual/en/imagick.sigmoidalcontrastimage.php
     * @param bool $sharpen
     * @param float $alpha
     * @param float $beta
     * @param int $channel [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function sigmoidalContrastImage($sharpen, $alpha, $beta, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Composites two images
     * @link https://php.net/manual/en/imagick.stereoimage.php
     * @param Imagick $offset_wand
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function stereoImage(Imagick $offset_wand) {}

    /**
     * (PECL imagick 2.0.0)

     * Repeatedly tiles the texture image
     * @link https://php.net/manual/en/imagick.textureimage.php
     * @param Imagick $texture_wand
     * @return Imagick a new Imagick object that has the repeated texture applied.
     * @throws ImagickException on error.
     */
    public function textureImage(Imagick $texture_wand) {}

    /**
     * pplies a color vector to each pixel in the image. The 'opacity' color is a per channel strength factor for how strongly the color should be applied.
     * If legacy is true, the behaviour of this function is incorrect, but consistent with how it behaved before Imagick version 3.4.0
     * @link https://php.net/manual/en/imagick.tintimage.php
     * @param mixed $tint
     * @param mixed $opacity
     * @param bool $legacy [optional]
     * @return bool TRUE on success.
     * @throws ImagickException Throws ImagickException on error
     * @since 2.0.0
     */
    public function tintImage($tint, $opacity, $legacy = false) {}

    /**
     * (PECL imagick 2.0.0)

     * Sharpens an image
     * @link https://php.net/manual/en/imagick.unsharpmaskimage.php
     * @param float $radius
     * @param float $sigma
     * @param float $amount
     * @param float $threshold
     * @param int $channel [optional]
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function unsharpMaskImage($radius, $sigma, $amount, $threshold, $channel = Imagick::CHANNEL_ALL) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a new Imagick object
     * @link https://php.net/manual/en/imagick.getimage.php
     * @return Imagick a new Imagick object with the current image sequence.
     * @throws ImagickException on error.
     */
    #[Pure]
    public function getImage() {}

    /**
     * (PECL imagick 2.0.0)

     * Adds new image to Imagick object image list
     * @link https://php.net/manual/en/imagick.addimage.php
     * @param Imagick $source 

     * The source Imagick object
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function addImage(Imagick $source) {}

    /**
     * (PECL imagick 2.0.0)

     * Replaces image in the object
     * @link https://php.net/manual/en/imagick.setimage.php
     * @param Imagick $replace 

     * The replace Imagick object
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setImage(Imagick $replace) {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a new image
     * @link https://php.net/manual/en/imagick.newimage.php
     * @param int $cols 

     * Columns in the new image
     * 
     * @param int $rows 

     * Rows in the new image
     * 
     * @param mixed $background 

     * The background color used for this image
     * 
     * @param string $format [optional] 

     * Image format. This parameter was added in Imagick version 2.0.1.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function newImage($cols, $rows, $background, $format = null) {}

    /**
     * (PECL imagick 2.0.0)

     * Creates a new image
     * @link https://php.net/manual/en/imagick.newpseudoimage.php
     * @param int $columns 

     * columns in the new image
     * 
     * @param int $rows 

     * rows in the new image
     * 
     * @param string $pseudoString 

     * string containing pseudo image definition.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function newPseudoImage($columns, $rows, $pseudoString) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the object compression type
     * @link https://php.net/manual/en/imagick.getcompression.php
     * @return int the compression constant
     */
    #[Pure]
    public function getCompression() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the object compression quality
     * @link https://php.net/manual/en/imagick.getcompressionquality.php
     * @return int integer describing the compression quality
     */
    #[Pure]
    public function getCompressionQuality() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the ImageMagick API copyright as a string
     * @link https://php.net/manual/en/imagick.getcopyright.php
     * @return string a string containing the copyright notice of Imagemagick and
     * Magickwand C API.
     */
    public static function getCopyright() {}

    /**
     * (PECL imagick 2.0.0)

     * The filename associated with an image sequence
     * @link https://php.net/manual/en/imagick.getfilename.php
     * @return string a string on success.
     */
    #[Pure]
    public function getFilename() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the format of the Imagick object
     * @link https://php.net/manual/en/imagick.getformat.php
     * @return string the format of the image.
     */
    #[Pure]
    public function getFormat() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the ImageMagick home URL
     * @link https://php.net/manual/en/imagick.gethomeurl.php
     * @return string a link to the imagemagick homepage.
     */
    public static function getHomeURL() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the object interlace scheme
     * @link https://php.net/manual/en/imagick.getinterlacescheme.php
     * @return int Gets the wand interlace
     * scheme.
     */
    #[Pure]
    public function getInterlaceScheme() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a value associated with the specified key
     * @link https://php.net/manual/en/imagick.getoption.php
     * @param string $key 

     * The name of the option
     * 
     * @return string a value associated with a wand and the specified key.
     */
    #[Pure]
    public function getOption($key) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the ImageMagick package name
     * @link https://php.net/manual/en/imagick.getpackagename.php
     * @return string the ImageMagick package name as a string.
     */
    public static function getPackageName() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the page geometry
     * @link https://php.net/manual/en/imagick.getpage.php
     * @return int[] the page geometry associated with the Imagick object in
     * an associative array with the keys "width", "height", "x", and "y",
     * throwing ImagickException on error.
     * @throws ImagickException on error
     */
    //width:int, height:int, x:int, y:int
    #[ArrayShape(["width" => "int", "height" => "int", "x" => "int", "y" => "int"])]
    #[Pure]
    public function getPage() {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the quantum depth
     * @link https://php.net/manual/en/imagick.getquantumdepth.php
     * @return array the Imagick quantum depth as a string.
     */
    // quantumDepthLong:int, quantumDepthString:string
    #[ArrayShape(["quantumDepthLong" => "int", "quantumDepthString" => "string"])]
    public static function getQuantumDepth() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the Imagick quantum range
     * @link https://php.net/manual/en/imagick.getquantumrange.php
     * @return array the Imagick quantum range as a string.
     */
    #[ArrayShape(["quantumRangeLong" => "int", "quantumRangeString" => "string"])]
    public static function getQuantumRange() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the ImageMagick release date
     * @link https://php.net/manual/en/imagick.getreleasedate.php
     * @return string the ImageMagick release date as a string.
     */
    public static function getReleaseDate() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the specified resource's memory usage
     * @link https://php.net/manual/en/imagick.getresource.php
     * @param int $type 

     * Refer to the list of resourcetype constants.
     * 
     * @return int the specified resource's memory usage in megabytes.
     */
    public static function getResource($type) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the specified resource limit
     * @link https://php.net/manual/en/imagick.getresourcelimit.php
     * @param int $type 

     * Refer to the list of resourcetype constants.
     * 
     * @return int the specified resource limit in megabytes.
     */
    public static function getResourceLimit($type) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the horizontal and vertical sampling factor
     * @link https://php.net/manual/en/imagick.getsamplingfactors.php
     * @return array an associative array with the horizontal and vertical sampling
     * factors of the image.
     */
    #[Pure]
    public function getSamplingFactors() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the size associated with the Imagick object
     * @link https://php.net/manual/en/imagick.getsize.php
     * @return int[] the size associated with the Imagick object as an array with the
     * keys "columns" and "rows".
     * @throws ImagickException on error.
     */
    #[ArrayShape(["columns" => "int", "rows" => "int"])]
    #[Pure]
    public function getSize() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the ImageMagick API version
     * @link https://php.net/manual/en/imagick.getversion.php
     * @return array the ImageMagick API version as a string and as a number.
     */
    #[ArrayShape(["versionNumber" => "int", "versionString" => "string"])]
    public static function getVersion() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the object's default background color
     * @link https://php.net/manual/en/imagick.setbackgroundcolor.php
     * @param mixed $background
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setBackgroundColor($background) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the object's default compression type
     * @link https://php.net/manual/en/imagick.setcompression.php
     * @param int $compression
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setCompression($compression) {}

    /**
     * (PECL imagick 0.9.10-0.9.9)

     * Sets the object's default compression quality
     * @link https://php.net/manual/en/imagick.setcompressionquality.php
     * @param int $quality
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setCompressionQuality($quality) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the filename before you read or write the image
     * @link https://php.net/manual/en/imagick.setfilename.php
     * @param string $filename
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setFilename($filename) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the format of the Imagick object
     * @link https://php.net/manual/en/imagick.setformat.php
     * @param string $format
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setFormat($format) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image compression
     * @link https://php.net/manual/en/imagick.setinterlacescheme.php
     * @param int $interlace_scheme
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setInterlaceScheme($interlace_scheme) {}

    /**
     * (PECL imagick 2.0.0)

     * Set an option
     * @link https://php.net/manual/en/imagick.setoption.php
     * @param string $key
     * @param string $value
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setOption($key, $value) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the page geometry of the Imagick object
     * @link https://php.net/manual/en/imagick.setpage.php
     * @param int $width
     * @param int $height
     * @param int $x
     * @param int $y
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setPage($width, $height, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the limit for a particular resource in megabytes
     * @link https://php.net/manual/en/imagick.setresourcelimit.php
     * @param int $type 

     * Refer to the list of resourcetype constants.
     * 
     * @param int $limit 

     * The resource limit. The unit depends on the type of the resource being limited.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public static function setResourceLimit($type, $limit) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image resolution
     * @link https://php.net/manual/en/imagick.setresolution.php
     * @param float $x_resolution 

     * The horizontal resolution.
     * 
     * @param float $y_resolution 

     * The vertical resolution.
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setResolution($x_resolution, $y_resolution) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image sampling factors
     * @link https://php.net/manual/en/imagick.setsamplingfactors.php
     * @param array $factors
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setSamplingFactors(array $factors) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the size of the Imagick object
     * @link https://php.net/manual/en/imagick.setsize.php
     * @param int $columns
     * @param int $rows
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setSize($columns, $rows) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the image type attribute
     * @link https://php.net/manual/en/imagick.settype.php
     * @param int $image_type
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function setType($image_type) {}

    public function key() {}

    public function next() {}

    public function rewind() {}

    /**
     * (PECL imagick 2.0.0)

     * Checks if the current item is valid
     * @link https://php.net/manual/en/imagick.valid.php
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function valid() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a reference to the current Imagick object
     * @link https://php.net/manual/en/imagick.current.php
     * @return Imagick self on success.
     */
    public function current() {}

    /**
     * Change the brightness and/or contrast of an image. It converts the brightness and contrast parameters into slope and intercept and calls a polynomical function to apply to the image.
     * @link https://php.net/manual/en/imagick.brightnesscontrastimage.php
     * @param float $brightness
     * @param float $contrast
     * @param int $CHANNEL [optional]
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function brightnessContrastImage($brightness, $contrast, $CHANNEL = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Applies a user supplied kernel to the image according to the given morphology method.
     * @link https://php.net/manual/en/imagick.morphology.php
     * @param int $morphologyMethod Which morphology method to use one of the \Imagick::MORPHOLOGY_* constants.
     * @param int $iterations The number of iteration to apply the morphology function. A value of -1 means loop until no change found. How this is applied may depend on the morphology method. Typically this is a value of 1.
     * @param ImagickKernel $ImagickKernel
     * @param int $CHANNEL [optional]
     * @return void
     * @throws ImagickException on error.
     * @throws ImagickKernelException on error.
     * @since 3.3.0
     */
    public function morphology($morphologyMethod, $iterations, ImagickKernel $ImagickKernel, $CHANNEL = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Applies a custom convolution kernel to the image.
     * @link https://php.net/manual/en/imagick.filter.php
     * @param ImagickKernel $ImagickKernel An instance of ImagickKernel that represents either a single kernel or a linked series of kernels.
     * @param int $CHANNEL [optional] Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function filter(ImagickKernel $ImagickKernel, $CHANNEL = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Apply color transformation to an image. The method permits saturation changes, hue rotation, luminance to alpha, and various other effects. Although variable-sized transformation matrices can be used, typically one uses a 5x5 matrix for an RGBA image and a 6x6 for CMYKA (or RGBA with offsets).
     * The matrix is similar to those used by Adobe Flash except offsets are in column 6 rather than 5 (in support of CMYKA images) and offsets are normalized (divide Flash offset by 255)
     * @link https://php.net/manual/en/imagick.colormatriximage.php
     * @param array $color_matrix
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function colorMatrixImage($color_matrix = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Deletes an image property.
     * @link https://php.net/manual/en/imagick.deleteimageproperty.php
     * @param string $name The name of the property to delete.
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function deleteImageProperty($name) {}

    /**
     * Implements the discrete Fourier transform (DFT) of the image either as a magnitude / phase or real / imaginary image pair.
     * @link https://php.net/manual/en/imagick.forwardfouriertransformimage.php
     * @param bool $magnitude If true, return as magnitude / phase pair otherwise a real / imaginary image pair.
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function forwardFourierTransformimage($magnitude) {}

    /**
     * Gets the current image's compression type.
     * @link https://php.net/manual/en/imagick.getimagecompression.php
     * @return int
     * @since 3.3.0
     */
    #[Pure]
    public function getImageCompression() {}

    /**
     * Get the StringRegistry entry for the named key or false if not set.
     * @link https://php.net/manual/en/imagick.getregistry.php
     * @param string $key
     * @return string|false
     * @throws ImagickException Since version >= 3.4.3. Throws an exception if the key does not exist, rather than terminating the program.
     * @since 3.3.0
     */
    public static function getRegistry($key) {}

    /**
     * Returns the ImageMagick quantum range as an integer.
     * @link https://php.net/manual/en/imagick.getquantum.php
     * @return int
     * @since 3.3.0
     */
    public static function getQuantum() {}

    /**
     * Replaces any embedded formatting characters with the appropriate image property and returns the interpreted text. See https://www.imagemagick.org/script/escape.php for escape sequences.
     * @link https://php.net/manual/en/imagick.identifyformat.php
     * @see https://www.imagemagick.org/script/escape.php
     * @param string $embedText A string containing formatting sequences e.g. "Trim box: %@ number of unique colors: %k".
     * @return bool
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function identifyFormat($embedText) {}

    /**
     * Implements the inverse discrete Fourier transform (DFT) of the image either as a magnitude / phase or real / imaginary image pair.
     * @link https://php.net/manual/en/imagick.inversefouriertransformimage.php
     * @param Imagick $complement The second image to combine with this one to form either the magnitude / phase or real / imaginary image pair.
     * @param bool $magnitude If true, combine as magnitude / phase pair otherwise a real / imaginary image pair.
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function inverseFourierTransformImage($complement, $magnitude) {}

    /**
     * List all the registry settings. Returns an array of all the key/value pairs in the registry
     * @link https://php.net/manual/en/imagick.listregistry.php
     * @return array An array containing the key/values from the registry.
     * @since 3.3.0
     */
    public static function listRegistry() {}

    /**
     * Rotational blurs an image.
     * @link https://php.net/manual/en/imagick.rotationalblurimage.php
     * @param float $angle
     * @param int $CHANNEL
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function rotationalBlurImage($angle, $CHANNEL = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Selectively blur an image within a contrast threshold. It is similar to the unsharpen mask that sharpens everything with contrast above a certain threshold.
     * @link https://php.net/manual/en/imagick.selectiveblurimage.php
     * @param float $radius
     * @param float $sigma
     * @param float $threshold
     * @param int $CHANNEL Provide any channel constant that is valid for your channel mode. To apply to more than one channel, combine channel constants using bitwise operators. Defaults to Imagick::CHANNEL_DEFAULT. Refer to this list of channel constants
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function selectiveBlurImage($radius, $sigma, $threshold, $CHANNEL = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Set whether antialiasing should be used for operations. On by default.
     * @param bool $antialias
     * @return int
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function setAntiAlias($antialias) {}

    /**
     * @link https://php.net/manual/en/imagick.setimagebiasquantum.php
     * @param string $bias
     * @return void
     * @since 3.3.0
     */
    public function setImageBiasQuantum($bias) {}

    /**
     * Set a callback that will be called during the processing of the Imagick image.
     * @link https://php.net/manual/en/imagick.setprogressmonitor.php
     * @param callable $callback The progress function to call. It should return true if image processing should continue, or false if it should be cancelled.
     * The offset parameter indicates the progress and the span parameter indicates the total amount of work needed to be done.
     * 
 bool callback ( mixed $offset , mixed $span ) 
     * Caution
     * The values passed to the callback function are not consistent. In particular the span parameter can increase during image processing. Because of this calculating the percentage complete of an image operation is not trivial.
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function setProgressMonitor($callback) {}

    /**
     * Sets the ImageMagick registry entry named key to value. This is most useful for setting "temporary-path" which controls where ImageMagick creates temporary images e.g. while processing PDFs.
     * @link https://php.net/manual/en/imagick.setregistry.php
     * @param string $key
     * @param string $value
     * @return void
     * @since 3.3.0
     */
    public static function setRegistry($key, $value) {}

    /**
     * Replace each pixel with corresponding statistic from the neighborhood of the specified width and height.
     * @link https://php.net/manual/en/imagick.statisticimage.php
     * @param int $type
     * @param int $width
     * @param int $height
     * @param int $channel [optional]
     * @return void
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function statisticImage($type, $width, $height, $channel = Imagick::CHANNEL_DEFAULT) {}

    /**
     * Searches for a subimage in the current image and returns a similarity image such that an exact match location is
     * completely white and if none of the pixels match, black, otherwise some gray level in-between.
     * You can also pass in the optional parameters bestMatch and similarity. After calling the function similarity will
     * be set to the 'score' of the similarity between the subimage and the matching position in the larger image,
     * bestMatch will contain an associative array with elements x, y, width, height that describe the matching region.
     *
     * @link https://php.net/manual/en/imagick.subimagematch.php
     * @param Imagick $imagick
     * @param array &$bestMatch [optional]
     * @param float &$similarity [optional] A new image that displays the amount of similarity at each pixel.
     * @param float $similarity_threshold [optional] Only used if compiled with ImageMagick (library) > 7
     * @param int $metric [optional] Only used if compiled with ImageMagick (library) > 7
     * @return Imagick
     * @throws ImagickException on error.
     * @since 3.3.0
     */
    public function subImageMatch(Imagick $imagick, array &$bestMatch, &$similarity, $similarity_threshold, $metric) {}

    /**
     * Is an alias of Imagick::subImageMatch
     *
     * @param Imagick $imagick
     * @param array &$bestMatch [optional]
     * @param float &$similarity [optional] A new image that displays the amount of similarity at each pixel.
     * @param float $similarity_threshold [optional]
     * @param int $metric [optional]
     * @return Imagick
     * @throws ImagickException on error.
     * @see Imagick::subImageMatch() This function is an alias of subImageMatch()
     * @since 3.4.0
     */
    public function similarityImage(Imagick $imagick, array &$bestMatch, &$similarity, $similarity_threshold, $metric) {}

    /**
     * Returns any ImageMagick  configure options that match the specified pattern (e.g. "*" for all). Options include NAME, VERSION, LIB_VERSION, etc.
     * @return string
     * @since 3.4.0
     */
    #[Pure]
    public function getConfigureOptions() {}

    /**
     * GetFeatures() returns the ImageMagick features that have been compiled into the runtime.
     * @return string
     * @since 3.4.0
     */
    #[Pure]
    public function getFeatures() {}

    /**
     * @return int
     * @since 3.4.0
     */
    #[Pure]
    public function getHDRIEnabled() {}

    /**
     * Sets the image channel mask. Returns the previous set channel mask.
     * Only works with Imagick >= 7
     * @param int $channel
     * @throws ImagickException on error.
     * @since 3.4.0
     */
    public function setImageChannelMask($channel) {}

    /**
     * Merge multiple images of the same size together with the selected operator. https://www.imagemagick.org/Usage/layers/#evaluate-sequence
     * @param int $EVALUATE_CONSTANT
     * @return bool
     * @see https://www.imagemagick.org/Usage/layers/#evaluate-sequence
     * @throws ImagickException on error.
     * @since 3.4.0
     */
    public function evaluateImages($EVALUATE_CONSTANT) {}

    /**
     * Extracts the 'mean' from the image and adjust the image to try make set its gamma appropriately.
     * @param int $channel [optional] Default value Imagick::CHANNEL_ALL
     * @return bool
     * @throws ImagickException on error.
     * @since 3.4.1
     */
    public function autoGammaImage($channel = Imagick::CHANNEL_ALL) {}

    /**
     * Adjusts an image so that its orientation is suitable $ for viewing (i.e. top-left orientation).
     * @return bool
     * @throws ImagickException on error.
     * @since 3.4.1
     */
    public function autoOrient() {}

    /**
     * Composite one image onto another using the specified gravity.
     *
     * @param Imagick $imagick
     * @param int $COMPOSITE_CONSTANT
     * @param int $GRAVITY_CONSTANT
     * @return bool
     * @throws ImagickException on error.
     * @since 3.4.1
     */
    public function compositeImageGravity(Imagick $imagick, $COMPOSITE_CONSTANT, $GRAVITY_CONSTANT) {}

    /**
     * Attempts to increase the appearance of large-scale light-dark transitions.
     *
     * @param float $radius
     * @param float $strength
     * @return bool
     * @throws ImagickException on error.
     * @since 3.4.1
     */
    public function localContrastImage($radius, $strength) {}

    /**
     * Identifies the potential image type, returns one of the Imagick::IMGTYPE_* constants
     * @return int
     * @throws ImagickException on error.
     * @since 3.4.3
     */
    public function identifyImageType() {}

    /**
     * Sets the image to the specified alpha level. Will replace ImagickDraw::setOpacity()
     *
     * @param float $alpha
     * @return bool
     * @throws ImagickException on error.
     * @since 3.4.3
     */
    public function setImageAlpha($alpha) {}
}

/**
 * @method ImagickDraw clone() (PECL imagick 2.0.0)
Makes an exact copy of the specified ImagickDraw object
 * @link https://php.net/manual/en/class.imagickdraw.php
 */
class ImagickDraw
{
    public function resetVectorGraphics() {}

    #[Pure]
    public function getTextKerning() {}

    /**
     * @param float $kerning
     */
    public function setTextKerning($kerning) {}

    #[Pure]
    public function getTextInterWordSpacing() {}

    /**
     * @param $spacing
     */
    public function setTextInterWordSpacing($spacing) {}

    #[Pure]
    public function getTextInterLineSpacing() {}

    /**
     * @param $spacing
     */
    public function setTextInterLineSpacing($spacing) {}

    /**
     * (PECL imagick 2.0.0)

     * The ImagickDraw constructor
     * @link https://php.net/manual/en/imagickdraw.construct.php
     */
    public function __construct() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the fill color to be used for drawing filled objects
     * @link https://php.net/manual/en/imagickdraw.setfillcolor.php
     * @param ImagickPixel $fill_pixel 

     * ImagickPixel to use to set the color
     * 
     * @return bool No value is returned.
     * @throws ImagickDrawException on error.
     */
    public function setFillColor(ImagickPixel $fill_pixel) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the opacity to use when drawing using the fill color or fill texture
     * @link https://php.net/manual/en/imagickdraw.setfillalpha.php
     * @param float $opacity 

     * fill alpha
     * 
     * @return bool No value is returned.
     */
    #[Deprecated]
    public function setFillAlpha($opacity) {}

    /**
     * Sets the image resolution
     * @param float $x_resolution 
The horizontal resolution.
     * @param float $y_resolution 
The vertical resolution.
     * @return bool
     * @throws ImagickDrawException on error.
     */
    public function setResolution($x_resolution, $y_resolution) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the color used for stroking object outlines
     * @link https://php.net/manual/en/imagickdraw.setstrokecolor.php
     * @param ImagickPixel $stroke_pixel 

     * the stroke color
     * 
     * @return bool No value is returned.
     * @throws ImagickDrawException on error.
     */
    public function setStrokeColor(ImagickPixel $stroke_pixel) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the opacity of stroked object outlines
     * @link https://php.net/manual/en/imagickdraw.setstrokealpha.php
     * @param float $opacity 

     * opacity
     * 
     * @return bool No value is returned.
     */
    #[Deprecated]
    public function setStrokeAlpha($opacity) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the width of the stroke used to draw object outlines
     * @link https://php.net/manual/en/imagickdraw.setstrokewidth.php
     * @param float $stroke_width 

     * stroke width
     * 
     * @return bool No value is returned.
     */
    public function setStrokeWidth($stroke_width) {}

    /**
     * (PECL imagick 2.0.0)

     * Clears the ImagickDraw
     * @link https://php.net/manual/en/imagickdraw.clear.php
     * @return bool an ImagickDraw object.
     */
    public function clear() {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a circle
     * @link https://php.net/manual/en/imagickdraw.circle.php
     * @param float $ox 

     * origin x coordinate
     * 
     * @param float $oy 

     * origin y coordinate
     * 
     * @param float $px 

     * perimeter x coordinate
     * 
     * @param float $py 

     * perimeter y coordinate
     * 
     * @return bool No value is returned.
     */
    public function circle($ox, $oy, $px, $py) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws text on the image
     * @link https://php.net/manual/en/imagickdraw.annotation.php
     * @param float $x 

     * The x coordinate where text is drawn
     * 
     * @param float $y 

     * The y coordinate where text is drawn
     * 
     * @param string $text 

     * The text to draw on the image
     * 
     * @return bool No value is returned.
     * @throws ImagickDrawException on error.
     */
    public function annotation($x, $y, $text) {}

    /**
     * (PECL imagick 2.0.0)

     * Controls whether text is antialiased
     * @link https://php.net/manual/en/imagickdraw.settextantialias.php
     * @param bool $antiAlias
     * @return bool No value is returned.
     */
    public function setTextAntialias($antiAlias) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies specifies the text code set
     * @link https://php.net/manual/en/imagickdraw.settextencoding.php
     * @param string $encoding 

     * the encoding name
     * 
     * @return bool No value is returned.
     */
    public function setTextEncoding($encoding) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the fully-specified font to use when annotating with text
     * @link https://php.net/manual/en/imagickdraw.setfont.php
     * @param string $font_name
     * @return bool TRUE on success.
     * @throws ImagickDrawException on error.
     * @throws ImagickException on error.
     */
    public function setFont($font_name) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the font family to use when annotating with text
     * @link https://php.net/manual/en/imagickdraw.setfontfamily.php
     * @param string $font_family 

     * the font family
     * 
     * @return bool TRUE on success.
     * @throws ImagickDrawException on error.
     * @throws ImagickException on error.
     */
    public function setFontFamily($font_family) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the font pointsize to use when annotating with text
     * @link https://php.net/manual/en/imagickdraw.setfontsize.php
     * @param float $pointsize 

     * the point size
     * 
     * @return bool No value is returned.
     */
    public function setFontSize($pointsize) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the font style to use when annotating with text
     * @link https://php.net/manual/en/imagickdraw.setfontstyle.php
     * @param int $style 

     * STYLETYPE_ constant
     * 
     * @return bool No value is returned.
     */
    public function setFontStyle($style) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the font weight
     * @link https://php.net/manual/en/imagickdraw.setfontweight.php
     * @param int $font_weight
     * @return bool
     * @throws ImagickDrawException on error.
     */
    public function setFontWeight($font_weight) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the font
     * @link https://php.net/manual/en/imagickdraw.getfont.php
     * @return string|false a string on success and false if no font is set.
     */
    #[Pure]
    public function getFont() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the font family
     * @link https://php.net/manual/en/imagickdraw.getfontfamily.php
     * @return string|false the font family currently selected or false if font family is not set.
     */
    #[Pure]
    public function getFontFamily() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the font pointsize
     * @link https://php.net/manual/en/imagickdraw.getfontsize.php
     * @return float the font size associated with the current ImagickDraw object.
     */
    #[Pure]
    public function getFontSize() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the font style
     * @link https://php.net/manual/en/imagickdraw.getfontstyle.php
     * @return int the font style constant (STYLE_) associated with the ImagickDraw object
     * or 0 if no style is set.
     */
    #[Pure]
    public function getFontStyle() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the font weight
     * @link https://php.net/manual/en/imagickdraw.getfontweight.php
     * @return int an int on success and 0 if no weight is set.
     */
    #[Pure]
    public function getFontWeight() {}

    /**
     * (PECL imagick 2.0.0)

     * Frees all associated resources
     * @link https://php.net/manual/en/imagickdraw.destroy.php
     * @return bool No value is returned.
     */
    public function destroy() {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a rectangle
     * @link https://php.net/manual/en/imagickdraw.rectangle.php
     * @param float $x1 

     * x coordinate of the top left corner
     * 
     * @param float $y1 

     * y coordinate of the top left corner
     * 
     * @param float $x2 

     * x coordinate of the bottom right corner
     * 
     * @param float $y2 

     * y coordinate of the bottom right corner
     * 
     * @return bool No value is returned.
     */
    public function rectangle($x1, $y1, $x2, $y2) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a rounded rectangle
     * @link https://php.net/manual/en/imagickdraw.roundrectangle.php
     * @param float $x1 

     * x coordinate of the top left corner
     * 
     * @param float $y1 

     * y coordinate of the top left corner
     * 
     * @param float $x2 

     * x coordinate of the bottom right
     * 
     * @param float $y2 

     * y coordinate of the bottom right
     * 
     * @param float $rx 

     * x rounding
     * 
     * @param float $ry 

     * y rounding
     * 
     * @return bool No value is returned.
     */
    public function roundRectangle($x1, $y1, $x2, $y2, $rx, $ry) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws an ellipse on the image
     * @link https://php.net/manual/en/imagickdraw.ellipse.php
     * @param float $ox
     * @param float $oy
     * @param float $rx
     * @param float $ry
     * @param float $start
     * @param float $end
     * @return bool No value is returned.
     */
    public function ellipse($ox, $oy, $rx, $ry, $start, $end) {}

    /**
     * (PECL imagick 2.0.0)

     * Skews the current coordinate system in the horizontal direction
     * @link https://php.net/manual/en/imagickdraw.skewx.php
     * @param float $degrees 

     * degrees to skew
     * 
     * @return bool No value is returned.
     */
    public function skewX($degrees) {}

    /**
     * (PECL imagick 2.0.0)

     * Skews the current coordinate system in the vertical direction
     * @link https://php.net/manual/en/imagickdraw.skewy.php
     * @param float $degrees 

     * degrees to skew
     * 
     * @return bool No value is returned.
     */
    public function skewY($degrees) {}

    /**
     * (PECL imagick 2.0.0)

     * Applies a translation to the current coordinate system
     * @link https://php.net/manual/en/imagickdraw.translate.php
     * @param float $x 

     * horizontal translation
     * 
     * @param float $y 

     * vertical translation
     * 
     * @return bool No value is returned.
     */
    public function translate($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a line
     * @link https://php.net/manual/en/imagickdraw.line.php
     * @param float $sx 

     * starting x coordinate
     * 
     * @param float $sy 

     * starting y coordinate
     * 
     * @param float $ex 

     * ending x coordinate
     * 
     * @param float $ey 

     * ending y coordinate
     * 
     * @return bool No value is returned.
     */
    public function line($sx, $sy, $ex, $ey) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws an arc
     * @link https://php.net/manual/en/imagickdraw.arc.php
     * @param float $sx 

     * Starting x ordinate of bounding rectangle
     * 
     * @param float $sy 

     * starting y ordinate of bounding rectangle
     * 
     * @param float $ex 

     * ending x ordinate of bounding rectangle
     * 
     * @param float $ey 

     * ending y ordinate of bounding rectangle
     * 
     * @param float $sd 

     * starting degrees of rotation
     * 
     * @param float $ed 

     * ending degrees of rotation
     * 
     * @return bool No value is returned.
     */
    public function arc($sx, $sy, $ex, $ey, $sd, $ed) {}

    /**
     * (PECL imagick 2.0.0)

     * Paints on the image's opacity channel
     * @link https://php.net/manual/en/imagickdraw.matte.php
     * @param float $x 

     * x coordinate of the matte
     * 
     * @param float $y 

     * y coordinate of the matte
     * 
     * @param int $paintMethod 

     * PAINT_ constant
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    public function matte($x, $y, $paintMethod) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a polygon
     * @link https://php.net/manual/en/imagickdraw.polygon.php
     * @param array $coordinates 

     * multidimensional array like array( array( 'x' => 3, 'y' => 4 ), array( 'x' => 2, 'y' => 6 ) );
     * 
     * @return bool TRUE on success.
     * @throws ImagickDrawException on error.
     */
    public function polygon(array $coordinates) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a point
     * @link https://php.net/manual/en/imagickdraw.point.php
     * @param float $x 

     * point's x coordinate
     * 
     * @param float $y 

     * point's y coordinate
     * 
     * @return bool No value is returned.
     */
    public function point($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the text decoration
     * @link https://php.net/manual/en/imagickdraw.gettextdecoration.php
     * @return int one of the DECORATION_ constants
     * and 0 if no decoration is set.
     */
    #[Pure]
    public function getTextDecoration() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the code set used for text annotations
     * @link https://php.net/manual/en/imagickdraw.gettextencoding.php
     * @return string a string specifying the code set
     * or false if text encoding is not set.
     */
    #[Pure]
    public function getTextEncoding() {}

    #[Pure]
    public function getFontStretch() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the font stretch to use when annotating with text
     * @link https://php.net/manual/en/imagickdraw.setfontstretch.php
     * @param int $fontStretch 

     * STRETCH_ constant
     * 
     * @return bool No value is returned.
     */
    public function setFontStretch($fontStretch) {}

    /**
     * (PECL imagick 2.0.0)

     * Controls whether stroked outlines are antialiased
     * @link https://php.net/manual/en/imagickdraw.setstrokeantialias.php
     * @param bool $stroke_antialias 

     * the antialias setting
     * 
     * @return bool No value is returned.
     */
    public function setStrokeAntialias($stroke_antialias) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies a text alignment
     * @link https://php.net/manual/en/imagickdraw.settextalignment.php
     * @param int $alignment 

     * ALIGN_ constant
     * 
     * @return bool No value is returned.
     */
    public function setTextAlignment($alignment) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies a decoration
     * @link https://php.net/manual/en/imagickdraw.settextdecoration.php
     * @param int $decoration 

     * DECORATION_ constant
     * 
     * @return bool No value is returned.
     */
    public function setTextDecoration($decoration) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the color of a background rectangle
     * @link https://php.net/manual/en/imagickdraw.settextundercolor.php
     * @param ImagickPixel $under_color 

     * the under color
     * 
     * @return bool No value is returned.
     * @throws ImagickDrawException on error.
     */
    public function setTextUnderColor(ImagickPixel $under_color) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the overall canvas size
     * @link https://php.net/manual/en/imagickdraw.setviewbox.php
     * @param int $x1 

     * left x coordinate
     * 
     * @param int $y1 

     * left y coordinate
     * 
     * @param int $x2 

     * right x coordinate
     * 
     * @param int $y2 

     * right y coordinate
     * 
     * @return bool No value is returned.
     */
    public function setViewbox($x1, $y1, $x2, $y2) {}

    /**
     * (PECL imagick 2.0.0)

     * Adjusts the current affine transformation matrix
     * @link https://php.net/manual/en/imagickdraw.affine.php
     * @param array $affine 

     * Affine matrix parameters
     * 
     * @return bool No value is returned.
     * @throws ImagickDrawException on error.
     */
    public function affine(array $affine) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a bezier curve
     * @link https://php.net/manual/en/imagickdraw.bezier.php
     * @param array $coordinates 

     * Multidimensional array like array( array( 'x' => 1, 'y' => 2 ),
     * array( 'x' => 3, 'y' => 4 ) )
     * 
     * @return bool No value is returned.
     * @throws ImagickDrawException on error.
     */
    public function bezier(array $coordinates) {}

    /**
     * (PECL imagick 2.0.0)

     * Composites an image onto the current image
     * @link https://php.net/manual/en/imagickdraw.composite.php
     * @param int $compose 

     * composition operator. One of COMPOSITE_ constants
     * 
     * @param float $x 

     * x coordinate of the top left corner
     * 
     * @param float $y 

     * y coordinate of the top left corner
     * 
     * @param float $width 

     * width of the composition image
     * 
     * @param float $height 

     * height of the composition image
     * 
     * @param Imagick $compositeWand 

     * the Imagick object where composition image is taken from
     * 
     * @return bool TRUE on success.
     * @throws ImagickException on error.
     */
    public function composite($compose, $x, $y, $width, $height, Imagick $compositeWand) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws color on image
     * @link https://php.net/manual/en/imagickdraw.color.php
     * @param float $x 

     * x coordinate of the paint
     * 
     * @param float $y 

     * y coordinate of the paint
     * 
     * @param int $paintMethod 

     * one of the PAINT_ constants
     * 
     * @return bool No value is returned.
     */
    public function color($x, $y, $paintMethod) {}

    /**
     * (PECL imagick 2.0.0)

     * Adds a comment
     * @link https://php.net/manual/en/imagickdraw.comment.php
     * @param string $comment 

     * The comment string to add to vector output stream
     * 
     * @return bool No value is returned.
     */
    public function comment($comment) {}

    /**
     * (PECL imagick 2.0.0)

     * Obtains the current clipping path ID
     * @link https://php.net/manual/en/imagickdraw.getclippath.php
     * @return string|false a string containing the clip path ID or false if no clip path exists.
     */
    #[Pure]
    public function getClipPath() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the current polygon fill rule
     * @link https://php.net/manual/en/imagickdraw.getcliprule.php
     * @return int one of the FILLRULE_ constants.
     */
    #[Pure]
    public function getClipRule() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the interpretation of clip path units
     * @link https://php.net/manual/en/imagickdraw.getclipunits.php
     * @return int an int on success.
     */
    #[Pure]
    public function getClipUnits() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the fill color
     * @link https://php.net/manual/en/imagickdraw.getfillcolor.php
     * @return ImagickPixel an ImagickPixel object.
     */
    #[Pure]
    public function getFillColor() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the opacity used when drawing
     * @link https://php.net/manual/en/imagickdraw.getfillopacity.php
     * @return float The opacity.
     */
    #[Pure]
    public function getFillOpacity() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the fill rule
     * @link https://php.net/manual/en/imagickdraw.getfillrule.php
     * @return int a FILLRULE_ constant
     */
    #[Pure]
    public function getFillRule() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the text placement gravity
     * @link https://php.net/manual/en/imagickdraw.getgravity.php
     * @return int a GRAVITY_ constant on success and 0 if no gravity is set.
     */
    #[Pure]
    public function getGravity() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the current stroke antialias setting
     * @link https://php.net/manual/en/imagickdraw.getstrokeantialias.php
     * @return bool TRUE if antialiasing is on and false if it is off.
     */
    #[Pure]
    public function getStrokeAntialias() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the color used for stroking object outlines
     * @link https://php.net/manual/en/imagickdraw.getstrokecolor.php
     * @return ImagickPixel an ImagickPixel object which describes the color.
     */
    #[Pure]
    public function getStrokeColor() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns an array representing the pattern of dashes and gaps used to stroke paths
     * @link https://php.net/manual/en/imagickdraw.getstrokedasharray.php
     * @return array an array on success and empty array if not set.
     */
    #[Pure]
    public function getStrokeDashArray() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the offset into the dash pattern to start the dash
     * @link https://php.net/manual/en/imagickdraw.getstrokedashoffset.php
     * @return float a float representing the offset and 0 if it's not set.
     */
    #[Pure]
    public function getStrokeDashOffset() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the shape to be used at the end of open subpaths when they are stroked
     * @link https://php.net/manual/en/imagickdraw.getstrokelinecap.php
     * @return int one of the LINECAP_ constants or 0 if stroke linecap is not set.
     */
    #[Pure]
    public function getStrokeLineCap() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the shape to be used at the corners of paths when they are stroked
     * @link https://php.net/manual/en/imagickdraw.getstrokelinejoin.php
     * @return int one of the LINEJOIN_ constants or 0 if stroke line join is not set.
     */
    #[Pure]
    public function getStrokeLineJoin() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the stroke miter limit
     * @link https://php.net/manual/en/imagickdraw.getstrokemiterlimit.php
     * @return int an int describing the miter limit
     * and 0 if no miter limit is set.
     */
    #[Pure]
    public function getStrokeMiterLimit() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the opacity of stroked object outlines
     * @link https://php.net/manual/en/imagickdraw.getstrokeopacity.php
     * @return float a float describing the opacity.
     */
    #[Pure]
    public function getStrokeOpacity() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the width of the stroke used to draw object outlines
     * @link https://php.net/manual/en/imagickdraw.getstrokewidth.php
     * @return float a float describing the stroke width.
     */
    #[Pure]
    public function getStrokeWidth() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the text alignment
     * @link https://php.net/manual/en/imagickdraw.gettextalignment.php
     * @return int one of the ALIGN_ constants and 0 if no align is set.
     */
    #[Pure]
    public function getTextAlignment() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the current text antialias setting
     * @link https://php.net/manual/en/imagickdraw.gettextantialias.php
     * @return bool TRUE if text is antialiased and false if not.
     */
    #[Pure]
    public function getTextAntialias() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a string containing vector graphics
     * @link https://php.net/manual/en/imagickdraw.getvectorgraphics.php
     * @return string a string containing the vector graphics.
     */
    #[Pure]
    public function getVectorGraphics() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the text under color
     * @link https://php.net/manual/en/imagickdraw.gettextundercolor.php
     * @return ImagickPixel an ImagickPixel object describing the color.
     * @throws ImagickDrawException on error.
     */
    #[Pure]
    public function getTextUnderColor() {}

    /**
     * (PECL imagick 2.0.0)

     * Adds a path element to the current path
     * @link https://php.net/manual/en/imagickdraw.pathclose.php
     * @return bool No value is returned.
     */
    public function pathClose() {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a cubic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetoabsolute.php
     * @param float $x1 

     * x coordinate of the first control point
     * 
     * @param float $y1 

     * y coordinate of the first control point
     * 
     * @param float $x2 

     * x coordinate of the second control point
     * 
     * @param float $y2 

     * y coordinate of the first control point
     * 
     * @param float $x 

     * x coordinate of the curve end
     * 
     * @param float $y 

     * y coordinate of the curve end
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToAbsolute($x1, $y1, $x2, $y2, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a cubic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetorelative.php
     * @param float $x1 

     * x coordinate of starting control point
     * 
     * @param float $y1 

     * y coordinate of starting control point
     * 
     * @param float $x2 

     * x coordinate of ending control point
     * 
     * @param float $y2 

     * y coordinate of ending control point
     * 
     * @param float $x 

     * ending x coordinate
     * 
     * @param float $y 

     * ending y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToRelative($x1, $y1, $x2, $y2, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a quadratic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetoquadraticbezierabsolute.php
     * @param float $x1 

     * x coordinate of the control point
     * 
     * @param float $y1 

     * y coordinate of the control point
     * 
     * @param float $x 

     * x coordinate of the end point
     * 
     * @param float $y 

     * y coordinate of the end point
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToQuadraticBezierAbsolute($x1, $y1, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a quadratic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetoquadraticbezierrelative.php
     * @param float $x1 

     * starting x coordinate
     * 
     * @param float $y1 

     * starting y coordinate
     * 
     * @param float $x 

     * ending x coordinate
     * 
     * @param float $y 

     * ending y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToQuadraticBezierRelative($x1, $y1, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a quadratic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetoquadraticbeziersmoothabsolute.php
     * @param float $x 

     * ending x coordinate
     * 
     * @param float $y 

     * ending y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToQuadraticBezierSmoothAbsolute($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a quadratic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetoquadraticbeziersmoothrelative.php
     * @param float $x 

     * ending x coordinate
     * 
     * @param float $y 

     * ending y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToQuadraticBezierSmoothRelative($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a cubic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetosmoothabsolute.php
     * @param float $x2 

     * x coordinate of the second control point
     * 
     * @param float $y2 

     * y coordinate of the second control point
     * 
     * @param float $x 

     * x coordinate of the ending point
     * 
     * @param float $y 

     * y coordinate of the ending point
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToSmoothAbsolute($x2, $y2, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a cubic Bezier curve
     * @link https://php.net/manual/en/imagickdraw.pathcurvetosmoothrelative.php
     * @param float $x2 

     * x coordinate of the second control point
     * 
     * @param float $y2 

     * y coordinate of the second control point
     * 
     * @param float $x 

     * x coordinate of the ending point
     * 
     * @param float $y 

     * y coordinate of the ending point
     * 
     * @return bool No value is returned.
     */
    public function pathCurveToSmoothRelative($x2, $y2, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws an elliptical arc
     * @link https://php.net/manual/en/imagickdraw.pathellipticarcabsolute.php
     * @param float $rx 

     * x radius
     * 
     * @param float $ry 

     * y radius
     * 
     * @param float $x_axis_rotation 

     * x axis rotation
     * 
     * @param bool $large_arc_flag 

     * large arc flag
     * 
     * @param bool $sweep_flag 

     * sweep flag
     * 
     * @param float $x 

     * x coordinate
     * 
     * @param float $y 

     * y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathEllipticArcAbsolute($rx, $ry, $x_axis_rotation, $large_arc_flag, $sweep_flag, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws an elliptical arc
     * @link https://php.net/manual/en/imagickdraw.pathellipticarcrelative.php
     * @param float $rx 

     * x radius
     * 
     * @param float $ry 

     * y radius
     * 
     * @param float $x_axis_rotation 

     * x axis rotation
     * 
     * @param bool $large_arc_flag 

     * large arc flag
     * 
     * @param bool $sweep_flag 

     * sweep flag
     * 
     * @param float $x 

     * x coordinate
     * 
     * @param float $y 

     * y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathEllipticArcRelative($rx, $ry, $x_axis_rotation, $large_arc_flag, $sweep_flag, $x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Terminates the current path
     * @link https://php.net/manual/en/imagickdraw.pathfinish.php
     * @return bool No value is returned.
     */
    public function pathFinish() {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a line path
     * @link https://php.net/manual/en/imagickdraw.pathlinetoabsolute.php
     * @param float $x 

     * starting x coordinate
     * 
     * @param float $y 

     * ending x coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathLineToAbsolute($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a line path
     * @link https://php.net/manual/en/imagickdraw.pathlinetorelative.php
     * @param float $x 

     * starting x coordinate
     * 
     * @param float $y 

     * starting y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathLineToRelative($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a horizontal line path
     * @link https://php.net/manual/en/imagickdraw.pathlinetohorizontalabsolute.php
     * @param float $x 

     * x coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathLineToHorizontalAbsolute($x) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a horizontal line
     * @link https://php.net/manual/en/imagickdraw.pathlinetohorizontalrelative.php
     * @param float $x 

     * x coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathLineToHorizontalRelative($x) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a vertical line
     * @link https://php.net/manual/en/imagickdraw.pathlinetoverticalabsolute.php
     * @param float $y 

     * y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathLineToVerticalAbsolute($y) {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a vertical line path
     * @link https://php.net/manual/en/imagickdraw.pathlinetoverticalrelative.php
     * @param float $y 

     * y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathLineToVerticalRelative($y) {}

    /**
     * (PECL imagick 2.0.0)

     * Starts a new sub-path
     * @link https://php.net/manual/en/imagickdraw.pathmovetoabsolute.php
     * @param float $x 

     * x coordinate of the starting point
     * 
     * @param float $y 

     * y coordinate of the starting point
     * 
     * @return bool No value is returned.
     */
    public function pathMoveToAbsolute($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Starts a new sub-path
     * @link https://php.net/manual/en/imagickdraw.pathmovetorelative.php
     * @param float $x 

     * target x coordinate
     * 
     * @param float $y 

     * target y coordinate
     * 
     * @return bool No value is returned.
     */
    public function pathMoveToRelative($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Declares the start of a path drawing list
     * @link https://php.net/manual/en/imagickdraw.pathstart.php
     * @return bool No value is returned.
     */
    public function pathStart() {}

    /**
     * (PECL imagick 2.0.0)

     * Draws a polyline
     * @link https://php.net/manual/en/imagickdraw.polyline.php
     * @param array $coordinates 

     * array of x and y coordinates: array( array( 'x' => 4, 'y' => 6 ), array( 'x' => 8, 'y' => 10 ) )
     * 
     * @return bool TRUE on success.
     * @throws ImagickDrawException on error.
     */
    public function polyline(array $coordinates) {}

    /**
     * (PECL imagick 2.0.0)

     * Terminates a clip path definition
     * @link https://php.net/manual/en/imagickdraw.popclippath.php
     * @return bool No value is returned.
     */
    public function popClipPath() {}

    /**
     * (PECL imagick 2.0.0)

     * Terminates a definition list
     * @link https://php.net/manual/en/imagickdraw.popdefs.php
     * @return bool No value is returned.
     */
    public function popDefs() {}

    /**
     * (PECL imagick 2.0.0)

     * Terminates a pattern definition
     * @link https://php.net/manual/en/imagickdraw.poppattern.php
     * @return bool TRUE on success or FALSE on failure.
     * @throws ImagickException on error.
     */
    public function popPattern() {}

    /**
     * (PECL imagick 2.0.0)

     * Starts a clip path definition
     * @link https://php.net/manual/en/imagickdraw.pushclippath.php
     * @param string $clip_mask_id 

     * Clip mask Id
     * 
     * @return bool No value is returned.
     */
    public function pushClipPath($clip_mask_id) {}

    /**
     * (PECL imagick 2.0.0)

     * Indicates that following commands create named elements for early processing
     * @link https://php.net/manual/en/imagickdraw.pushdefs.php
     * @return bool No value is returned.
     */
    public function pushDefs() {}

    /**
     * (PECL imagick 2.0.0)

     * Indicates that subsequent commands up to a ImagickDraw::opPattern() command comprise the definition of a named pattern
     * @link https://php.net/manual/en/imagickdraw.pushpattern.php
     * @param string $pattern_id 

     * the pattern Id
     * 
     * @param float $x 

     * x coordinate of the top-left corner
     * 
     * @param float $y 

     * y coordinate of the top-left corner
     * 
     * @param float $width 

     * width of the pattern
     * 
     * @param float $height 

     * height of the pattern
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    public function pushPattern($pattern_id, $x, $y, $width, $height) {}

    /**
     * (PECL imagick 2.0.0)

     * Renders all preceding drawing commands onto the image
     * @link https://php.net/manual/en/imagickdraw.render.php
     * @return bool TRUE on success or FALSE on failure.
     * @throws ImagickException on error.
     */
    public function render() {}

    /**
     * (PECL imagick 2.0.0)

     * Applies the specified rotation to the current coordinate space
     * @link https://php.net/manual/en/imagickdraw.rotate.php
     * @param float $degrees 

     * degrees to rotate
     * 
     * @return bool No value is returned.
     */
    public function rotate($degrees) {}

    /**
     * (PECL imagick 2.0.0)

     * Adjusts the scaling factor
     * @link https://php.net/manual/en/imagickdraw.scale.php
     * @param float $x 

     * horizontal factor
     * 
     * @param float $y 

     * vertical factor
     * 
     * @return bool No value is returned.
     */
    public function scale($x, $y) {}

    /**
     * (PECL imagick 2.0.0)

     * Associates a named clipping path with the image
     * @link https://php.net/manual/en/imagickdraw.setclippath.php
     * @param string $clip_mask 

     * the clipping path name
     * 
     * @return bool No value is returned.
     * @throws ImagickException on error.
     */
    public function setClipPath($clip_mask) {}

    /**
     * (PECL imagick 2.0.0)

     * Set the polygon fill rule to be used by the clipping path
     * @link https://php.net/manual/en/imagickdraw.setcliprule.php
     * @param int $fill_rule 

     * FILLRULE_ constant
     * 
     * @return bool No value is returned.
     */
    public function setClipRule($fill_rule) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the interpretation of clip path units
     * @link https://php.net/manual/en/imagickdraw.setclipunits.php
     * @param int $clip_units 

     * the number of clip units
     * 
     * @return bool No value is returned.
     */
    public function setClipUnits($clip_units) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the opacity to use when drawing using the fill color or fill texture
     * @link https://php.net/manual/en/imagickdraw.setfillopacity.php
     * @param float $fillOpacity 

     * the fill opacity
     * 
     * @return bool No value is returned.
     */
    public function setFillOpacity($fillOpacity) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the URL to use as a fill pattern for filling objects
     * @link https://php.net/manual/en/imagickdraw.setfillpatternurl.php
     * @param string $fill_url 

     * URL to use to obtain fill pattern.
     * 
     * @return bool TRUE on success or FALSE on failure.
     * @throws ImagickException on error.
     */
    public function setFillPatternURL($fill_url) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the fill rule to use while drawing polygons
     * @link https://php.net/manual/en/imagickdraw.setfillrule.php
     * @param int $fill_rule 

     * FILLRULE_ constant
     * 
     * @return bool No value is returned.
     */
    public function setFillRule($fill_rule) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the text placement gravity
     * @link https://php.net/manual/en/imagickdraw.setgravity.php
     * @param int $gravity 

     * GRAVITY_ constant
     * 
     * @return bool No value is returned.
     */
    public function setGravity($gravity) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the pattern used for stroking object outlines
     * @link https://php.net/manual/en/imagickdraw.setstrokepatternurl.php
     * @param string $stroke_url 

     * stroke URL
     * 
     * @return bool imagick.imagickdraw.return.success;
     * @throws ImagickException on error.
     */
    public function setStrokePatternURL($stroke_url) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the offset into the dash pattern to start the dash
     * @link https://php.net/manual/en/imagickdraw.setstrokedashoffset.php
     * @param float $dash_offset 

     * dash offset
     * 
     * @return bool No value is returned.
     */
    public function setStrokeDashOffset($dash_offset) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the shape to be used at the end of open subpaths when they are stroked
     * @link https://php.net/manual/en/imagickdraw.setstrokelinecap.php
     * @param int $linecap 

     * LINECAP_ constant
     * 
     * @return bool No value is returned.
     */
    public function setStrokeLineCap($linecap) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the shape to be used at the corners of paths when they are stroked
     * @link https://php.net/manual/en/imagickdraw.setstrokelinejoin.php
     * @param int $linejoin 

     * LINEJOIN_ constant
     * 
     * @return bool No value is returned.
     */
    public function setStrokeLineJoin($linejoin) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the miter limit
     * @link https://php.net/manual/en/imagickdraw.setstrokemiterlimit.php
     * @param int $miterlimit 

     * the miter limit
     * 
     * @return bool No value is returned.
     */
    public function setStrokeMiterLimit($miterlimit) {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the opacity of stroked object outlines
     * @link https://php.net/manual/en/imagickdraw.setstrokeopacity.php
     * @param float $stroke_opacity 

     * stroke opacity. 1.0 is fully opaque
     * 
     * @return bool No value is returned.
     */
    public function setStrokeOpacity($stroke_opacity) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the vector graphics
     * @link https://php.net/manual/en/imagickdraw.setvectorgraphics.php
     * @param string $xml 

     * xml containing the vector graphics
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    public function setVectorGraphics($xml) {}

    /**
     * (PECL imagick 2.0.0)

     * Destroys the current ImagickDraw in the stack, and returns to the previously pushed ImagickDraw
     * @link https://php.net/manual/en/imagickdraw.pop.php
     * @return bool TRUE on success and false on failure.
     * @throws ImagickException on error.
     */
    public function pop() {}

    /**
     * (PECL imagick 2.0.0)

     * Clones the current ImagickDraw and pushes it to the stack
     * @link https://php.net/manual/en/imagickdraw.push.php
     * @return bool TRUE on success or FALSE on failure.
     * @throws ImagickException on error.
     */
    public function push() {}

    /**
     * (PECL imagick 2.0.0)

     * Specifies the pattern of dashes and gaps used to stroke paths
     * @link https://php.net/manual/en/imagickdraw.setstrokedasharray.php
     * @param array $dashArray 

     * array of floats
     * 
     * @return bool TRUE on success.
     */
    public function setStrokeDashArray(array $dashArray) {}

    /**
     * Sets the opacity to use when drawing using the fill or stroke color or texture. Fully opaque is 1.0.
     *
     * @param float $opacity
     * @return void
     * @since 3.4.1
     */
    public function setOpacity($opacity) {}

    /**
     * Returns the opacity used when drawing with the fill or stroke color or texture. Fully opaque is 1.0.
     *
     * @return float
     * @since 3.4.1
     */
    #[Pure]
    public function getOpacity() {}

    /**
     * Sets the image font resolution.
     *
     * @param float $x
     * @param float $y
     * @return bool
     * @throws ImagickException on error.
     * @since 3.4.1
     */
    public function setFontResolution($x, $y) {}

    /**
     * Gets the image X and Y resolution.
     *
     * @return array
     * @throws ImagickException on error.
     * @since 3.4.1
     */
    #[Pure]
    public function getFontResolution() {}

    /**
     * Returns the direction that will be used when annotating with text.
     * @return bool
     * @since 3.4.1
     */
    #[Pure]
    public function getTextDirection() {}

    /**
     * Sets the font style to use when annotating with text. The AnyStyle enumeration acts as a wild-card "don't care" option.
     *
     * @param int $direction
     * @return bool
     * @since 3.4.1
     */
    public function setTextDirection($direction) {}

    /**
     * Returns the border color used for drawing bordered objects.
     *
     * @return ImagickPixel
     * @since 3.4.1
     */
    #[Pure]
    public function getBorderColor() {}

    /**
     * Sets the border color to be used for drawing bordered objects.
     * @param ImagickPixel $color
     * @return bool
     * @throws ImagickDrawException on error.
     * @since 3.4.1
     */
    public function setBorderColor(ImagickPixel $color) {}

    /**
     * Obtains the vertical and horizontal resolution.
     *
     * @return string|null
     * @since 3.4.1
     */
    #[Pure]
    public function getDensity() {}

    /**
     * Sets the vertical and horizontal resolution.
     * @param string $density_string
     * @return bool
     * @throws ImagickException on error.
     * @since 3.4.1
     */
    public function setDensity($density_string) {}
}

/**
 * @link https://php.net/manual/en/class.imagickpixeliterator.php
 */
class ImagickPixelIterator implements Iterator
{
    /**
     * (PECL imagick 2.0.0)

     * The ImagickPixelIterator constructor
     * @link https://php.net/manual/en/imagickpixeliterator.construct.php
     * @param Imagick $wand
     * @throws ImagickPixelIteratorException on error.
     * @throws ImagickException on error.
     */
    public function __construct(Imagick $wand) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a new pixel iterator
     * @link https://php.net/manual/en/imagickpixeliterator.newpixeliterator.php
     * @param Imagick $wand
     * @return bool TRUE on success. Throwing ImagickPixelIteratorException.
     * @throws ImagickPixelIteratorException
     * @throws ImagickException
     */
    #[Deprecated(replacement: "%class%->getPixelIterator(%parametersList%)")]
    public function newPixelIterator(Imagick $wand) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns a new pixel iterator
     * @link https://php.net/manual/en/imagickpixeliterator.newpixelregioniterator.php
     * @param Imagick $wand
     * @param int $x
     * @param int $y
     * @param int $columns
     * @param int $rows
     * @return bool a new ImagickPixelIterator on success; on failure, throws ImagickPixelIteratorException
     * @throws ImagickPixelIteratorException
     * @throws ImagickException
     */
    #[Deprecated(replacement: "%class%->getPixelRegionIterator(%parametersList%)")]
    public function newPixelRegionIterator(Imagick $wand, $x, $y, $columns, $rows) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the current pixel iterator row
     * @link https://php.net/manual/en/imagickpixeliterator.getiteratorrow.php
     * @return int the integer offset of the row, throwing ImagickPixelIteratorException on error.
     * @throws ImagickPixelIteratorException on error
     */
    #[Pure]
    public function getIteratorRow() {}

    /**
     * (PECL imagick 2.0.0)

     * Set the pixel iterator row
     * @link https://php.net/manual/en/imagickpixeliterator.setiteratorrow.php
     * @param int $row
     * @return bool TRUE on success.
     * @throws ImagickPixelIteratorException on error.
     */
    public function setIteratorRow($row) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the pixel iterator to the first pixel row
     * @link https://php.net/manual/en/imagickpixeliterator.setiteratorfirstrow.php
     * @return bool TRUE on success.
     * @throws ImagickPixelIteratorException on error.
     */
    public function setIteratorFirstRow() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the pixel iterator to the last pixel row
     * @link https://php.net/manual/en/imagickpixeliterator.setiteratorlastrow.php
     * @return bool TRUE on success.
     * @throws ImagickPixelIteratorException on error.
     */
    public function setIteratorLastRow() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the previous row
     * @link https://php.net/manual/en/imagickpixeliterator.getpreviousiteratorrow.php
     * @return array the previous row as an array of ImagickPixelWand objects from the
     * ImagickPixelIterator, throwing ImagickPixelIteratorException on error.
     * @throws ImagickPixelIteratorException on error
     */
    #[Pure]
    public function getPreviousIteratorRow() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the current row of ImagickPixel objects
     * @link https://php.net/manual/en/imagickpixeliterator.getcurrentiteratorrow.php
     * @return array a row as an array of ImagickPixel objects that can themselves be iterated.
     * @throws ImagickPixelIteratorException on error.
     */
    #[Pure]
    public function getCurrentIteratorRow() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the next row of the pixel iterator
     * @link https://php.net/manual/en/imagickpixeliterator.getnextiteratorrow.php
     * @return array the next row as an array of ImagickPixel objects, throwing
     * ImagickPixelIteratorException on error.
     * @throws ImagickPixelIteratorException on error
     */
    #[Pure]
    public function getNextIteratorRow() {}

    /**
     * (PECL imagick 2.0.0)

     * Resets the pixel iterator
     * @link https://php.net/manual/en/imagickpixeliterator.resetiterator.php
     * @return bool TRUE on success.
     * @throws ImagickPixelIteratorException on error.
     */
    public function resetIterator() {}

    /**
     * (PECL imagick 2.0.0)

     * Syncs the pixel iterator
     * @link https://php.net/manual/en/imagickpixeliterator.synciterator.php
     * @return bool TRUE on success.
     * @throws ImagickPixelIteratorException on error.
     */
    public function syncIterator() {}

    /**
     * (PECL imagick 2.0.0)

     * Deallocates resources associated with a PixelIterator
     * @link https://php.net/manual/en/imagickpixeliterator.destroy.php
     * @return bool TRUE on success.
     * @throws ImagickPixelIteratorException on error.
     */
    public function destroy() {}

    /**
     * (PECL imagick 2.0.0)

     * Clear resources associated with a PixelIterator
     * @link https://php.net/manual/en/imagickpixeliterator.clear.php
     * @return bool TRUE on success.
     * @throws ImagickPixelIteratorException on error.
     */
    public function clear() {}

    /**
     * @param Imagick $Imagick
     * @throws ImagickPixelIteratorException on error.
     * @throws ImagickException on error.
     */
    public static function getpixeliterator(Imagick $Imagick) {}

    /**
     * @param Imagick $Imagick
     * @param $x
     * @param $y
     * @param $columns
     * @param $rows
     * @throws ImagickPixelIteratorException on error.
     * @throws ImagickException on error.
     */
    public static function getpixelregioniterator(Imagick $Imagick, $x, $y, $columns, $rows) {}

    /**
     * @throws ImagickPixelIteratorException on error.
     */
    public function key() {}

    /**
     * @throws ImagickPixelIteratorException on error.
     */
    public function next() {}

    /**
     * @throws ImagickPixelIteratorException on error.
     */
    public function rewind() {}

    /**
     * @throws ImagickPixelIteratorException on error.
     */
    public function current() {}

    /**
     * @throws ImagickPixelIteratorException on error.
     */
    public function valid() {}
}

/**
 * @method clone()
 * @link https://php.net/manual/en/class.imagickpixel.php
 */
class ImagickPixel
{
    /**
     * (PECL imagick 2.0.0)

     * Returns the normalized HSL color of the ImagickPixel object
     * @link https://php.net/manual/en/imagickpixel.gethsl.php
     * @return float[] the HSL value in an array with the keys "hue",
     * "saturation", and "luminosity". Throws ImagickPixelException on failure.
     * @throws ImagickPixelException on failure
     */
    #[ArrayShape(["hue" => "float", "saturation" => "float", "luminosity" => "float"])]
    #[Pure]
    public function getHSL() {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the normalized HSL color
     * @link https://php.net/manual/en/imagickpixel.sethsl.php
     * @param float $hue 

     * The normalized value for hue, described as a fractional arc
     * (between 0 and 1) of the hue circle, where the zero value is
     * red.
     * 
     * @param float $saturation 

     * The normalized value for saturation, with 1 as full saturation.
     * 
     * @param float $luminosity 

     * The normalized value for luminosity, on a scale from black at
     * 0 to white at 1, with the full HS value at 0.5 luminosity.
     * 
     * @return bool TRUE on success.
     * @throws ImagickPixelException on failure
     */
    public function setHSL($hue, $saturation, $luminosity) {}

    /**
     * @throws ImagickPixelException on failure
     */
    #[Pure]
    public function getColorValueQuantum() {}

    /**
     * @param $color_value
     * @throws ImagickPixelException on failure
     */
    public function setColorValueQuantum($color_value) {}

    /**
     * Gets the colormap index of the pixel wand.
     * @throws ImagickPixelException on failure
     */
    #[Pure]
    public function getIndex() {}

    /**
     * @param int $index
     * @throws ImagickPixelException on failure
     */
    public function setIndex($index) {}

    /**
     * (PECL imagick 2.0.0)

     * The ImagickPixel constructor
     * @link https://php.net/manual/en/imagickpixel.construct.php
     * @param string $color [optional] 

     * The optional color string to use as the initial value of this object.
     * 
     * @throws ImagickPixelException on failure
     */
    public function __construct($color = null) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the color
     * @link https://php.net/manual/en/imagickpixel.setcolor.php
     * @param string $color 

     * The color definition to use in order to initialise the
     * ImagickPixel object.
     * 
     * @return bool TRUE if the specified color was set, FALSE otherwise.
     * @throws ImagickPixelException on failure
     */
    public function setColor($color) {}

    /**
     * (PECL imagick 2.0.0)

     * Sets the normalized value of one of the channels
     * @link https://php.net/manual/en/imagickpixel.setcolorvalue.php
     * @param int $color 

     * One of the Imagick color constants e.g. \Imagick::COLOR_GREEN or \Imagick::COLOR_ALPHA.
     * 
     * @param float $value 

     * The value to set this channel to, ranging from 0 to 1.
     * 
     * @return bool TRUE on success.
     * @throws ImagickPixelException on failure
     */
    public function setColorValue($color, $value) {}

    /**
     * (PECL imagick 2.0.0)

     * Gets the normalized value of the provided color channel
     * @link https://php.net/manual/en/imagickpixel.getcolorvalue.php
     * @param int $color 

     * The color to get the value of, specified as one of the Imagick color
     * constants. This can be one of the RGB colors, CMYK colors, alpha and
     * opacity e.g (Imagick::COLOR_BLUE, Imagick::COLOR_MAGENTA).
     * 
     * @return float The value of the channel, as a normalized floating-point number, throwing
     * ImagickPixelException on error.
     * @throws ImagickPixelException on error
     */
    #[Pure]
    public function getColorValue($color) {}

    /**
     * (PECL imagick 2.0.0)

     * Clears resources associated with this object
     * @link https://php.net/manual/en/imagickpixel.clear.php
     * @return bool TRUE on success.
     * @throws ImagickPixelException on failure
     */
    public function clear() {}

    /**
     * (PECL imagick 2.0.0)

     * Deallocates resources associated with this object
     * @link https://php.net/manual/en/imagickpixel.destroy.php
     * @return bool TRUE on success.
     * @throws ImagickPixelException on failure
     */
    public function destroy() {}

    /**
     * (PECL imagick 2.0.0)

     * Check the distance between this color and another
     * @link https://php.net/manual/en/imagickpixel.issimilar.php
     * @param ImagickPixel $color 

     * The ImagickPixel object to compare this object against.
     * 
     * @param float $fuzz 

     * The maximum distance within which to consider these colors as similar.
     * The theoretical maximum for this value is the square root of three
     * (1.732).
     * 
     * @return bool TRUE on success.
     * @throws ImagickPixelException on failure
     */
    public function isSimilar(ImagickPixel $color, $fuzz) {}

    /**
     * (No version information available, might only be in SVN)

     * Check the distance between this color and another
     * @link https://php.net/manual/en/imagickpixel.ispixelsimilar.php
     * @param ImagickPixel $color 

     * The ImagickPixel object to compare this object against.
     * 
     * @param float $fuzz 

     * The maximum distance within which to consider these colors as similar.
     * The theoretical maximum for this value is the square root of three
     * (1.732).
     * 
     * @return bool TRUE on success.
     * @throws ImagickPixelException on failure
     */
    public function isPixelSimilar(ImagickPixel $color, $fuzz) {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the color
     * @link https://php.net/manual/en/imagickpixel.getcolor.php
     * @param int $normalized [optional] 

     * Normalize the color values
     * 
     * @return array An array of channel values, each normalized if TRUE is given as param. Throws
     * ImagickPixelException on error.
     * @throws ImagickPixelException on error.
     */
    #[ArrayShape(["r" => "int|float", "g" => "int|float", "b" => "int|float", "a" => "int|float"])]
    #[Pure]
    public function getColor($normalized = 0) {}

    /**
     * (PECL imagick 2.1.0)

     * Returns the color as a string
     * @link https://php.net/manual/en/imagickpixel.getcolorasstring.php
     * @return string the color of the ImagickPixel object as a string.
     * @throws ImagickPixelException on failure
     */
    #[Pure]
    public function getColorAsString() {}

    /**
     * (PECL imagick 2.0.0)

     * Returns the color count associated with this color
     * @link https://php.net/manual/en/imagickpixel.getcolorcount.php
     * @return int the color count as an integer on success, throws
     * ImagickPixelException on failure.
     * @throws ImagickPixelException on failure.
     */
    #[Pure]
    public function getColorCount() {}

    /**
     * @param int $colorCount
     * @throws ImagickPixelException on failure
     */
    public function setColorCount($colorCount) {}

    /**
     * Returns true if the distance between two colors is less than the specified distance. The fuzz value should be in the range 0-QuantumRange.

     * The maximum value represents the longest possible distance in the colorspace. e.g. from RGB(0, 0, 0) to RGB(255, 255, 255) for the RGB colorspace
     * @link https://php.net/manual/en/imagickpixel.ispixelsimilarquantum.php
     * @param string $color
     * @param string $fuzz
     * @return bool
     * @throws ImagickPixelException on failure
     * @since 3.3.0
     */
    public function isPixelSimilarQuantum($color, $fuzz) {}

    /**
     * Returns the color of the pixel in an array as Quantum values. If ImageMagick was compiled as HDRI these will be floats, otherwise they will be integers.
     * @link https://php.net/manual/en/imagickpixel.getcolorquantum.php
     * @return mixed The quantum value of the color element. Float if ImageMagick was compiled with HDRI, otherwise an int.
     * @throws ImagickPixelException on failure
     * @since 3.3.0
     */
    #[Pure]
    public function getColorQuantum() {}

    /**
     * Sets the color count associated with this color from another ImagickPixel object.
     *
     * @param ImagickPixel $srcPixel
     * @return bool
     * @throws ImagickPixelException on failure
     * @since 3.4.1
     */
    public function setColorFromPixel(ImagickPixel $srcPixel) {}
}
// End of imagick v.3.2.0RC1

// Start of Imagick v3.3.0RC1

/**
 * @link https://php.net/manual/en/class.imagickkernel.php
 */
class ImagickKernel
{
    /**
     * Attach another kernel to this kernel to allow them to both be applied in a single morphology or filter function. Returns the new combined kernel.
     * @link https://php.net/manual/en/imagickkernel.addkernel.php
     * @param ImagickKernel $imagickKernel
     * @return void
     * @throws ImagickKernelException on error
     * @since 3.3.0
     */
    public function addKernel(ImagickKernel $imagickKernel) {}

    /**
     * Adds a given amount of the 'Unity' Convolution Kernel to the given pre-scaled and normalized Kernel. This in effect adds that amount of the original image into the resulting convolution kernel. The resulting effect is to convert the defined kernels into blended soft-blurs, unsharp kernels or into sharpening kernels.
     * @link https://php.net/manual/en/imagickkernel.addunitykernel.php
     * @return void
     * @throws ImagickKernelException on error
     * @since 3.3.0
     */
    public function addUnityKernel() {}

    /**
     * Create a kernel from a builtin in kernel. See https://www.imagemagick.org/Usage/morphology/#kernel for examples.

     * Currently the 'rotation' symbols are not supported. Example: $diamondKernel = ImagickKernel::fromBuiltIn(\Imagick::KERNEL_DIAMOND, "2");
     * @link https://php.net/manual/en/imagickkernel.frombuiltin.php
     * @param int $kernelType The type of kernel to build e.g. \Imagick::KERNEL_DIAMOND
     * @param string $kernelString A string that describes the parameters e.g. "4,2.5"
     * @return ImagickKernel
     * @since 3.3.0
     */
    public static function fromBuiltin($kernelType, $kernelString) {}

    /**
     * Create a kernel from a builtin in kernel. See https://www.imagemagick.org/Usage/morphology/#kernel for examples.

     * Currently the 'rotation' symbols are not supported. Example: $diamondKernel = ImagickKernel::fromBuiltIn(\Imagick::KERNEL_DIAMOND, "2");
     * @link https://php.net/manual/en/imagickkernel.frombuiltin.php
     * @see https://www.imagemagick.org/Usage/morphology/#kernel
     * @param array $matrix A matrix (i.e. 2d array) of values that define the kernel. Each element should be either a float value, or FALSE if that element shouldn't be used by the kernel.
     * @param array $origin [optional] Which element of the kernel should be used as the origin pixel. e.g. For a 3x3 matrix specifying the origin as [2, 2] would specify that the bottom right element should be the origin pixel.
     * @return ImagickKernel
     * @throws ImagickKernelException on error
     * @since 3.3.0
     */
    public static function fromMatrix($matrix, $origin) {}

    /**
     * Get the 2d matrix of values used in this kernel. The elements are either float for elements that are used or 'false' if the element should be skipped.
     * @link https://php.net/manual/en/imagickkernel.getmatrix.php
     * @return array A matrix (2d array) of the values that represent the kernel.
     * @throws ImagickKernelException on error
     * @since 3.3.0
     */
    #[Pure]
    public function getMatrix() {}

    /**
     * ScaleKernelInfo() scales the given kernel list by the given amount, with or without normalization of the sum of the kernel values (as per given flags).

     * The exact behaviour of this function depends on the normalization type being used please see https://www.imagemagick.org/api/morphology.php#ScaleKernelInfo for details.

     * Flag should be one of Imagick::NORMALIZE_KERNEL_VALUE, Imagick::NORMALIZE_KERNEL_CORRELATE, Imagick::NORMALIZE_KERNEL_PERCENT or not set.
     * @link https://php.net/manual/en/imagickkernel.scale.php
     * @see https://www.imagemagick.org/api/morphology.php#ScaleKernelInfo
     * @return void
     * @throws ImagickKernelException on error
     * @since 3.3.0
     */
    public function scale() {}

    /**
     * Separates a linked set of kernels and returns an array of ImagickKernels.
     * @link https://php.net/manual/en/imagickkernel.separate.php
     * @return void
     * @throws ImagickKernelException on error
     * @since 3.3.0
     */
    public function seperate() {}
}
services:
  php_under_test:
    build: tests/DockerImages/${PHP_VERSION}
    volumes:
      - .:/opt/project/phpstorm-stubs
  test_runner:
    build: tests/DockerImages/testRunner
    volumes:
      - .:/opt/project/phpstorm-stubs
  pecl_extensions:
    build: tests/DockerImages/peclExtensions
    volumes:
      - .:/opt/project/phpstorm-stubs

 * The new message domain, or NULL to get the current setting without
 * changing it
 * 

 * @return string If successful, this function returns the current message
 * domain, after possibly changing it.
 */
function textdomain(?string $domain = null): string {}

/**
 * Lookup a message in the current domain
 * @link https://php.net/manual/en/function.gettext.php
 * @param string $message 

 * The message being translated.
 * 
 * @return string a translated string if one is found in the
 * translation table, or the submitted message if not found.
 */
#[Pure]
function _(string $message): string {}

/**
 * Lookup a message in the current domain
 * @link https://php.net/manual/en/function.gettext.php
 * @param string $message 

 * The message being translated.
 * 
 * @return string a translated string if one is found in the
 * translation table, or the submitted message if not found.
 */
#[Pure]
function gettext(string $message): string {}

/**
 * Override the current domain
 * @link https://php.net/manual/en/function.dgettext.php
 * @param string $domain 

 * The domain
 * 
 * @param string $message 

 * The message
 * 
 * @return string A string on success.
 */
function dgettext(string $domain, string $message): string {}

/**
 * Overrides the domain for a single lookup
 * @link https://php.net/manual/en/function.dcgettext.php
 * @param string $domain 

 * The domain
 * 
 * @param string $message 

 * The message
 * 
 * @param int $category 

 * The category
 * 
 * @return string A string on success.
 */
function dcgettext(string $domain, string $message, int $category): string {}

/**
 * Sets the path for a domain
 * @link https://php.net/manual/en/function.bindtextdomain.php
 * @param string $domain 

 * The domain
 * 
 * @param string|null $directory 

 * The directory path. Since PHP 8.0.3 directory is nullable. If null is passed, the currently set directory is returned.
 * 
 * @return string|false The full pathname for the domain currently being set.
 */
function bindtextdomain(string $domain, #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: 'string')] $directory = null): string|false {}

/**
 * Plural version of gettext
 * @link https://php.net/manual/en/function.ngettext.php
 * @param string $singular
 * @param string $plural
 * @param int $count
 * @return string correct plural form of message identified by
 * msgid1 and msgid2
 * for count n.
 */
#[Pure]
function ngettext(string $singular, string $plural, int $count): string {}

/**
 * Plural version of dgettext
 * @link https://php.net/manual/en/function.dngettext.php
 * @param string $domain 

 * The domain
 * 
 * @param string $singular
 * @param string $plural
 * @param int $count
 * @return string A string on success.
 */
#[Pure]
function dngettext(string $domain, string $singular, string $plural, int $count): string {}

/**
 * Plural version of dcgettext
 * @link https://php.net/manual/en/function.dcngettext.php
 * @param string $domain 

 * The domain
 * 
 * @param string $singular
 * @param string $plural
 * @param int $count
 * @param int $category
 * @return string A string on success.
 */
#[Pure]
function dcngettext(string $domain, string $singular, string $plural, int $count, int $category): string {}

/**
 * Specify the character encoding in which the messages from the DOMAIN message catalog will be returned
 * @link https://php.net/manual/en/function.bind-textdomain-codeset.php
 * @param string $domain 

 * The domain
 * 
 * @param string|null $codeset 

 * The code set. Since 8.0.3 is nullable.  If null is passed, the currently set encoding is returned.
 * 
 * @return string|false A string on success.
 */
function bind_textdomain_codeset(string $domain, #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: 'string')] $codeset = null): string|false {}

// End of gettext v.

     * COM class constructor.
     * @param string $module_name
     * @param string $server_name [optional]
     * @param int $codepage [optional]
     * @param string $typelib [optional]
     */
    public function __construct($module_name, $server_name = null, $codepage = CP_ACP, $typelib = null) {}

    public function __get($name) {}

    public function __set($name, $value) {}

    public function __call($name, $args) {}
}

/**
 * The DOTNET class allows you to instantiate a class from a .Net assembly and call its methods and access its properties.
 * @link https://php.net/manual/en/class.dotnet.php
 */
class DOTNET
{
    /**
     * (PHP 4 >= 4.1.0, PHP 5, PHP 7)

     * COM class constructor.
     * @param string $assembly_name
     * @param string $class_name
     * @param int $codepage [optional]
     */
    public function __construct($assembly_name, string $class_name, $codepage = CP_ACP) {}

    public function __get($name) {}

    public function __set($name, $value) {}

    public function __call($name, $args) {}
}

/**
 * The VARIANT is COM's equivalent of the PHP zval; it is a structure that can contain a value with a range of different possible types. The VARIANT class provided by the COM extension allows you to have more control over the way that PHP passes values to and from COM.
 * @link https://php.net/manual/en/class.variant.php
 */
class VARIANT
{
    /**
     * (PHP 4 >= 4.1.0, PHP 5, PHP 7)

     * COM class constructor.
     * @param mixed $value [optional]
     * @param int $type [optional]
     * @param int $codepage [optional]
     */
    public function __construct($value = null, int $type = VT_EMPTY, $codepage = CP_ACP) {}

    public function __get($name) {}

    public function __set($name, $value) {}

    public function __call($name, $args) {}
}

/**
 * This extension will throw instances of the class com_exception whenever there is a potentially fatal error reported by COM. All COM exceptions have a well-defined code property that corresponds to the HRESULT return value from the various COM operations. You may use this code to make programmatic decisions on how to handle the exception.
 * @link https://php.net/manual/en/com.error-handling.php
 */
class com_exception extends \Exception {}

/**
 * (PHP 5, PHP 7)

 * Generate a globally unique identifier (GUID)
 * @link https://php.net/manual/en/function.com-create-guid.php
 * @return string
 */
function com_create_guid() {}

/**
 * (PHP 4 >= 4.2.0, PHP 5, PHP 7)

 * Connect events from a COM object to a PHP object
 * @link https://php.net/manual/en/function.com-event-sink.php
 * @param \VARIANT $comobject
 * @param object $sinkobject
 * @param string $sinkinterface [optional]
 * @return bool
 */
function com_event_sink($comobject, $sinkobject, $sinkinterface = null) {}

/**
 * (PHP 5, PHP 7)

 * Returns a handle to an already running instance of a COM object
 * @link https://php.net/manual/en/function.com-get-active-object.php
 * @param string $progid
 * @param int $code_page [optional]
 * @return \VARIANT
 */
function com_get_active_object($progid, $code_page = CP_ACP) {}

/**
 * (PHP 4 >= 4.1.0, PHP 5, PHP 7)

 * Loads a Typelib
 * @link https://php.net/manual/en/function.com-get-active-object.php
 * @param string $typelib_name
 * @param bool $case_insensitive [optional]
 * @return bool
 */
function com_load_typelib($typelib_name, $case_insensitive = true) {}

/**
 * (PHP 4 >= 4.2.0, PHP 5, PHP 7)

 * Process COM messages, sleeping for up to timeoutms milliseconds
 * @link https://php.net/manual/en/function.com-message-pump.php
 * @param int $timeoutms [optional]
 * @return bool
 */
function com_message_pump($timeoutms = 0) {}

/**
 * (PHP 4 >= 4.2.0, PHP 5, PHP 7)

 * Print out a PHP class definition for a dispatchable interface
 * @link https://php.net/manual/en/function.com-print-typeinfo.php
 * @param object $comobject
 * @param string $dispinterface [optional]
 * @param bool $wantsink [optional]
 * @return bool
 */
function com_print_typeinfo($comobject, $dispinterface = null, $wantsink = false) {}

/**
 * (PHP 5, PHP 7)

 * Returns the absolute value of a variant
 * @link https://php.net/manual/en/function.variant-abs.php
 * @param mixed $val
 * @return mixed
 */
function variant_abs($val) {}

/**
 * (PHP 5, PHP 7)

 * "Adds" two variant values together and returns the result
 * @link https://php.net/manual/en/function.variant-abs.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_add($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Performs a bitwise AND operation between two variants
 * @link https://php.net/manual/en/function.variant-and.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_and($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Convert a variant into a new variant object of another type
 * @link https://php.net/manual/en/function.variant-cast.php
 * @param \VARIANT $variant
 * @param int $type
 * @return \VARIANT
 */
function variant_cast($variant, $type) {}

/**
 * (PHP 5, PHP 7)

 * Concatenates two variant values together and returns the result
 * @link https://php.net/manual/en/function.variant-cat.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_cat($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Compares two variants
 * @link https://php.net/manual/en/function.variant-cmp.php
 * @param mixed $left
 * @param mixed $right
 * @param int $lcid [optional]
 * @param int $flags [optional]
 * @return int
 */
function variant_cmp($left, $right, $lcid = null, $flags = null) {}

/**
 * (PHP 5, PHP 7)

 * Returns a variant date representation of a Unix timestamp
 * @link https://php.net/manual/en/function.variant-date-from-timestamp.php
 * @param int $timestamp
 * @return \VARIANT
 */
function variant_date_from_timestamp($timestamp) {}

/**
 * (PHP 5, PHP 7)

 * Converts a variant date/time value to Unix timestamp
 * @link https://php.net/manual/en/function.variant-date-to-timestamp.php
 * @param \VARIANT $variant
 * @return int
 */
function variant_date_to_timestamp($variant) {}

/**
 * (PHP 5, PHP 7)

 * Returns the result from dividing two variants
 * @link https://php.net/manual/en/function.variant-div.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_div($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Performs a bitwise equivalence on two variants
 * @link https://php.net/manual/en/function.variant-eqv.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_eqv($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Returns the integer portion of a variant
 * @link https://php.net/manual/en/function.variant-fix.php
 * @param mixed $variant
 * @return mixed
 */
function variant_fix($variant) {}

/**
 * (PHP 5, PHP 7)

 * Returns the type of a variant object
 * @link https://php.net/manual/en/function.variant-get-type.php
 * @param VARIANT $variant
 * @return int
 */
function variant_get_type($variant) {}

/**
 * (PHP 5, PHP 7)

 * Converts variants to integers and then returns the result from dividing them
 * @link https://php.net/manual/en/function.variant-idiv.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_idiv($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Performs a bitwise implication on two variants
 * @link https://php.net/manual/en/function.variant-imp.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_imp($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Returns the integer portion of a variant
 * @link https://php.net/manual/en/function.variant-int.php
 * @param mixed $variant
 * @return mixed
 */
function variant_int($variant) {}

/**
 * (PHP 5, PHP 7)

 * Divides two variants and returns only the remainder
 * @link https://php.net/manual/en/function.variant-mod.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_mod($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Multiplies the values of the two variants
 * @link https://php.net/manual/en/function.variant-mul.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_mul($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Performs logical negation on a variant
 * @link https://php.net/manual/en/function.variant-neg.php
 * @param mixed $variant
 * @return mixed
 */
function variant_neg($variant) {}

/**
 * (PHP 5, PHP 7)

 * Performs bitwise not negation on a variant
 * @link https://php.net/manual/en/function.variant-not.php
 * @param mixed $variant
 * @return mixed
 */
function variant_not($variant) {}

/**
 * (PHP 5, PHP 7)

 * Performs a logical disjunction on two variants
 * @link https://php.net/manual/en/function.variant-or.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_or($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Returns the result of performing the power function with two variants
 * @link https://php.net/manual/en/function.variant-pow.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_pow($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Rounds a variant to the specified number of decimal places
 * @link https://php.net/manual/en/function.variant-round.php
 * @param mixed $variant
 * @param int $decimals
 * @return mixed
 */
function variant_round($variant, $decimals) {}

/**
 * (PHP 5, PHP 7)

 * Convert a variant into another type "in-place"
 * @link https://php.net/manual/en/function.variant-set-type.php
 * @param VARIANT $variant
 * @param int $type
 * @return void
 */
function variant_set_type($variant, $type) {}

/**
 * (PHP 5, PHP 7)

 * Assigns a new value for a variant object
 * @link https://php.net/manual/en/function.variant-set.php
 * @param VARIANT $variant
 * @param mixed $value
 * @return void
 */
function variant_set($variant, $value) {}

/**
 * (PHP 5, PHP 7)

 * Subtracts the value of the right variant from the left variant value
 * @link https://php.net/manual/en/function.variant-sub.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_sub($left, $right) {}

/**
 * (PHP 5, PHP 7)

 * Performs a logical exclusion on two variants
 * @link https://php.net/manual/en/function.variant-xor.php
 * @param mixed $left
 * @param mixed $right
 * @return mixed
 */
function variant_xor($left, $right) {}

define('CLSCTX_INPROC_SERVER', 1);
define('CLSCTX_INPROC_HANDLER', 2);
define('CLSCTX_LOCAL_SERVER', 4);
define('CLSCTX_REMOTE_SERVER', 16);
define('CLSCTX_SERVER', 21);
define('CLSCTX_ALL', 23);

define('VT_NULL', 1);
define('VT_EMPTY', 0);
define('VT_UI1', 17);
define('VT_I2', 2);
define('VT_I4', 3);
define('VT_R4', 4);
define('VT_R8', 5);
define('VT_BOOL', 11);
define('VT_ERROR', 10);
define('VT_CY', 6);
define('VT_DATE', 7);
define('VT_BSTR', 8);
define('VT_DECIMAL', 14);
define('VT_UNKNOWN', 13);
define('VT_DISPATCH', 9);
define('VT_VARIANT', 12);
define('VT_I1', 16);
define('VT_UI2', 18);
define('VT_UI4', 19);
define('VT_INT', 22);
define('VT_UINT', 23);
define('VT_ARRAY', 8192);
define('VT_BYREF', 16384);

define('CP_ACP', 0);
define('CP_MACCP', 2);
define('CP_OEMCP', 1);
define('CP_UTF7', 65000);
define('CP_UTF8', 65001);
define('CP_SYMBOL', 42);
define('CP_THREAD_ACP', 3);

define('VARCMP_LT', 0);
define('VARCMP_EQ', 1);
define('VARCMP_GT', 2);
define('VARCMP_NULL', 3);

define('NORM_IGNORECASE', 1);
define('NORM_IGNORENONSPACE', 2);
define('NORM_IGNORESYMBOLS', 4);
define('NORM_IGNOREWIDTH', 131072);
define('NORM_IGNOREKANATYPE', 65536);
define('NORM_IGNOREKASHIDA', 262144);

define('DISP_E_DIVBYZERO', -2147352558);
define('DISP_E_OVERFLOW', -2147352566);
define('MK_E_UNAVAILABLE', -2147221021);

// End of com v.

 * A Pool is a container for, and controller of, an adjustable number of
 * Workers.

 * Pooling provides a higher level abstraction of the Worker functionality,
 * including the management of references in the way required by pthreads.
 * @link https://secure.php.net/manual/en/class.pool.php
 */
class Pool
{
    /**
     * Maximum number of Workers this Pool can use
     * @var int
     */
    protected $size;

    /**
     * The class of the Worker
     * @var string
     */
    protected $class;

    /**
     * The arguments for constructor of new Workers
     * @var array
     */
    protected $ctor;

    /**
     * References to Workers
     * @var array
     */
    protected $workers;

    /**
     * Offset in workers of the last Worker used
     * @var int
     */
    protected $last;

    /**
     * (PECL pthreads >= 2.0.0)

     * Construct a new pool of workers. Pools lazily create their threads, which means
     * new threads will only be spawned when they are required to execute tasks.
     * @link https://secure.php.net/manual/en/pool.construct.php
     * @param int $size 
The maximum number of workers for this pool to create
     * @param string $class [optional] 
The class for new Workers. If no class is
     * given, then it defaults to the {@link Worker} class.
     * @param array $ctor [optional] 
An array of arguments to be passed to new
     * Workers
     */
    public function __construct(int $size, string $class = 'Worker', array $ctor = []) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Allows the pool to collect references determined to be garbage by the
     * optionally given collector
     * @link https://secure.php.net/manual/en/pool.collect.php
     * @param null|callable $collector [optional] 
A Callable collector that returns a
     * boolean on whether the task can be collected or not. Only in rare cases should
     * a custom collector need to be used.
     * @return int 
The number of remaining tasks in the pool to be collected
     */
    public function collect(?callable $collector = null) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Resize the Pool
     * @link https://secure.php.net/manual/en/pool.resize.php
     * @param int $size 
The maximum number of Workers this Pool can create
     * @return void
     */
    public function resize(int $size) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Shuts down all of the workers in the pool. This will block until all submitted
     * tasks have been executed.
     * @link https://secure.php.net/manual/en/pool.shutdown.php
     * @return void
     */
    public function shutdown() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Submit the task to the next Worker in the Pool
     * @link https://secure.php.net/manual/en/pool.submit.php
     * @param Threaded $task 
The task for execution
     * @return int 
the identifier of the Worker executing the object
     */
    public function submit(Threaded $task) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Submit a task to the specified worker in the pool. The workers are indexed
     * from 0, and will only exist if the pool has needed to create them (since
     * threads are lazily spawned).
     * @link https://secure.php.net/manual/en/pool.submitTo.php
     * @param int $worker 
The worker to stack the task onto, indexed from 0
     * @param Threaded $task 
The task for execution
     * @return int 
The identifier of the worker that accepted the task
     */
    public function submitTo(int $worker, Threaded $task) {}
}

/**
 * Threaded objects form the basis of pthreads ability to execute user code
 * in parallel; they expose synchronization methods and various useful
 * interfaces.

 * Threaded objects, most importantly, provide implicit safety for the programmer;
 * all operations on the object scope are safe.
 *
 * @link https://secure.php.net/manual/en/class.threaded.php
 */
class Threaded implements Collectable, Traversable, Countable, ArrayAccess
{
    /**
     * Worker object in which this Threaded is being executed
     * @var Worker
     */
    protected $worker;

    /**
     * (PECL pthreads >= 3.0.0)

     * Increments the internal number of references to a Threaded object
     * @return void
     */
    public function addRef() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Fetches a chunk of the objects property table of the given size,
     * optionally preserving keys
     * @link https://secure.php.net/manual/en/threaded.chunk.php
     * @param int $size 
The number of items to fetch
     * @param bool $preserve [optional] 
Preserve the keys of members, by default false
     * @return array 
An array of items from the objects property table
     */
    public function chunk($size, $preserve = false) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Returns the number of properties for this object
     * @link https://secure.php.net/manual/en/threaded.count.php
     * @return int 
The number of properties for this object
     */
    public function count() {}

    /**
     * (PECL pthreads >= 3.0.0)

     * Decrements the internal number of references to a Threaded object
     * @return void
     */
    public function delRef() {}

    /**
     * (PECL pthreads >= 2.0.8)

     * Makes thread safe standard class at runtime
     * @link https://secure.php.net/manual/en/threaded.extend.php
     * @param string $class 
The class to extend
     * @return bool 
A boolean indication of success
     */
    public static function extend($class) {}

    /**
     * (PECL pthreads >= 3.0.0)

     * Retrieves the internal number of references to a Threaded object
     * @return int 
The number of references to the Threaded object
     */
    public function getRefCount() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Tell if the referenced object is executing
     * @link https://secure.php.net/manual/en/thread.isrunning.php
     * @return bool 
A boolean indication of state
     */
    public function isRunning() {}

    /**
     * (PECL pthreads >= 3.1.0)

     * @inheritdoc
     * @see Collectable::isGarbage()
     */
    public function isGarbage(): bool {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Tell if the referenced object was terminated during execution; suffered
     * fatal errors, or threw uncaught exceptions
     * @link https://secure.php.net/manual/en/threaded.isterminated.php
     * @return bool 
A boolean indication of state
     */
    public function isTerminated() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Merges data into the current object
     * @link https://secure.php.net/manual/en/threaded.merge.php
     * @var mixed 
The data to merge
     * @var bool [optional] 
Overwrite existing keys, by default true
     * @return bool 
A boolean indication of success
     */
    public function merge($from, $overwrite = true) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Send notification to the referenced object
     * @link https://secure.php.net/manual/en/threaded.notify.php
     * @return bool 
A boolean indication of success
     */
    public function notify() {}

    /**
     * (PECL pthreads >= 3.0.0)

     * Send notification to the referenced object. This unblocks at least one
     * of the blocked threads (as opposed to unblocking all of them, as seen with
     * Threaded::notify()).
     * @link https://secure.php.net/manual/en/threaded.notifyone.php
     * @return bool 
A boolean indication of success
     */
    public function notifyOne() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Pops an item from the objects property table
     * @link https://secure.php.net/manual/en/threaded.pop.php
     * @return mixed 
The last item from the objects property table
     */
    public function pop() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * The programmer should always implement the run method for objects
     * that are intended for execution.
     * @link https://secure.php.net/manual/en/threaded.run.php
     * @return void
     */
    public function run() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Shifts an item from the objects property table
     * @link https://secure.php.net/manual/en/threaded.shift.php
     * @return mixed 
The first item from the objects property table
     */
    public function shift() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Executes the block while retaining the referenced objects
     * synchronization lock for the calling context
     * @link https://secure.php.net/manual/en/threaded.synchronized.php
     * @param Closure $block 
The block of code to execute
     * @param mixed ...$_ [optional] 
Variable length list of arguments
     * to use as function arguments to the block
     * @return mixed 
The return value from the block
     */
    public function synchronized(Closure $block, ...$_) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Will cause the calling context to wait for notification from the
     * referenced object
     * @link https://secure.php.net/manual/en/threaded.wait.php
     * @param int $timeout [optional] 
An optional timeout in microseconds
     * @return bool 
A boolean indication of success
     */
    public function wait(int $timeout = 0) {}

    /**
     * @inheritdoc
     * @see ArrayAccess::offsetExists()
     */
    public function offsetExists($offset) {}

    /**
     * @inheritdoc
     * @see ArrayAccess::offsetGet()
     */
    public function offsetGet($offset) {}

    /**
     * @inheritdoc
     * @see ArrayAccess::offsetSet()
     */
    public function offsetSet($offset, $value) {}

    /**
     * @inheritdoc
     * @see ArrayAccess::offsetUnset()
     */
    public function offsetUnset($offset) {}
}

/**
 * (PECL pthreads >= 2.0.0)

 * When the start method of a Thread is invoked, the run method code will be
 * executed in separate Thread, in parallel.

 * After the run method is executed the Thread will exit immediately, it will
 * be joined with the creating Thread at the appropriate time.
 *
 * @link https://secure.php.net/manual/en/class.thread.php
 */
class Thread extends Threaded implements Countable, Traversable, ArrayAccess
{
    /**
     * (PECL pthreads >= 2.0.0)

     * Will return the identity of the Thread that created the referenced Thread
     * @link https://secure.php.net/manual/en/thread.getcreatorid.php
     * @return int 
A numeric identity
     */
    public function getCreatorId() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Return a reference to the currently executing Thread
     * @link https://secure.php.net/manual/en/thread.getcurrentthread.php
     * @return Thread 
An object representing the currently executing Thread
     */
    public static function getCurrentThread() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Will return the identity of the currently executing Thread
     * @link https://secure.php.net/manual/en/thread.getcurrentthreadid.php
     * @return int 
A numeric identity
     */
    public static function getCurrentThreadId() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Will return the identity of the referenced Thread
     * @link https://secure.php.net/manual/en/thread.getthreadid.php
     * @return int 
A numeric identity
     */
    public function getThreadId() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Tell if the referenced Thread has been joined
     * @link https://secure.php.net/manual/en/thread.isjoined.php
     * @return bool 
A boolean indication of state
     */
    public function isJoined() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Tell if the referenced Thread was started
     * @link https://secure.php.net/manual/en/thread.isstarted.php
     * @return bool 
A boolean indication of state
     */
    public function isStarted() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Causes the calling context to wait for the referenced Thread to finish executing
     * @link https://secure.php.net/manual/en/thread.join.php
     * @return bool 
A boolean indication of success
     */
    public function join() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Will start a new Thread to execute the implemented run method
     * @link https://secure.php.net/manual/en/thread.start.php
     * @param int $options [optional] 
An optional mask of inheritance
     * constants, by default {@link PTHREADS_INHERIT_ALL}
     * @return bool 
A boolean indication of success
     */
    public function start(int $options = PTHREADS_INHERIT_ALL) {}
}

/**
 * (PECL pthreads >= 2.0.0)

 * Worker Threads have a persistent context, as such should be used over
 * Threads in most cases.

 * When a Worker is started, the run method will be executed, but the Thread will
 * not leave until one of the following conditions are met:

 * 
the Worker goes out of scope (no more references remain)
 * 
the programmer calls shutdown
 * 
the script dies
 * This means the programmer can reuse the context throughout execution; placing
 * objects on the stack of the Worker will cause the Worker to execute the stacked
 * objects run method.
 * @link https://secure.php.net/manual/en/class.worker.php
 */
class Worker extends Thread implements Traversable, Countable, ArrayAccess
{
    /**
     * (PECL pthreads >= 3.0.0)

     * Allows the worker to collect references determined to be garbage by the
     * optionally given collector
     * @link https://secure.php.net/manual/en/worker.collect.php
     * @param null|callable $collector [optional] 
A Callable collector that returns
     * a boolean on whether the task can be collected or not. Only in rare cases
     * should a custom collector need to be used
     * @return int 
The number of remaining tasks on the worker's stack to be
     * collected
     */
    public function collect(?callable $collector = null) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Returns the number of tasks left on the stack
     * @link https://secure.php.net/manual/en/worker.getstacked.php
     * @return int 
Returns the number of tasks currently waiting to be
     * executed by the worker
     */
    public function getStacked() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Whether the worker has been shutdown or not
     * @link https://secure.php.net/manual/en/worker.isshutdown.php
     * @return bool 
Returns whether the worker has been shutdown or not
     */
    public function isShutdown() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Shuts down the Worker after executing all of the stacked tasks
     * @link https://secure.php.net/manual/en/worker.shutdown.php
     * @return bool 
Whether the worker was successfully shutdown or not
     */
    public function shutdown() {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Appends the new work to the stack of the referenced worker
     * @link https://secure.php.net/manual/en/worker.stack.php
     * @param Threaded $work 
A Threaded object to be executed by the Worker
     * @return int 
The new size of the stack
     */
    public function stack(Threaded $work) {}

    /**
     * (PECL pthreads >= 2.0.0)

     * Removes the first task (the oldest one) in the stack
     * @link https://secure.php.net/manual/en/worker.unstack.php
     * @return Threaded|null 
The item removed from the stack
     */
    public function unstack() {}
}

/**
 * (PECL pthreads >= 2.0.8)

 * Represents a garbage-collectable object.
 * @link https://secure.php.net/manual/en/class.collectable.php
 */
interface Collectable
{
    /**
     * (PECL pthreads >= 2.0.8)

     * Can be called in {@link Pool::collect()} to determine if this object is garbage
     * @link https://secure.php.net/manual/en/collectable.isgarbage.php
     * @return bool 
Whether this object is garbage or not
     */
    public function isGarbage(): bool;
}

/**
 * (PECL pthreads >= 3.0.0)

 * The Volatile class is new to pthreads v3. Its introduction is a consequence of
 * the new immutability semantics of Threaded members of Threaded classes. The
 * Volatile class enables for mutability of its Threaded members, and is also
 * used to store PHP arrays in Threaded contexts.
 * @see Threaded
 * @link https://secure.php.net/manual/en/class.volatile.php
 */
class Volatile extends Threaded implements Collectable, Traversable {}

 * Resource holding the key.
 * 

 * @return void
 */
#[Deprecated(since: '8.0')]
function openssl_pkey_free(#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey"], default: "resource")] $key): void {}

/**
 * Generates a new private key
 * @link https://php.net/manual/en/function.openssl-pkey-new.php
 * @param array|null $options [optional] 

 * You can finetune the key generation (such as specifying the number of
 * bits) using configargs. See
 * openssl_csr_new for more information about
 * configargs.
 * 
 * @return OpenSSLAsymmetricKey|resource|false a resource identifier for the pkey on success, or false on
 * error.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey|false"], default: "resource|false")]
function openssl_pkey_new(?array $options) {}

/**
 * Gets an exportable representation of a key into a string
 * @link https://php.net/manual/en/function.openssl-pkey-export.php
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
 * @param string &$output
 * @param string|null $passphrase [optional] 

 * The key is optionally protected by passphrase.
 * 
 * @param array|null $options [optional] 

 * configargs can be used to fine-tune the export
 * process by specifying and/or overriding options for the openssl
 * configuration file. See openssl_csr_new for more
 * information about configargs.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_pkey_export(
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $key,
    &$output,
    ?string $passphrase,
    ?array $options
): bool {}

/**
 * Gets an exportable representation of a key into a file
 * @link https://php.net/manual/en/function.openssl-pkey-export-to-file.php
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
 * @param string $output_filename 

 * Path to the output file.
 * 
 * @param string|null $passphrase [optional] 

 * The key can be optionally protected by a
 * passphrase.
 * 
 * @param array|null $options [optional] 

 * configargs can be used to fine-tune the export
 * process by specifying and/or overriding options for the openssl
 * configuration file. See openssl_csr_new for more
 * information about configargs.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_pkey_export_to_file(
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $key,
    string $output_filename,
    ?string $passphrase,
    ?array $options
): bool {}

/**
 * Get a private key
 * @link https://php.net/manual/en/function.openssl-pkey-get-private.php
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * 

 * key can be one of the following:
 * 

 * 
a string having the format
 * file://path/to/file.pem. The named file must
 * contain a PEM encoded certificate/private key (it may contain both).
 * 
 * 
A PEM formatted private key.
 * 

 * @param string|null $passphrase 

 * The optional parameter passphrase must be used
 * if the specified key is encrypted (protected by a passphrase).
 * 
 * @return OpenSSLAsymmetricKey|resource|false Returns a positive key resource identifier on success, or FALSE on error.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey|false"], default: "resource|false")]
function openssl_pkey_get_private(
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    ?string $passphrase = null
) {}

/**
 * Extract public key from certificate and prepare it for use
 * @link https://php.net/manual/en/function.openssl-pkey-get-public.php
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key 
certificate can be one of the following:
 * 

 * 
an X.509 certificate resource
 * 
a string having the format
 * file://path/to/file.pem. The named file must
 * contain a PEM encoded certificate/public key (it may contain both).
 * 
 * 
A PEM formatted public key.
 * 

 * @return OpenSSLAsymmetricKey|resource|false a positive key resource identifier on success, or false on error.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey|false"], default: "resource|false")]
function openssl_pkey_get_public(#[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $public_key) {}

/**
 * Returns an array with the key details
 * @link https://php.net/manual/en/function.openssl-pkey-get-details.php
 * @param OpenSSLAsymmetricKey|resource $key 

 * Resource holding the key.
 * 
 * @return array|false an array with the key details in success or false in failure.
 * Returned array has indexes bits (number of bits),
 * key (string representation of the public key) and
 * type (type of the key which is one of
 * OPENSSL_KEYTYPE_RSA,
 * OPENSSL_KEYTYPE_DSA,
 * OPENSSL_KEYTYPE_DH,
 * OPENSSL_KEYTYPE_EC or -1 meaning unknown).
 * 

 * 

 * Depending on the key type used, additional details may be returned. Note that
 * some elements may not always be available.
 */
#[ArrayShape(["bits" => "int", "key" => "string", "rsa" => "array", "dsa" => "array", "dh" => "array", "ec" => "array", "type" => "int"])]
function openssl_pkey_get_details(#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey"], default: "resource")] $key): array|false {}

/**
 * Free key resource
 * @link https://php.net/manual/en/function.openssl-free-key.php
 * @param OpenSSLAsymmetricKey|resource $key
 * @return void
 */
#[Deprecated(since: '8.0')]
function openssl_free_key(#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey"], default: "resource")] $key): void {}

/**
 * Alias of openssl_pkey_get_private
 * @link https://php.net/manual/en/function.openssl-get-privatekey.php
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * 

 * key can be one of the following:
 * 

 * 
a string having the format
 * file://path/to/file.pem. The named file must
 * contain a PEM encoded certificate/private key (it may contain both).
 * 
 * 
A PEM formatted private key.
 * 

 * @param string|null $passphrase [optional] 

 * The optional parameter passphrase must be used
 * if the specified key is encrypted (protected by a passphrase).
 * 
 * @return OpenSSLAsymmetricKey|resource|false Returns a positive key resource identifier on success, or FALSE on error.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey|false"], default: "resource|false")]
function openssl_get_privatekey(
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    ?string $passphrase
) {}

/**
 * Alias of openssl_pkey_get_public
 * @link https://php.net/manual/en/function.openssl-get-publickey.php
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key 

 * certificate can be one of the following:
 * 

 * 
an X.509 certificate resource
 * 
a string having the format
 * file://path/to/file.pem. The named file must
 * contain a PEM encoded certificate/public key (it may contain both).
 * 
 * 
A PEM formatted public key.
 * 

 * @return OpenSSLAsymmetricKey|false a positive key resource identifier on success, or FALSE on error.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey|false"], default: "resource|false")]
function openssl_get_publickey(#[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $public_key) {}

/**
 * Generate a new signed public key and challenge
 * @link https://php.net/manual/en/function.openssl-spki-new.php
 * @param OpenSSLAsymmetricKey|resource $private_key 

 * privkey should be set to a private key that was
 * previously generated by {@link https://php.net/en/manual/function.openssl-pkey-new.php openssl_pkey_new()} (or
 * otherwise obtained from the other openssl_pkey family of functions).
 * The corresponding public portion of the key will be used to sign the
 * CSR.
 * 
 * @param string $challenge 
The challenge associated to associate with the SPKAC
 * @param int $digest_algo 
The digest algorithm. See openssl_get_md_method().
 * @return string|false Returns a signed public key and challenge string or NULL on failure.
 * @since 5.6
 */
function openssl_spki_new(#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey"], default: "resource")] $private_key, string $challenge, int $digest_algo = 2): string|false {}

/**
 * Verifies a signed public key and challenge
 * @link https://php.net/manual/en/function.openssl-spki-verify.php
 * @param string $spki 
Expects a valid signed public key and challenge
 * @return bool Returns a boolean on success or failure.
 * @since 5.6
 */
function openssl_spki_verify(string $spki): bool {}

/**
 * Exports the challenge associated with a signed public key and challenge
 * @link https://php.net/manual/en/function.openssl-spki-export-challenge.php
 * @param string $spki 
Expects a valid signed public key and challenge
 * @return string|false Returns the associated challenge string or NULL on failure.
 * @since 5.6
 */
function openssl_spki_export_challenge(string $spki): string|false {}

/**
 * Exports a valid PEM formatted public key signed public key and challenge
 * @link https://php.net/manual/en/function.openssl-spki-export.php
 * @param string $spki 
Expects a valid signed public key and challenge
 * @return string|false Returns the associated PEM formatted public key or NULL on failure.
 * @since 5.6
 */
function openssl_spki_export(string $spki): string|false {}
/**
 * Parse an X.509 certificate and return a resource identifier for
 * it
 * @link https://php.net/manual/en/function.openssl-x509-read.php
 * @param OpenSSLCertificate|string|resource $certificate
 * @return OpenSSLCertificate|resource|false a resource identifier on success or false on failure.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|false"], default: "resource|false")]
function openssl_x509_read(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate) {}

/**
 * @param string $certificate
 * @param string $digest_algo [optional] hash method
 * @param bool $binary [optional]
 * @return string|false FALSE on failure
 * @since 5.6
 */
function openssl_x509_fingerprint(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate, string $digest_algo = 'sha1', bool $binary = false): string|false {}
/**
 * Free certificate resource
 * @link https://php.net/manual/en/function.openssl-x509-free.php
 * @param OpenSSLCertificate|resource|string $certificate
 * @return void
 */
#[Deprecated(since: '8.0')]
function openssl_x509_free(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate"], default: "resource|string")] $certificate): void {}

/**
 * Parse an X509 certificate and return the information as an array
 * @link https://php.net/manual/en/function.openssl-x509-parse.php
 * @param OpenSSLCertificate|string|resource $certificate
 * @param bool $short_names [optional] 

 * shortnames controls how the data is indexed in the
 * array - if shortnames is true (the default) then
 * fields will be indexed with the short name form, otherwise, the long name
 * form will be used - e.g.: CN is the shortname form of commonName.
 * 
 * @return array|false The structure of the returned data is (deliberately) not
 * yet documented, as it is still subject to change.
 */
#[ArrayShape([
    'name' => 'string',
    'subject' => 'string',
    'hash' => 'string',
    'issuer' => 'string',
    'version' => 'int',
    'serialNumber' => 'string',
    'serialNumberHex' => 'string',
    'validFrom' => 'string',
    'validTo' => 'string',
    'validFrom_time_t' => 'int',
    'validTo_time_t' => 'int',
    'alias' => 'string',
    'signatureTypeSN' => 'string',
    'signatureTypeLN' => 'string',
    'signatureTypeNID' => 'int',
    'purposes' => 'array',
    'extensions' => 'array'
])]
function openssl_x509_parse(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate,
    #[PhpStormStubsElementAvailable(from: '5.3', to: '7.0')] bool $shortname,
    #[PhpStormStubsElementAvailable(from: '7.1')] bool $short_names = true
): array|false {}

/**
 * Verifies if a certificate can be used for a particular purpose
 * @link https://php.net/manual/en/function.openssl-x509-checkpurpose.php
 * @param OpenSSLCertificate|string|resource $certificate 

 * The examined certificate.
 * 
 * @param int $purpose 

 * 
 * openssl_x509_checkpurpose purposes
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
Constant
Description
X509_PURPOSE_SSL_CLIENT
Can the certificate be used for the client side of an SSL
 * connection?
X509_PURPOSE_SSL_SERVER
Can the certificate be used for the server side of an SSL
 * connection?
X509_PURPOSE_NS_SSL_SERVER
Can the cert be used for Netscape SSL server?
X509_PURPOSE_SMIME_SIGN
Can the cert be used to sign S/MIME email?
X509_PURPOSE_SMIME_ENCRYPT
Can the cert be used to encrypt S/MIME email?
X509_PURPOSE_CRL_SIGN
Can the cert be used to sign a certificate revocation list
 * (CRL)?
X509_PURPOSE_ANY
Can the cert be used for Any/All purposes?
 * These options are not bitfields - you may specify one only!
 * 
 * @param array $ca_info 

 * cainfo should be an array of trusted CA files/dirs
 * as described in Certificate
 * Verification.
 * 
 * @param string|null $untrusted_certificates_file [optional] 

 * If specified, this should be the name of a PEM encoded file holding
 * certificates that can be used to help verify the certificate, although
 * no trust is placed in the certificates that come from that file.
 * 
 * @return int|bool true if the certificate can be used for the intended purpose,
 * false if it cannot, or -1 on error.
 */
function openssl_x509_checkpurpose(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate,
    int $purpose,
    #[PhpStormStubsElementAvailable(from: '5.3', to: '7.0')] array $ca_info,
    #[PhpStormStubsElementAvailable(from: '7.1')] array $ca_info = [],
    ?string $untrusted_certificates_file
): int|bool {}

/**
 * Checks if a private key corresponds to a certificate
 * @link https://php.net/manual/en/function.openssl-x509-check-private-key.php
 * @param OpenSSLCertificate|string|resource $certificate 

 * The certificate.
 * 
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key 

 * The private key.
 * 
 * @return bool true if key is the private key that
 * corresponds to cert, or false otherwise.
 */
function openssl_x509_check_private_key(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key
): bool {}

/**
 * Exports a certificate as a string
 * @link https://php.net/manual/en/function.openssl-x509-export.php
 * @param OpenSSLCertificate|string|resource $certificate
 * @param string &$output 

 * On success, this will hold the PEM.
 * 
 * @param bool $no_text [optional]
 * @return bool true on success or false on failure.
 */
function openssl_x509_export(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate, &$output, bool $no_text = true): bool {}

/**
 * Exports a certificate to file
 * @link https://php.net/manual/en/function.openssl-x509-export-to-file.php
 * @param OpenSSLCertificate|string|resource $certificate
 * @param string $output_filename 

 * Path to the output file.
 * 
 * @param bool $no_text [optional]
 * @return bool true on success or false on failure.
 */
function openssl_x509_export_to_file(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate, string $output_filename, bool $no_text = true): bool {}

/**
 * Verifies digital signature of x509 certificate against a public key
 * @link https://www.php.net/manual/en/function.openssl-x509-verify.php
 * @param OpenSSLCertificate|string|resource $certificate
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key
 * @return int Returns 1 if the signature is correct, 0 if it is incorrect, and -1 on error.
 * @since 7.4
 */
function openssl_x509_verify(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $public_key
): int {}

/**
 * Exports a PKCS#12 Compatible Certificate Store File to variable.
 * @link https://php.net/manual/en/function.openssl-pkcs12-export.php
 * @param OpenSSLCertificate|string|resource $certificate
 * @param string &$output 

 * On success, this will hold the PKCS#12.
 * 
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key 

 * Private key component of PKCS#12 file.
 * 
 * @param string $passphrase 

 * Encryption password for unlocking the PKCS#12 file.
 * 
 * @param array $options
 * @return bool true on success or false on failure.
 * @since 5.2.2
 */
function openssl_pkcs12_export(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate,
    &$output,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    string $passphrase,
    #[PhpStormStubsElementAvailable(from: '5.3', to: '7.0')] $args,
    #[PhpStormStubsElementAvailable(from: '7.1')] array $options = []
): bool {}

/**
 * Exports a PKCS#12 Compatible Certificate Store File
 * @link https://php.net/manual/en/function.openssl-pkcs12-export-to-file.php
 * @param OpenSSLCertificate|string|resource $certificate
 * @param string $output_filename 

 * Path to the output file.
 * 
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key 

 * Private key component of PKCS#12 file.
 * 
 * @param string $passphrase 

 * Encryption password for unlocking the PKCS#12 file.
 * 
 * @param array $options
 * @return bool true on success or false on failure.
 * @since 5.2.2
 */
function openssl_pkcs12_export_to_file(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate, string $output_filename, $private_key, string $passphrase, array $options = []): bool {}

/**
 * Parse a PKCS#12 Certificate Store into an array
 * @link https://php.net/manual/en/function.openssl-pkcs12-read.php
 * @param string $pkcs12
 * @param array &$certificates 

 * On success, this will hold the Certificate Store Data.
 * 
 * @param string $passphrase 

 * Encryption password for unlocking the PKCS#12 file.
 * 
 * @return bool true on success or false on failure.
 * @since 5.2.2
 */
function openssl_pkcs12_read(string $pkcs12, &$certificates, string $passphrase): bool {}

/**
 * Generates a CSR
 * @link https://php.net/manual/en/function.openssl-csr-new.php
 * @param array $distinguished_names 

 * The Distinguished Name to be used in the certificate.
 * 
 * @param OpenSSLAsymmetricKey &$private_key 

 * privkey should be set to a private key that was
 * previously generated by openssl_pkey_new (or
 * otherwise obtained from the other openssl_pkey family of functions).
 * The corresponding public portion of the key will be used to sign the
 * CSR.
 * 
 * @param array|null $options [optional] 

 * By default, the information in your system openssl.conf
 * is used to initialize the request; you can specify a configuration file
 * section by setting the config_section_section key of
 * configargs. You can also specify an alternative
 * openssl configuration file by setting the value of the
 * config key to the path of the file you want to use.
 * The following keys, if present in configargs
 * behave as their equivalents in the openssl.conf, as
 * listed in the table below.
 * 
 * Configuration overrides
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
configargs key
type
openssl.conf equivalent
description
digest_alg
string
default_md
Selects which digest method to use
x509_extensions
string
x509_extensions
Selects which extensions should be used when creating an x509
 * certificate
req_extensions
string
req_extensions
Selects which extensions should be used when creating a CSR
private_key_bits
integer
default_bits
Specifies how many bits should be used to generate a private
 * key
private_key_type
integer
none
Specifies the type of private key to create. This can be one
 * of OPENSSL_KEYTYPE_DSA,
 * OPENSSL_KEYTYPE_DH or
 * OPENSSL_KEYTYPE_RSA.
 * The default value is OPENSSL_KEYTYPE_RSA which
 * is currently the only supported key type.
 * 
encrypt_key
boolean
encrypt_key
Should an exported key (with passphrase) be encrypted?
encrypt_key_cipher
integer
none

 * One of cipher constants.
 * 
 * 
 * @param array|null $extra_attributes [optional] 

 * extraattribs is used to specify additional
 * configuration options for the CSR. Both dn and
 * extraattribs are associative arrays whose keys are
 * converted to OIDs and applied to the relevant part of the request.
 * 
 * @return OpenSSLCertificateSigningRequest|resource|false the CSR.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificateSigningRequest|false"], default: "resource|false")]
function openssl_csr_new(
    array $distinguished_names,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey'], default: 'resource')] &$private_key,
    ?array $options,
    ?array $extra_attributes
) {}

/**
 * Exports a CSR as a string
 * @link https://php.net/manual/en/function.openssl-csr-export.php
 * @param OpenSSLCertificateSigningRequest|string|resource $csr
 * @param string &$output
 * @param bool $no_text [optional]
 * @return bool true on success or false on failure.
 */
function openssl_csr_export(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificateSigningRequest|string"], default: "resource|string")] $csr, &$output, bool $no_text = true): bool {}

/**
 * Exports a CSR to a file
 * @link https://php.net/manual/en/function.openssl-csr-export-to-file.php
 * @param OpenSSLCertificateSigningRequest|string|resource $csr
 * @param string $output_filename 

 * Path to the output file.
 * 
 * @param bool $no_text [optional]
 * @return bool true on success or false on failure.
 */
function openssl_csr_export_to_file(#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificateSigningRequest|string"], default: "resource|string")] $csr, string $output_filename, bool $no_text = true): bool {}

/**
 * Sign a CSR with another certificate (or itself) and generate a certificate
 * @link https://php.net/manual/en/function.openssl-csr-sign.php
 * @param OpenSSLCertificateSigningRequest|string|resource $csr 

 * A CSR previously generated by openssl_csr_new.
 * It can also be the path to a PEM encoded CSR when specified as
 * file://path/to/csr or an exported string generated
 * by openssl_csr_export.
 * 
 * @param OpenSSLCertificate|resource|string|null $ca_certificate 

 * The generated certificate will be signed by cacert.
 * If cacert is null, the generated certificate
 * will be a self-signed certificate.
 * 
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key 

 * priv_key is the private key that corresponds to
 * cacert.
 * 
 * @param int $days 

 * days specifies the length of time for which the
 * generated certificate will be valid, in days.
 * 
 * @param array|null $options [optional] 

 * You can finetune the CSR signing by configargs.
 * See openssl_csr_new for more information about
 * configargs.
 * 
 * @param int $serial [optional] 

 * An optional the serial number of issued certificate. If not specified
 * it will default to 0.
 * 
 * @return OpenSSLCertificate|resource|false an x509 certificate resource on success, false on failure.
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|false"], default: "resource|false")]
function openssl_csr_sign(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificateSigningRequest|string"], default: "resource|string")] $csr,
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string|null"], default: "resource|string|null")] $ca_certificate,
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey|OpenSSLCertificate|array|string"], default: "resource|array|string")] $private_key,
    int $days,
    ?array $options,
    int $serial = 0,
    #[PhpStormStubsElementAvailable(from: '8.4')] ?string $serial_hex = null
) {}

/**
 * Returns the subject of a CERT
 * @link https://php.net/manual/en/function.openssl-csr-get-subject.php
 * @param OpenSSLCertificateSigningRequest|string|resource $csr
 * @param bool $short_names [optional]
 * @return array|false
 */
function openssl_csr_get_subject(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificateSigningRequest|string"], default: "resource|string")] $csr,
    #[PhpStormStubsElementAvailable(from: '7.1')] bool $short_names = true
): array|false {}

/**
 * Returns the public key of a CERT
 * @link https://php.net/manual/en/function.openssl-csr-get-public-key.php
 * @param OpenSSLCertificateSigningRequest|string|resource $csr
 * @param bool $short_names [optional]
 * @return OpenSSLAsymmetricKey|resource|false
 */
#[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey|false"], default: "resource|false")]
function openssl_csr_get_public_key(
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificateSigningRequest|string"], default: "resource|string")] $csr,
    #[PhpStormStubsElementAvailable(from: '7.1')] bool $short_names = true
) {}

/**
 * Computes a digest
 * @link https://php.net/manual/en/function.openssl-digest.php
 * @param string $data 

 * The data.
 * 
 * @param string $digest_algo 

 * The digest method.
 * 
 * @param bool $binary [optional] 

 * Setting to true will return as raw output data, otherwise the return
 * value is binhex encoded.
 * 
 * @return string|false the digested hash value on success or false on failure.
 */
function openssl_digest(string $data, string $digest_algo, bool $binary = false): string|false {}

/**
 * Encrypts data
 * @link https://php.net/manual/en/function.openssl-encrypt.php
 * @param string $data 

 * The data.
 * 
 * @param string $cipher_algo 

 * The cipher method. For a list of available cipher methods, use {@see openssl_get_cipher_methods()}.
 * 
 * @param string $passphrase 

 * The key.
 * 
 * @param int $options [optional] 

 * options is a bitwise disjunction of the flags OPENSSL_RAW_DATA and OPENSSL_ZERO_PADDING.
 * 
 * @param string $iv [optional] 

 * A non-NULL Initialization Vector.
 * 
 * @param string &$tag [optional] 
The authentication tag passed by reference when using AEAD cipher mode (GCM or CCM).
 * @param string $aad [optional] 
Additional authentication data.
 * @param int $tag_length [optional] 

 * The length of the authentication tag. Its value can be between 4 and 16 for GCM mode.
 * 
 * @return string|false the encrypted string on success or false on failure.
 */
function openssl_encrypt(
    string $data,
    string $cipher_algo,
    string $passphrase,
    int $options = 0,
    string $iv = "",
    #[PhpStormStubsElementAvailable(from: '7.1')] &$tag,
    #[PhpStormStubsElementAvailable(from: '7.1')] string $aad = "",
    #[PhpStormStubsElementAvailable(from: '7.1')] int $tag_length = 16
): string|false {}

/**
 * Decrypts data
 * @link https://php.net/manual/en/function.openssl-decrypt.php
 * @param string $data 

 * The data.
 * 
 * @param string $cipher_algo 

 * The cipher method.
 * 
 * @param string $passphrase 

 * The password.
 * 
 * @param int $options [optional] 

 * Setting to true will take a raw encoded string,
 * otherwise a base64 string is assumed for the
 * data parameter.
 * 
 * @param string $iv [optional] 

 * A non-NULL Initialization Vector.
 * 
 * @param string|null $tag 

 * The authentication tag in AEAD cipher mode. If it is incorrect, the authentication fails and the function returns FALSE.
 * 
 * @param string $aad [optional] 
Additional authentication data.
 * @return string|false The decrypted string on success or false on failure.
 */
function openssl_decrypt(
    string $data,
    string $cipher_algo,
    string $passphrase,
    int $options = 0,
    string $iv = "",
    #[PhpStormStubsElementAvailable(from: '7.1')] #[LanguageLevelTypeAware(['8.1' => 'string|null'], default: 'string')] $tag = null,
    #[PhpStormStubsElementAvailable(from: '7.1')] string $aad = ""
): string|false {}

/**
 * (PHP 5 >= PHP 5.3.3)

 * Gets the cipher iv length
 * @link https://php.net/manual/en/function.openssl-cipher-iv-length.php
 * @param string $cipher_algo 

 * The method.
 * 
 * @return int|false the cipher length on success, or false on failure.
 */
function openssl_cipher_iv_length(string $cipher_algo): int|false {}

/**
 * This function works in exactly the same way as openssl_cipher_iv_length but for a key length. This is especially
 * useful to make sure that the right key length is provided to openssl_encrypt and openssl_decrypt.
 * @param string $cipher_algo
 * @return int|false
 * @since 8.2
 */
function openssl_cipher_key_length(string $cipher_algo): int|false {}

/**
 * Generate signature
 * @link https://php.net/manual/en/function.openssl-sign.php
 * @param string $data
 * @param string &$signature 

 * If the call was successful the signature is returned in
 * signature.
 * 
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * @param string|int $algorithm [optional] 

 * For more information see the list of Signature Algorithms.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_sign(
    string $data,
    &$signature,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    string|int $algorithm = OPENSSL_ALGO_SHA1
): bool {}

/**
 * Verify signature
 * @link https://php.net/manual/en/function.openssl-verify.php
 * @param string $data
 * @param string $signature
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key
 * @param string|int $algorithm [optional] 

 * For more information see the list of Signature Algorithms.
 * 
 * @return int|false 1 if the signature is correct, 0 if it is incorrect, and
 * -1 on error.
 */
function openssl_verify(
    string $data,
    string $signature,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $public_key,
    string|int $algorithm = OPENSSL_ALGO_SHA1
): int|false {}

/**
 * Seal (encrypt) data
 * @link https://php.net/manual/en/function.openssl-seal.php
 * @param string $data
 * @param string &$sealed_data
 * @param array &$encrypted_keys
 * @param array $public_key
 * @param string $cipher_algo
 * @param string &$iv
 * @return int|false the length of the sealed data on success, or false on error.
 * If successful the sealed data is returned in
 * sealed_data, and the envelope keys in
 * env_keys.
 */
function openssl_seal(
    string $data,
    &$sealed_data,
    &$encrypted_keys,
    array $public_key,
    #[PhpStormStubsElementAvailable(from: '5.3', to: '7.4')] string $cipher_algo = '',
    #[PhpStormStubsElementAvailable(from: '8.0')] string $cipher_algo,
    #[PhpStormStubsElementAvailable(from: '7.0')] &$iv = null
): int|false {}

/**
 * Open sealed data
 * @link https://php.net/manual/en/function.openssl-open.php
 * @param string $data
 * @param string &$output 

 * If the call is successful the opened data is returned in this
 * parameter.
 * 
 * @param string $encrypted_key
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * @param string $cipher_algo The cipher method.
 * @param string|null $iv [optional] The initialization vector.
 * @return bool true on success or false on failure.
 */
function openssl_open(
    string $data,
    &$output,
    string $encrypted_key,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    #[PhpStormStubsElementAvailable(from: '7.0', to: '7.4')] string $cipher_algo = '',
    #[PhpStormStubsElementAvailable(from: '8.0')] string $cipher_algo,
    #[PhpStormStubsElementAvailable(from: '7.0')] ?string $iv
): bool {}

/**
 * Generates a PKCS5 v2 PBKDF2 string, defaults to SHA-1
 * @link https://secure.php.net/manual/en/function.openssl-pbkdf2.php
 * @param string $password
 * @param string $salt
 * @param int $key_length
 * @param int $iterations
 * @param string $digest_algo [optional]
 * @return string|false Returns string or FALSE on failure.
 * @since 5.5
 */
function openssl_pbkdf2(string $password, string $salt, int $key_length, int $iterations, string $digest_algo = 'sha1'): string|false {}

/**
 * Verifies the signature of an S/MIME signed message
 * @link https://php.net/manual/en/function.openssl-pkcs7-verify.php
 * @param string $input_filename 

 * Path to the message.
 * 
 * @param int $flags 

 * flags can be used to affect how the signature is
 * verified - see PKCS7 constants
 * for more information.
 * 
 * @param string|null $signers_certificates_filename [optional] 

 * If the outfilename is specified, it should be a
 * string holding the name of a file into which the certificates of the
 * persons that signed the messages will be stored in PEM format.
 * 
 * @param array $ca_info 

 * If the cainfo is specified, it should hold
 * information about the trusted CA certificates to use in the verification
 * process - see certificate
 * verification for more information about this parameter.
 * 
 * @param string|null $untrusted_certificates_filename [optional] 

 * If the extracerts is specified, it is the filename
 * of a file containing a bunch of certificates to use as untrusted CAs.
 * 
 * @param string|null $content [optional] 

 * You can specify a filename with content that will
 * be filled with the verified data, but with the signature information
 * stripped.
 * @param string|null $output_filename [optional]
 * 
 * @return bool|int true if the signature is verified, false if it is not correct
 * (the message has been tampered with, or the signing certificate is invalid),
 * or -1 on error.
 */
function openssl_pkcs7_verify(
    string $input_filename,
    int $flags,
    ?string $signers_certificates_filename,
    array $ca_info = [],
    ?string $untrusted_certificates_filename,
    ?string $content,
    #[PhpStormStubsElementAvailable("7.2")] ?string $output_filename
): int|bool {}

/**
 * Decrypts an S/MIME encrypted message
 * @link https://php.net/manual/en/function.openssl-pkcs7-decrypt.php
 * @param string $input_filename
 * @param string $output_filename 

 * The decrypted message is written to the file specified by
 * outfilename.
 * 
 * @param OpenSSLCertificate|string|resource $certificate
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $private_key [optional]
 * @return bool true on success or false on failure.
 */
function openssl_pkcs7_decrypt(
    string $input_filename,
    string $output_filename,
    $certificate,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null'], default: 'resource|array|string|null')] $private_key
): bool {}

/**
 * Sign an S/MIME message
 * @link https://php.net/manual/en/function.openssl-pkcs7-sign.php
 * @param string $input_filename
 * @param string $output_filename
 * @param OpenSSLCertificate|string|resource $certificate
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * @param array|null $headers 

 * headers is an array of headers that
 * will be prepended to the data after it has been signed (see
 * openssl_pkcs7_encrypt for more information about
 * the format of this parameter).
 * 
 * @param int $flags [optional] 

 * flags can be used to alter the output - see PKCS7 constants.
 * 
 * @param string|null $untrusted_certificates_filename [optional] 

 * extracerts specifies the name of a file containing
 * a bunch of extra certificates to include in the signature which can for
 * example be used to help the recipient to verify the certificate that you used.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_pkcs7_sign(
    string $input_filename,
    string $output_filename,
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|string"], default: "resource|string")] $certificate,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    ?array $headers,
    int $flags = PKCS7_DETACHED,
    ?string $untrusted_certificates_filename
): bool {}

/**
 * Encrypt an S/MIME message
 * @link https://php.net/manual/en/function.openssl-pkcs7-encrypt.php
 * @param string $input_filename
 * @param string $output_filename
 * @param OpenSSLCertificate|array|string|resource $certificate 

 * Either a lone X.509 certificate, or an array of X.509 certificates.
 * 
 * @param array|null $headers 

 * headers is an array of headers that
 * will be prepended to the data after it has been encrypted.
 * 
 * 

 * headers can be either an associative array
 * keyed by header name, or an indexed array, where each element contains
 * a single header line.
 * 
 * @param int $flags [optional] 

 * flags can be used to specify options that affect
 * the encoding process - see PKCS7
 * constants.
 * 
 * @param int $cipher_algo [optional] 

 * One of cipher constants.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_pkcs7_encrypt(
    string $input_filename,
    string $output_filename,
    #[LanguageLevelTypeAware(["8.0" => "OpenSSLCertificate|array|string"], default: "resource|array|string")] $certificate,
    ?array $headers,
    int $flags = 0,
    int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC
): bool {}

/**
 * Encrypts data with private key
 * @link https://php.net/manual/en/function.openssl-private-encrypt.php
 * @param string $data
 * @param string &$encrypted_data
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * @param int $padding [optional] 

 * padding can be one of
 * OPENSSL_PKCS1_PADDING,
 * OPENSSL_NO_PADDING.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_private_encrypt(
    string $data,
    &$encrypted_data,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    int $padding = OPENSSL_PKCS1_PADDING
): bool {}

/**
 * Decrypts data with private key
 * @link https://php.net/manual/en/function.openssl-private-decrypt.php
 * @param string $data
 * @param string &$decrypted_data
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key 

 * key must be the private key corresponding that
 * was used to encrypt the data.
 * 
 * @param int $padding [optional] 

 * padding can be one of
 * OPENSSL_PKCS1_PADDING,
 * OPENSSL_SSLV23_PADDING,
 * OPENSSL_PKCS1_OAEP_PADDING,
 * OPENSSL_NO_PADDING.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_private_decrypt(
    string $data,
    &$decrypted_data,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    int $padding = OPENSSL_PKCS1_PADDING
): bool {}

/**
 * Encrypts data with public key
 * @link https://php.net/manual/en/function.openssl-public-encrypt.php
 * @param string $data
 * @param string &$encrypted_data 

 * This will hold the result of the encryption.
 * 
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key 

 * The public key.
 * 
 * @param int $padding [optional] 

 * padding can be one of
 * OPENSSL_PKCS1_PADDING,
 * OPENSSL_SSLV23_PADDING,
 * OPENSSL_PKCS1_OAEP_PADDING,
 * OPENSSL_NO_PADDING.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_public_encrypt(
    string $data,
    &$encrypted_data,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $public_key,
    int $padding = OPENSSL_PKCS1_PADDING
): bool {}

/**
 * Decrypts data with public key
 * @link https://php.net/manual/en/function.openssl-public-decrypt.php
 * @param string $data
 * @param string &$decrypted_data
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key 

 * key must be the public key corresponding that
 * was used to encrypt the data.
 * 
 * @param int $padding [optional] 

 * padding can be one of
 * OPENSSL_PKCS1_PADDING,
 * OPENSSL_NO_PADDING.
 * 
 * @return bool true on success or false on failure.
 */
function openssl_public_decrypt(
    string $data,
    &$decrypted_data,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $public_key,
    int $padding = OPENSSL_PKCS1_PADDING
): bool {}

/**
 * Gets available digest methods
 * @link https://php.net/manual/en/function.openssl-get-md-methods.php
 * @param bool $aliases [optional] 

 * Set to true if digest aliases should be included within the
 * returned array.
 * 
 * @return array An array of available digest methods.
 */
function openssl_get_md_methods(bool $aliases = false): array {}

/**
 * Gets available cipher methods
 * @link https://php.net/manual/en/function.openssl-get-cipher-methods.php
 * @param bool $aliases [optional] 

 * Set to true if cipher aliases should be included within the
 * returned array.
 * 
 * @return array An array of available cipher methods.
 */
function openssl_get_cipher_methods(bool $aliases = false): array {}

/**
 * Computes shared secret for public value of remote DH key and local DH key
 * @link https://php.net/manual/en/function.openssl-dh-compute-key.php
 * @param string $public_key 

 * Public key
 * 
 * @param OpenSSLAsymmetricKey|resource $private_key 

 * DH key
 * 
 * @return string|false computed key on success or false on failure.
 * @since 5.3
 */
function openssl_dh_compute_key(string $public_key, #[LanguageLevelTypeAware(["8.0" => "OpenSSLAsymmetricKey"], default: "resource")] $private_key): string|false {}

/**
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * @param int $key_length
 * @return string|false
 * @since 7.3
 */
function openssl_pkey_derive(
    $public_key,
    #[LanguageLevelTypeAware(['8.0' => 'OpenSSLAsymmetricKey|OpenSSLCertificate|array|string'], default: 'resource|array|string')] $private_key,
    int $key_length = 0
): string|false {}

/**
 * Generates a string of pseudo-random bytes, with the number of bytes determined by the length parameter.
 * 
It also indicates if a cryptographically strong algorithm was used to produce the pseudo-random bytes,
 * and does this via the optional crypto_strong parameter. It's rare for this to be FALSE, but some systems may be broken or old.
 * @link https://php.net/manual/en/function.openssl-random-pseudo-bytes.php
 * @param positive-int $length 

 * The length of the desired string of bytes. Must be a positive integer. PHP will
 * try to cast this parameter to a non-null integer to use it.
 * 
 * @param bool &$strong_result [optional]

 * If passed into the function, this will hold a boolean value that determines
 * if the algorithm used was "cryptographically strong", e.g., safe for usage with GPG,
 * passwords, etc. true if it did, otherwise false
 * 
 * @return string|false the generated string of bytes on success, or false on failure.
 */
#[LanguageLevelTypeAware(["7.4" => "string"], default: "string|false")]
function openssl_random_pseudo_bytes(int $length, &$strong_result) {}

/**
 * Return openSSL error message
 * @link https://php.net/manual/en/function.openssl-error-string.php
 * @return string|false an error message string, or false if there are no more error
 * messages to return.
 */
function openssl_error_string(): string|false {}

/**
 * Retrieve the available certificate locations
 * @link https://php.net/manual/en/function.openssl-get-cert-locations.php
 * @return array an array with the available certificate locations
 * @since 5.6
 */
#[ArrayShape([
    'default_cert_file' => 'string',
    'default_cert_file_env' => 'string',
    'default_cert_dir' => 'string',
    'default_cert_dir_env' => 'string',
    'default_private_dir' => 'string',
    'default_default_cert_area' => 'string',
    'ini_cafile' => 'string',
    'ini_capath' => 'string'
])]
function openssl_get_cert_locations(): array {}

function openssl_get_curve_names(): array|false {}

/**
 * @param string $data
 * @param array &$certificates
 * @return bool
 * @since 7.2
 */
function openssl_pkcs7_read(string $data, &$certificates): bool {}

/**
 * Verifies that the data block is intact, the signer is who they say they are, and returns the certs of the signers.
 * @param string $input_filename
 * @param int $flags [optional]
 * @param string|null $certificates [optional]
 * @param array $ca_info
 * @param string|null $untrusted_certificates_filename [optional]
 * @param string|null $content [optional]
 * @param string|null $pk7 [optional]
 * @param string|null $sigfile [optional]
 * @param int $encoding [optional]
 * @return bool
 * @since 8.0
 */
function openssl_cms_verify(string $input_filename, int $flags = 0, ?string $certificates, array $ca_info = [], ?string $untrusted_certificates_filename, ?string $content, ?string $pk7, ?string $sigfile, int $encoding = OPENSSL_ENCODING_SMIME): bool {}

/**
 * Encrypts the message in the file with the certificates and outputs the result to the supplied file.
 * @param string $input_filename
 * @param string $output_filename
 * @param resource|string|array $certificate
 * @param null|array $headers
 * @param int $flags
 * @param int $encoding
 * @param int $cipher_algo
 * @return bool
 * @since 8.0
 */
function openssl_cms_encrypt(string $input_filename, string $output_filename, $certificate, ?array $headers, int $flags = 0, int $encoding = OPENSSL_ENCODING_SMIME, int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC): bool {}

/**
 * Signs the MIME message in the file with a cert and key and output the result to the supplied file.
 * @param string $input_filename
 * @param string $output_filename
 * @param OpenSSLCertificate|string $certificate
 * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key
 * @param array|null $headers
 * @param int $flags [optional]
 * @param int $encoding [optional]
 * @param string|null $untrusted_certificates_filename [optional]
 * @return bool
 * @since 8.0
 */
function openssl_cms_sign(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, $private_key, ?array $headers, int $flags = 0, int $encoding = OPENSSL_ENCODING_SMIME, ?string $untrusted_certificates_filename): bool {}

/**
 * Decrypts the S/MIME message in the file and outputs the results to the supplied file.
 * @param string $input_filename
 * @param string $output_filename
 * @param resource|string $certificate
 * @param resource|string|array $private_key
 * @param int $encoding
 * @return bool
 * @since 8.0
 */
function openssl_cms_decrypt(string $input_filename, string $output_filename, $certificate, $private_key = null, int $encoding = OPENSSL_ENCODING_SMIME): bool {}

/**
 * Exports the CMS file to an array of PEM certificates.
 * @param string $input_filename
 * @param array &$certificates
 * @return bool
 * @since 8.0
 */
function openssl_cms_read(string $input_filename, &$certificates): bool {}

define('OPENSSL_VERSION_TEXT', "OpenSSL 1.0.0e 6 Sep 2011");
define('OPENSSL_VERSION_NUMBER', 268435551);
define('X509_PURPOSE_SSL_CLIENT', 1);
define('X509_PURPOSE_SSL_SERVER', 2);
define('X509_PURPOSE_NS_SSL_SERVER', 3);
define('X509_PURPOSE_SMIME_SIGN', 4);
define('X509_PURPOSE_SMIME_ENCRYPT', 5);
define('X509_PURPOSE_CRL_SIGN', 6);
define('X509_PURPOSE_ANY', 7);
/**
 * @since 8.4
 */
define('X509_PURPOSE_OCSP_HELPER', 8);
/**
 * @since 8.4
 */
define('X509_PURPOSE_TIMESTAMP_SIGN', 9);

/**
 * Used as default algorithm by openssl_sign and
 * openssl_verify.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('OPENSSL_ALGO_SHA1', 1);
define('OPENSSL_ALGO_MD5', 2);
define('OPENSSL_ALGO_MD4', 3);
define('OPENSSL_ALGO_MD2', 4);
define('OPENSSL_ALGO_DSS1', 5);
define('OPENSSL_ALGO_SHA224', 6);
define('OPENSSL_ALGO_SHA256', 7);
define('OPENSSL_ALGO_SHA384', 8);
define('OPENSSL_ALGO_SHA512', 9);
define('OPENSSL_ALGO_RMD160', 10);
/**
 * When signing a message, use cleartext signing with the MIME
 * type "multipart/signed". This is the default
 * if you do not specify any flags to
 * openssl_pkcs7_sign.
 * If you turn this option off, the message will be signed using
 * opaque signing, which is more resistant to translation by mail relays
 * but cannot be read by mail agents that do not support S/MIME.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_DETACHED', 64);

/**
 * Adds text/plain content type headers to encrypted/signed
 * message. If decrypting or verifying, it strips those headers from
 * the output - if the decrypted or verified message is not of MIME type
 * text/plain then an error will occur.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_TEXT', 1);

/**
 * When verifying a message, certificates (if
 * any) included in the message are normally searched for the
 * signing certificate. With this option only the
 * certificates specified in the extracerts
 * parameter of openssl_pkcs7_verify are
 * used. The supplied certificates can still be used as
 * untrusted CAs however.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_NOINTERN', 16);

/**
 * Do not verify the signers certificate of a signed
 * message.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_NOVERIFY', 32);

/**
 * Do not chain verification of signers certificates: that is
 * don't use the certificates in the signed message as untrusted CAs.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_NOCHAIN', 8);

/**
 * When signing a message the signer's certificate is normally
 * included - with this option it is excluded. This will reduce the
 * size of the signed message but the verifier must have a copy of the
 * signers certificate available locally (passed using the
 * extracerts to
 * openssl_pkcs7_verify for example).
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_NOCERTS', 2);

/**
 * Normally when a message is signed, a set of attributes are
 * included which include the signing time and the supported symmetric
 * algorithms. With this option they are not included.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_NOATTR', 256);

/**
 * Normally the input message is converted to "canonical" format
 * which is effectively using CR and LF
 * as end of line: as required by the S/MIME specification. When this
 * option is present, no translation occurs. This is useful when
 * handling binary data which may not be in MIME format.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_BINARY', 128);

/**
 * @since 8.3
 */
define('PKCS7_NOOLDMIMETYPE', 1024);

/**
 * Don't try and verify the signatures on a message
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('PKCS7_NOSIGS', 4);
define('OPENSSL_PKCS1_PADDING', 1);
define('OPENSSL_SSLV23_PADDING', 2);
define('OPENSSL_NO_PADDING', 3);
define('OPENSSL_PKCS1_OAEP_PADDING', 4);
define('OPENSSL_CIPHER_RC2_40', 0);
define('OPENSSL_CIPHER_RC2_128', 1);
define('OPENSSL_CIPHER_RC2_64', 2);
define('OPENSSL_CIPHER_DES', 3);
define('OPENSSL_CIPHER_3DES', 4);
define('OPENSSL_KEYTYPE_RSA', 0);
define('OPENSSL_KEYTYPE_DSA', 1);
define('OPENSSL_KEYTYPE_DH', 2);
define('OPENSSL_KEYTYPE_EC', 3);
/**
 * @since 8.4
 */
define('OPENSSL_KEYTYPE_X25519', 4);
/**
 * @since 8.4
 */
define('OPENSSL_KEYTYPE_ED25519', 5);
/**
 * @since 8.4
 */
define('OPENSSL_KEYTYPE_X448', 6);
/**
 * @since 8.4
 */
define('OPENSSL_KEYTYPE_ED448', 7);

/**
 * Whether SNI support is available or not.
 * @link https://php.net/manual/en/openssl.constants.php
 */
define('OPENSSL_TLSEXT_SERVER_NAME', 1);

// End of openssl v.

/** @link https://php.net/manual/en/openssl.ciphers.php */
define('OPENSSL_CIPHER_AES_128_CBC', 5);
/** @link https://php.net/manual/en/openssl.ciphers.php */
define('OPENSSL_CIPHER_AES_192_CBC', 6);
/** @link https://php.net/manual/en/openssl.ciphers.php */
define('OPENSSL_CIPHER_AES_256_CBC', 7);
define('OPENSSL_RAW_DATA', 1);
define('OPENSSL_ZERO_PADDING', 2);
define('OPENSSL_DONT_ZERO_PAD_KEY', 4);

/**
 * @since 8.0
 */
define('OPENSSL_CMS_DETACHED', 64);
/**
 * @since 8.0
 */
define('OPENSSL_CMS_TEXT', 1);
/**
 * @since 8.0
 */
define('OPENSSL_CMS_NOINTERN', 16);
/**
 * @since 8.0
 */
define('OPENSSL_CMS_NOVERIFY', 32);
/**
 * @since 8.0
 */
define('OPENSSL_CMS_NOCERTS', 2);
/**
 * @since 8.0
 */
define('OPENSSL_CMS_NOATTR', 256);
/**
 * @since 8.0
 */
define('OPENSSL_CMS_BINARY', 128);
/**
 * @since 8.0
 */
define('OPENSSL_CMS_NOSIGS', 12);
/**
 * @since 8.0
 */
define('OPENSSL_ENCODING_DER', 0);
/**
 * @since 8.0
 */
define('OPENSSL_ENCODING_SMIME', 1);
/**
 * @since 8.0
 */
define('OPENSSL_ENCODING_PEM', 2);

define('OPENSSL_DEFAULT_STREAM_CIPHERS', "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:" .
"ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:" .
"DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:" .
"ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:" .
"ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:" .
"DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:" .
"AES256-GCM-SHA384:AES128:AES256:HIGH:!SSLv2:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!RC4:!ADH");

/**
 * @since 8.3
 */
define('OPENSSL_CMS_OLDMIMETYPE', 1024);

/**
 * @since 8.0
 */
final class OpenSSLCertificate
{
    /**
     * Cannot directly construct OpenSSLCertificate, use openssl_x509_read() instead
     * @see openssl_x509_read()
     */
    private function __construct() {}
}

/**
 * @since 8.0
 */
final class OpenSSLCertificateSigningRequest
{
    /**
     * Cannot directly construct OpenSSLCertificateSigningRequest, use openssl_csr_new() instead
     * @see openssl_csr_new()
     */
    private function __construct() {}
}

/**
 * @since 8.0
 */
final class OpenSSLAsymmetricKey
{
    /**
     * Cannot directly construct OpenSSLAsymmetricKey, use openssl_pkey_new() instead
     * @see openssl_pkey_new()
     */
    private function __construct() {}
}
LuaSandbox is an extension for PHP 5, PHP 7, and HHVM to allow safely running
 * untrusted Lua 5.1 code from within PHP.

 *
 * @link https://www.php.net/manual/en/book.luasandbox.php
 * @package luasandbox
 * @version 3.0.3
 */

/**
 * The LuaSandbox class creates a Lua environment and allows for execution of Lua code.
 *
 * @link https://www.php.net/manual/en/class.luasandbox.php
 * @since luasandbox >= 1.0.0
 */
class LuaSandbox
{
    /**
     * Used with LuaSandbox::getProfilerFunctionReport()
     * to return timings in samples.
     */
    public const SAMPLES = 0;

    /**
     * Used with LuaSandbox::getProfilerFunctionReport()
     * to return timings in seconds.
     */
    public const SECONDS = 1;

    /**
     * Used with LuaSandbox::getProfilerFunctionReport()
     * to return timings in percentages of the total.
     */
    public const PERCENT = 2;

    /**
     * Call a function in a Lua global variable.
     *
     * 
If the name contains "." characters, the function is located via recursive table accesses,
     * as if the name were a Lua expression.
     *
     * 
If the variable does not exist, or is not a function,
     * false will be returned and a warning issued.
     *
     * 
For more information about calling Lua functions and the return values,
     * see LuaSandboxFunction::call().
     *
     * @link https://www.php.net/manual/en/luasandbox.callFunction.php
     * @param string $name 
Lua variable name.
     * @param mixed[] $arguments 
Arguments to the function.
     * @return array|bool 
Returns an array of values returned by the Lua function,
     * which may be empty, or false in case of failure.
     * @see LuaSandboxFunction::call()
     * @since luasandbox >= 1.0.0
     */
    public function callFunction($name, array $arguments) {}

    /**
     * Disable the profiler.
     *
     * @link https://www.php.net/manual/en/luasandbox.disableProfiler.php
     * @since luasandbox >= 1.1.0
     * @see LuaSandbox::enableProfiler()
     * @see LuaSandbox::getProfilerFunctionReport()
     */
    public function disableProfiler() {}

    /**
     * Enable the profiler.
     *
     * 
The profiler periodically samples the Lua environment
     * to record the running function. Testing indicates that
     * at least on Linux, setting a period less than 1ms will
     * lead to a high overrun count but no performance problems.
     *
     * @link https://www.php.net/manual/en/luasandbox.enableprofiler.php
     * @param float $period [optional] 
Sampling period in seconds.
     * @return bool 
Returns a boolean indicating whether the profiler is enabled.
     * @since luasandbox >= 1.1.0
     * @see LuaSandbox::disableProfiler()
     * @see LuaSandbox::getProfilerFunctionReport()
     */
    public function enableProfiler($period = 0.02) {}

    /**
     * Fetch the current CPU time usage of the Lua environment.
     *
     * 
This includes time spent in PHP callbacks.
     *
     * 
Note: On Windows, this function always returns zero.
     * On operating systems that do not support CLOCK_THREAD_CPUTIME_ID,
     * such as FreeBSD and Mac OS X, this function will return the
     * elapsed wall-clock time, not CPU time.
     *
     * @link https://www.php.net/manual/en/luasandbox.getcpuusage.php
     * @return float 
Returns the current CPU time usage in seconds.
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::getMemoryUsage()
     * @see LuaSandbox::getPeakMemoryUsage()
     * @see LuaSandbox::setCPULimit()
     */
    public function getCPUUsage() {}

    /**
     * Fetch the current memory usage of the Lua environment.
     *
     * @link https://www.php.net/manual/en/luasandbox.getmemoryusage.php
     * @return int
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::getMemoryUsage()
     * @see LuaSandbox::getCPUUsage()
     * @see LuaSandbox::setMemoryLimit()
     */
    public function getMemoryUsage() {}

    /**
     * Fetch the peak memory usage of the Lua environment.
     *
     * @link https://www.php.net/manual/en/luasandbox.getpeakmemoryusage.php
     * @return int 
Returns the current memory usage in bytes.
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::getMemoryUsage()
     * @see LuaSandbox::getCPUUsage()
     * @see LuaSandbox::setMemoryLimit()
     */
    public function getPeakMemoryUsage() {}

    /**
     * Fetch profiler data.
     *
     * 
For a profiling instance previously started by LuaSandbox::enableProfiler(),
     * get a report of the cost of each function.
     *
     * 
The measurement unit used for the cost is determined by the $units parameter:
     * 
LuaSandbox::SAMPLES Measure in number of samples.
     * 
LuaSandbox::SECONDS Measure in seconds of CPU time.
     * 
LuaSandbox::PERCENT Measure percentage of CPU time.
     *
     * 
Note: On Windows, this function always returns an empty array.
     * On operating systems that do not support CLOCK_THREAD_CPUTIME_ID,
     * such as FreeBSD and Mac OS X, this function will report the
     * elapsed wall-clock time, not CPU time.
     *
     * @link https://www.php.net/manual/en/luasandbox.getprofilerfunctionreport.php
     * @param int $units Measurement unit constant.
     * @return array 
Returns profiler measurements, sorted in descending order, as an associative array.
     * Keys are the Lua function names (with source file and line defined in angle brackets), values are the
     * measurements as integer or float.
     * @since luasandbox >= 1.1.0
     * @see LuaSandbox::SAMPLES
     * @see LuaSandbox::SECONDS
     * @see LuaSandbox::PERCENT
     */
    public function getProfilerFunctionReport($units = LuaSandbox::SECONDS) {}

    /**
     * Return the versions of LuaSandbox and Lua.
     *
     * @link https://www.php.net/manual/en/luasandbox.getversioninfo.php
     * @return array 
Returns an array with two keys:
     * 
LuaSandbox (string), the version of the LuaSandbox extension.
     * 
Lua (string), the library name and version as defined by the LUA_RELEASE macro, for example, "Lua 5.1.5".
     * @since luasandbox >= 1.6.0
     */
    public static function getVersionInfo() {}

    /**
     * Load a precompiled binary chunk into the Lua environment.
     *
     * 
Loads data generated by LuaSandboxFunction::dump().
     *
     * @link https://www.php.net/manual/en/luasandbox.loadbinary.php
     * @param string $code 
Data from LuaSandboxFunction::dump().
     * @param string $chunkName [optional] 
Name for the loaded function.
     * @return LuaSandboxFunction
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::loadString()
     */
    public function loadBinary($code, $chunkName = '') {}

    /**
     * Load Lua code into the Lua environment.
     *
     * 
This is the equivalent of standard Lua's loadstring() function.
     *
     * @link https://www.php.net/manual/en/luasandbox.loadString.php
     * @param string $code 
Lua code.
     * @param string $chunkName [optional] 
Name for the loaded chunk, for use in error traces.
     * @return LuaSandboxFunction 
Returns a LuaSandboxFunction which, when executed,
     * will execute the passed $code.
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::registerLibrary()
     * @see LuaSandbox::wrapPhpFunction()
     */
    public function loadString($code, $chunkName = '') {}

    /**
     * Pause the CPU usage timer.
     *
     * 
This only has effect when called from within a callback from Lua.
     * When execution returns to Lua, the timer will be automatically unpaused.
     * If a new call into Lua is made, the timer will be unpaused
     * for the duration of that call.
     *
     * 
If a PHP callback calls into Lua again with timer not paused,
     * and then that Lua function calls into PHP again,
     * the second PHP call will not be able to pause the timer.
     * The logic is that even though the second PHP call would
     * avoid counting the CPU usage against the limit,
     * the first call still counts it.
     *
     * @link https://www.php.net/manual/en/luasandbox.pauseusagetimer.php
     * @return bool 
Returns a boolean indicating whether the timer is now paused.
     * @since luasandbox >= 1.4.0
     * @see LuaSandbox::setCPULimit()
     * @see LuaSandbox::unpauseUsageTimer()
     */
    public function pauseUsageTimer() {}

    /**
     * Register a set of PHP functions as a Lua library.
     *
     * 
Registers a set of PHP functions as a Lua library,
     * so that Lua can call the relevant PHP code.
     *
     * 
For more information about calling Lua functions and the return values,
     * see LuaSandboxFunction::call().
     *
     * @link https://www.php.net/manual/en/luasandbox.registerlibrary.php
     * @param string $libname 
The name of the library.
     * In the Lua state, the global variable of this name will be set to the table of functions.
     * If the table already exists, the new functions will be added to it.
     * @param array $functions 
Returns an array, where each key is a function name,
     * and each value is a corresponding PHP callable.
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::loadString()
     * @see LuaSandbox::wrapPhpFunction()
     */
    public function registerLibrary($libname, $functions) {}

    /**
     * Set the CPU time limit for the Lua environment.
     *
     * 
If the total user and system time used by the environment after the call
     * to this method exceeds this limit, a LuaSandboxTimeoutError exception is thrown.
     *
     * 
Time used in PHP callbacks is included in the limit.
     *
     * 
Setting the time limit from a callback while Lua is running causes the timer to be reset,
     * or started if it was not already running.
     *
     * 
Note: On Windows, the CPU limit will be ignored. On operating systems
     * that do not support CLOCK_THREAD_CPUTIME_ID, such as FreeBSD and
     * Mac OS X, wall-clock time rather than CPU time will be limited.
     *
     * @link https://www.php.net/manual/en/luasandbox.setcpulimit.php
     * @param bool|float $limit 
Limit as a float in seconds, or false for no limit.
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::getCPUUsage()
     * @see LuaSandbox::setMemoryLimit()
     */
    public function setCPULimit($limit) {}

    /**
     * Set the memory limit for the Lua environment.
     *
     * @link https://www.php.net/manual/en/luasandbox.setmemorylimit.php
     * @param int $limit 
Memory limit in bytes.
     * @throws LuaSandboxMemoryError 
Exception is thrown if this limit is exceeded.
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::getMemoryUsage()
     * @see LuaSandbox::getPeakMemoryUsage()
     * @see LuaSandbox::setCPULimit()
     */
    public function setMemoryLimit($limit) {}

    /**
     * Unpause the timer paused by LuaSandbox::pauseUsageTimer().
     *
     * @link https://www.php.net/manual/en/luasandbox.unpauseusagetimer.php
     * @since luasandbox >= 1.0.0
     * @see LuaSandbox::setCPULimit()
     * @see LuaSandbox::unpauseUsageTimer()
     */
    public function unpauseUsageTimer() {}

    /**
     * Wrap a PHP callable in a LuaSandboxFunction.
     *
     * 
Wraps a PHP callable in a LuaSandboxFunction,
     * so it can be passed into Lua as an anonymous function.
     *
     * 
The function must return either an array of values (which may be empty),
     * or NULL which is equivalent to returning the empty array.
     *
     * 
Exceptions will be raised as errors in Lua, however only LuaSandboxRuntimeError
     * exceptions may be caught inside Lua with pcall() or xpcall().

     *
     * 
For more information about calling Lua functions and the return values,
     * see LuaSandboxFunction::call().
     *
     * @link https://www.php.net/manual/en/luasandbox.wrapPhpFunction.php
     * @param callable $function 
Callable to wrap.
     * @return LuaSandboxFunction
     * @since luasandbox >= 1.2.0
     * @see LuaSandbox::loadString()
     * @see LuaSandbox::registerLibrary()
     */
    public function wrapPhpFunction($function) {}
}

/**
 * Represents a Lua function, allowing it to be called from PHP.
 *
 * 
A LuaSandboxFunction may be obtained as a return value from Lua,
 * as a parameter passed to a callback from Lua,
 * or by using LuaSandbox::wrapPhpFunction(), LuaSandbox::loadString(),
 * or LuaSandbox::loadBinary().
 *
 * @since luasandbox >= 1.0.0
 */
class LuaSandboxFunction
{
    /**
     * Call a Lua function.
     *
     * 
Errors considered to be the fault of the PHP code will result in the
     * function returning false and E_WARNING being raised, for example,
     * a resource type being used as an argument. Lua errors will result
     * in a LuaSandboxRuntimeError exception being thrown.
     *
     * 
PHP and Lua types are converted as follows:
     * 

     * 
PHP NULL is Lua nil, and vice versa.
     * 
PHP integers and floats are converted to Lua numbers. Infinity and NAN are supported.
     * 
Lua numbers without a fractional part between approximately -2**53 and 2**53 are
     * converted to PHP integers, with others being converted to PHP floats.
     * 
PHP booleans are Lua booleans, and vice versa.
     * 
PHP strings are Lua strings, and vice versa.
     * 
Lua functions are PHP LuaSandboxFunction objects, and vice versa.
     * General PHP callables are not supported.
     * 
PHP arrays are converted to Lua tables, and vice versa.
     * 

     *   
Note that Lua typically indexes arrays from 1, while PHP indexes arrays from 0.
     *   No adjustment is made for these differing conventions.
     *   
Self-referential arrays are not supported in either direction.
     *   
PHP references are dereferenced.
     *   
Lua __pairs and __ipairs are processed. __index is ignored.
     *   
When converting from PHP to Lua, integer keys between -2**53 and 2**53 are represented as Lua numbers.
     *   All other keys are represented as Lua strings.
     *   
When converting from Lua to PHP, keys other than strings and numbers will result in an error,
     *   as will collisions when converting numbers to strings or vice versa
     *   (since PHP considers things like $a[0] and $a["0"] as being equivalent).
     * 
     * 
All other types are unsupported and will raise an error/exception,
     * including general PHP objects and Lua userdata and thread types.
     * 
     *
     * 
Lua functions inherently return a list of results. So on success,
     * this method returns an array containing all of the values returned by Lua,
     * with integer keys starting from zero.
     * Lua may return no results, in which case an empty array is returned.
     *
     * @link https://www.php.net/manual/en/luasandboxfunction.call.php
     * @param string[] $arguments 
Arguments passed to the function.
     * @return array|bool 
Returns an array of values returned by the function,
     * which may be empty, or false on error.
     * @since luasandbox >= 1.0.0
     */
    public function call($arguments) {}

    /**
     * Dump the function as a binary blob.
     *
     * @link https://www.php.net/manual/en/luasandboxfunction.dump.php
     * @return string 
Returns a string that may be passed to LuaSandbox::loadBinary().
     * @since luasandbox >= 1.0.0
     */
    public function dump() {}
}

/**
 * Base class for LuaSandbox exceptions.
 *
 * @since luasandbox >= 1.0.0
 */
class LuaSandboxError extends Exception
{
    public const RUN = 2;
    public const SYNTAX = 3;
    public const MEM = 4;
    public const ERR = 5;
}

/**
 * Catchable LuaSandbox runtime exceptions.
 *
 * 
These may be caught inside Lua using pcall() or xpcall().
 *
 * @since luasandbox >= 1.0.0
 */
class LuaSandboxRuntimeError extends LuaSandboxError {}

/**
 * Uncatchable LuaSandbox exceptions.
 *
 * 
These may not be caught inside Lua using pcall() or xpcall().
 *
 * @since luasandbox >= 1.0.0
 */
class LuaSandboxFatalError extends LuaSandboxError {}

/**
 * Exception thrown when Lua encounters an error inside an error handler.
 *
 * @since luasandbox >= 1.0.0
 */
class LuaSandboxErrorError extends LuaSandboxFatalError {}

/**
 * Exception thrown when Lua cannot allocate memory.
 *
 * @since luasandbox >= 1.0.0
 * @see LuaSandbox::setMemoryLimit()
 */
class LuaSandboxMemoryError extends LuaSandboxFatalError {}

/**
 * Exception thrown when Lua code cannot be parsed.
 *
 * @since luasandbox >= 1.0.0
 */
class LuaSandboxSyntaxError extends LuaSandboxFatalError {}

/**
 * Exception thrown when the configured CPU time limit is exceeded.
 *
 * @since luasandbox >= 1.0.0
 * @see LuaSandbox::setCPULimit()
 */
class LuaSandboxTimeoutError extends LuaSandboxFatalError {}

     * Returns the value of the specified configuration option for the tidy document
     * @link https://php.net/manual/en/tidy.getopt.php
     * @param string $option 

     * You will find a list with each configuration option and their types
     * at: http://tidy.sourceforge.net/docs/quickref.html.
     * 
     * @return string|int|bool the value of the specified option.
     * The return type depends on the type of the specified one.
     */
    #[TentativeType]
    public function getOpt(#[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $option): string|int|bool {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Execute configured cleanup and repair operations on parsed markup
     * @link https://php.net/manual/en/tidy.cleanrepair.php
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function cleanRepair(): bool {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Parse markup in file or URI
     * @link https://php.net/manual/en/tidy.parsefile.php
     * @param string $filename 

     * If the filename parameter is given, this function
     * will also read that file and initialize the object with the file,
     * acting like tidy_parse_file.
     * 
     * @param mixed $config [optional] 

     * The config config can be passed either as an
     * array or as a string. If a string is passed, it is interpreted as the
     * name of the configuration file, otherwise, it is interpreted as the
     * options themselves.
     * 
     * 

     * For an explanation about each option, see
     * http://tidy.sourceforge.net/docs/quickref.html.
     * 
     * @param string|null $encoding [optional] 

     * The encoding parameter sets the encoding for
     * input/output documents. The possible values for encoding are:
     * ascii, latin0, latin1,
     * raw, utf8, iso2022,
     * mac, win1252, ibm858,
     * utf16, utf16le, utf16be,
     * big5, and shiftjis.
     * 
     * @param bool $useIncludePath [optional] 

     * Search for the file in the include_path.
     * 
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function parseFile(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $filename,
        #[LanguageLevelTypeAware(['8.0' => 'array|string|null'], default: '')] $config = null,
        #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: '')] $encoding = null,
        #[LanguageLevelTypeAware(['8.0' => 'bool'], default: '')] $useIncludePath = false
    ): bool {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Parse a document stored in a string
     * @link https://php.net/manual/en/tidy.parsestring.php
     * @param string $string 

     * The data to be parsed.
     * 
     * @param mixed $config [optional] 

     * The config config can be passed either as an
     * array or as a string. If a string is passed, it is interpreted as the
     * name of the configuration file, otherwise, it is interpreted as the
     * options themselves.
     * 
     * 

     * For an explanation about each option, visit http://tidy.sourceforge.net/docs/quickref.html.
     * 
     * @param string|null $encoding [optional] 

     * The encoding parameter sets the encoding for
     * input/output documents. The possible values for encoding are:
     * ascii, latin0, latin1,
     * raw, utf8, iso2022,
     * mac, win1252, ibm858,
     * utf16, utf16le, utf16be,
     * big5, and shiftjis.
     * 
     * @return bool a new tidy instance.
     */
    #[TentativeType]
    public function parseString(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $string,
        #[LanguageLevelTypeAware(['8.0' => 'array|string|null'], default: '')] $config = null,
        #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: '')] $encoding = null
    ): bool {}

    /**
     * (PHP 5, PECL tidy >= 0.7.0)

     * Repair a string using an optionally provided configuration file
     * @link https://php.net/manual/en/tidy.repairstring.php
     * @param string $string 

     * The data to be repaired.
     * 
     * @param array|string|null $config [optional] 

     * The config config can be passed either as an
     * array or as a string. If a string is passed, it is interpreted as the
     * name of the configuration file, otherwise, it is interpreted as the
     * options themselves.
     * 
     * 

     * Check http://tidy.sourceforge.net/docs/quickref.html for
     * an explanation about each option.
     * 
     * @param string|null $encoding [optional] 

     * The encoding parameter sets the encoding for
     * input/output documents. The possible values for encoding are:
     * ascii, latin0, latin1,
     * raw, utf8, iso2022,
     * mac, win1252, ibm858,
     * utf16, utf16le, utf16be,
     * big5, and shiftjis.
     * 
     * @return string|false the repaired string.
     */
    #[TentativeType]
    public static function repairString(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $string,
        #[LanguageLevelTypeAware(['8.0' => 'array|string|null'], default: '')] $config = null,
        #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: '')] $encoding = null
    ): string|false {}

    /**
     * (PHP 5, PECL tidy >= 0.7.0)

     * Repair a file and return it as a string
     * @link https://php.net/manual/en/tidy.repairfile.php
     * @param string $filename 

     * The file to be repaired.
     * 
     * @param array|string|null $config [optional] 

     * The config config can be passed either as an
     * array or as a string. If a string is passed, it is interpreted as the
     * name of the configuration file, otherwise, it is interpreted as the
     * options themselves.
     * 
     * 

     * Check http://tidy.sourceforge.net/docs/quickref.html for an
     * explanation about each option.
     * 
     * @param string|null $encoding [optional] 

     * The encoding parameter sets the encoding for
     * input/output documents. The possible values for encoding are:
     * ascii, latin0, latin1,
     * raw, utf8, iso2022,
     * mac, win1252, ibm858,
     * utf16, utf16le, utf16be,
     * big5, and shiftjis.
     * 
     * @param bool $useIncludePath [optional] 

     * Search for the file in the include_path.
     * 
     * @return string|false the repaired contents as a string.
     */
    #[TentativeType]
    public static function repairFile(
        #[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $filename,
        #[LanguageLevelTypeAware(['8.0' => 'array|string|null'], default: '')] $config = null,
        #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: '')] $encoding = null,
        #[LanguageLevelTypeAware(['8.0' => 'bool'], default: '')] $useIncludePath = false
    ): string|false {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Run configured diagnostics on parsed and repaired markup
     * @link https://php.net/manual/en/tidy.diagnose.php
     * @return bool TRUE on success or FALSE on failure.
     */
    #[TentativeType]
    public function diagnose(): bool {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Get release date (version) for Tidy library
     * @link https://php.net/manual/en/tidy.getrelease.php
     * @return string a string with the release date of the Tidy library.
     */
    #[TentativeType]
    public function getRelease(): string {}

    /**
     * (PHP 5, PECL tidy >= 0.7.0)

     * Get current Tidy configuration
     * @link https://php.net/manual/en/tidy.getconfig.php
     * @return array an array of configuration options.
     * 

     * 

     * For an explanation about each option, visit http://tidy.sourceforge.net/docs/quickref.html.
     */
    #[TentativeType]
    public function getConfig(): array {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Get status of specified document
     * @link https://php.net/manual/en/tidy.getstatus.php
     * @return int 0 if no error/warning was raised, 1 for warnings or accessibility
     * errors, or 2 for errors.
     */
    #[TentativeType]
    public function getStatus(): int {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Get the Detected HTML version for the specified document
     * @link https://php.net/manual/en/tidy.gethtmlver.php
     * @return int the detected HTML version.
     * 
     * 

     * This function is not yet implemented in the Tidylib itself, so it always
     * return 0.
     */
    #[TentativeType]
    public function getHtmlVer(): int {}

    /**
     * Returns the documentation for the given option name
     * @link https://php.net/manual/en/tidy.getoptdoc.php
     * @param string $option 

     * The option name
     * 
     * @return string|false a string if the option exists and has documentation available, or
     * FALSE otherwise.
     */
    #[TentativeType]
    public function getOptDoc(#[LanguageLevelTypeAware(['8.0' => 'string'], default: '')] $option): string|false {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Indicates if the document is a XHTML document
     * @link https://php.net/manual/en/tidy.isxhtml.php
     * @return bool This function returns TRUE if the specified tidy
     * object is a XHTML document, or FALSE otherwise.
     * 

     * 

     * This function is not yet implemented in the Tidylib itself, so it always
     * return FALSE.
     */
    #[TentativeType]
    public function isXhtml(): bool {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Indicates if the document is a generic (non HTML/XHTML) XML document
     * @link https://php.net/manual/en/tidy.isxml.php
     * @return bool This function returns TRUE if the specified tidy
     * object is a generic XML document (non HTML/XHTML),
     * or FALSE otherwise.
     * 
     * 

     * This function is not yet implemented in the Tidylib itself, so it always
     * return FALSE.
     */
    #[TentativeType]
    public function isXml(): bool {}

    /**
     * (PHP 5, PECL tidy 0.5.2-1.0.0)

     * Returns a tidyNode object representing the root of the tidy parse tree
     * @link https://php.net/manual/en/tidy.root.php
     * @return tidyNode|null the tidyNode object.
     */
    #[TentativeType]
    public function root(): ?tidyNode {}

    /**
     * (PHP 5, PECL tidy 0.5.2-1.0.0)

     * Returns a tidyNode object starting from the <head> tag of the tidy parse tree
     * @link https://php.net/manual/en/tidy.head.php
     * @return tidyNode|null the tidyNode object.
     */
    #[TentativeType]
    public function head(): ?tidyNode {}

    /**
     * (PHP 5, PECL tidy 0.5.2-1.0.0)

     * Returns a tidyNode object starting from the <html> tag of the tidy parse tree
     * @link https://php.net/manual/en/tidy.html.php
     * @return tidyNode|null the tidyNode object.
     */
    #[TentativeType]
    public function html(): ?tidyNode {}

    /**
     * (PHP 5, PECL tidy 0.5.2-1.0)

     * Returns a tidyNode object starting from the <body> tag of the tidy parse tree
     * @link https://php.net/manual/en/tidy.body.php
     * @return tidyNode|null a tidyNode object starting from the
     * <body> tag of the tidy parse tree.
     */
    #[TentativeType]
    public function body(): ?tidyNode {}

    /**
     * (PHP 5, PECL tidy >= 0.5.2)

     * Constructs a new tidy object
     * @link https://php.net/manual/en/tidy.construct.php
     * @param string $filename [optional] 

     * If the filename parameter is given, this function
     * will also read that file and initialize the object with the file,
     * acting like tidy_parse_file.
     * 
     * @param mixed $config [optional] 

     * The config config can be passed either as an
     * array or as a string. If a string is passed, it is interpreted as the
     * name of the configuration file, otherwise, it is interpreted as the
     * options themselves.
     * 
     * 

     * For an explanation about each option, visit http://tidy.sourceforge.net/docs/quickref.html.
     * 
     * @param string|null $encoding [optional] 

     * The encoding parameter sets the encoding for
     * input/output documents. The possible values for encoding are:
     * ascii, latin0, latin1,
     * raw, utf8, iso2022,
     * mac, win1252, ibm858,
     * utf16, utf16le, utf16be,
     * big5, and shiftjis.
     * 
     * @param bool $useIncludePath [optional] 

     * Search for the file in the include_path.
     * 
     */
    public function __construct(
        #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: '')] $filename = null,
        #[LanguageLevelTypeAware(['8.0' => 'array|string|null'], default: '')] $config = null,
        #[LanguageLevelTypeAware(['8.0' => 'string|null'], default: '')] $encoding = null,
        #[LanguageLevelTypeAware(['8.0' => 'bool'], default: '')] $useIncludePath = null
    ) {}
}

/**
 * An HTML node in an HTML file, as detected by tidy.
 * @link https://php.net/manual/en/class.tidynode.php
 */
final class tidyNode
{
    /**
     * 
The HTML representation of the node, including the surrounding tags.
     * @var string
     */
    public readonly string $value;

    /**
     * 
The name of the HTML node
     * @var string
     */
    public readonly string $name;

    /**
     * 
The type of the tag (one of the constants above, e.g. TIDY_NODETYPE_PHP)
     * @var int
     */
    public readonly int $type;

    /**
     * 
The line number at which the tags is located in the file
     * @var int
     */
    public readonly int $line;

    /**
     * 
The column number at which the tags is located in the file
     * @var int
     */
    public readonly int $column;

    /**
     * 
Indicates if the node is a proprietary tag
     * @var bool
     */
    public readonly bool $proprietary;

    /**
     * 
The ID of the tag (one of the constants above, e.g. TIDY_TAG_FRAME)
     * @var int|null
     */
    public readonly ?int $id;

    /**
     * 

     * An array of string, representing
     * the attributes names (as keys) of the current node.
     * 
     * @var array|null
     */
    public readonly ?array $attribute;

    /**
     * 

     * An array of tidyNode, representing
     * the children of the current node.
     * 
     * @var array|null
     */
    public readonly ?array $child;

    /**
     * Checks if a node has children
     * @link https://php.net/manual/en/tidynode.haschildren.php
     * @return bool TRUE if the node has children, FALSE otherwise.
     * @since 5.0.1
     */
    public function hasChildren():bool {}

    /**
     * Checks if a node has siblings
     * @link https://php.net/manual/en/tidynode.hassiblings.php
     * @return bool TRUE if the node has siblings, FALSE otherwise.
     * @since 5.0.1
     */
    public function hasSiblings(): bool {}

    /**
     * Checks if a node represents a comment
     * @link https://php.net/manual/en/tidynode.iscomment.php
     * @return bool TRUE if the node is a comment, FALSE otherwise.
     * @since 5.0.1
     */
    public function isComment():bool {}

    /**
     * Checks if a node is part of a HTML document
     * @link https://php.net/manual/en/tidynode.ishtml.php
     * @return bool TRUE if the node is part of a HTML document, FALSE otherwise.
     * @since 5.0.1
     */
    public function isHtml(): bool {}

    /**
     * Checks if a node represents text (no markup)
     * @link https://php.net/manual/en/tidynode.istext.php
     * @return bool TRUE if the node represent a text, FALSE otherwise.
     * @since 5.0.1
     */
    public function isText(): bool {}

    /**
     * Checks if this node is JSTE
     * @link https://php.net/manual/en/tidynode.isjste.php
     * @return bool TRUE if the node is JSTE, FALSE otherwise.
     * @since 5.0.1
     */
    public function isJste(): bool {}

    /**
     * Checks if this node is ASP
     * @link https://php.net/manual/en/tidynode.isasp.php
     * @return bool TRUE if the node is ASP, FALSE otherwise.
     * @since 5.0.1
     */
    public function isAsp(): bool {}

    /**
     * Checks if a node is PHP
     * @link https://php.net/manual/en/tidynode.isphp.php
     * @return bool TRUE if the current node is PHP code, FALSE otherwise.
     * @since 5.0.1
     */
    public function isPhp(): bool {}

    /**
     * Returns the parent node of the current node
     * @link https://php.net/manual/en/tidynode.getparent.php
     * @return tidyNode|null a tidyNode if the node has a parent, or NULL
     * otherwise.
     * @since 5.2.2
     */
    public function getParent(): ?tidyNode {}

    private function __construct() {}
}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Returns the value of the specified configuration option for the tidy document
 * @link https://php.net/manual/en/tidy.getopt.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @param string $option 

 * You will find a list with each configuration option and their types
 * at: http://tidy.sourceforge.net/docs/quickref.html.
 * 
 * @return string|int|bool the value of the specified option.
 * The return type depends on the type of the specified one.
 */
function tidy_getopt(#[PhpStormStubsElementAvailable(from: '8.0')]  tidy $tidy, string $option):string|int|bool {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Parse a document stored in a string
 * @link https://php.net/manual/en/tidy.parsestring.php
 * @param string $string 

 * The data to be parsed.
 * 
 * @param mixed $config [optional] 

 * The config config can be passed either as an
 * array or as a string. If a string is passed, it is interpreted as the
 * name of the configuration file, otherwise, it is interpreted as the
 * options themselves.
 * 
 * 

 * For an explanation about each option, visit http://tidy.sourceforge.net/docs/quickref.html.
 * 
 * @param string|null $encoding [optional] 

 * The encoding parameter sets the encoding for
 * input/output documents. The possible values for encoding are:
 * ascii, latin0, latin1,
 * raw, utf8, iso2022,
 * mac, win1252, ibm858,
 * utf16, utf16le, utf16be,
 * big5, and shiftjis.
 * 
 * @return tidy|false a new tidy instance.
 */
function tidy_parse_string(string $string, array|string|null $config = null, null|string $encoding = null):tidy|false {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Parse markup in file or URI
 * @link https://php.net/manual/en/tidy.parsefile.php
 * @param string $filename 

 * If the filename parameter is given, this function
 * will also read that file and initialize the object with the file,
 * acting like tidy_parse_file.
 * 
 * @param mixed $config [optional] 

 * The config config can be passed either as an
 * array or as a string. If a string is passed, it is interpreted as the
 * name of the configuration file, otherwise, it is interpreted as the
 * options themselves.
 * 
 * 

 * For an explanation about each option, see
 * http://tidy.sourceforge.net/docs/quickref.html.
 * 
 * @param string|null $encoding [optional] 

 * The encoding parameter sets the encoding for
 * input/output documents. The possible values for encoding are:
 * ascii, latin0, latin1,
 * raw, utf8, iso2022,
 * mac, win1252, ibm858,
 * utf16, utf16le, utf16be,
 * big5, and shiftjis.
 * 
 * @param bool $useIncludePath [optional] 

 * Search for the file in the include_path.
 * 
 * @return tidy|false a new tidy instance.
 */
function tidy_parse_file(string $filename, array|string|null $config = null, null|string $encoding = null, bool $useIncludePath = false):tidy|false {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Return a string representing the parsed tidy markup
 * @link https://php.net/manual/en/function.tidy-get-output.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return string the parsed tidy markup.
 */
function tidy_get_output(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):string {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Return warnings and errors which occurred parsing the specified document
 * @link https://php.net/manual/en/tidy.props.errorbuffer.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return string|false the error buffer as a string.
 */
function tidy_get_error_buffer(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):string|false {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Execute configured cleanup and repair operations on parsed markup
 * @link https://php.net/manual/en/tidy.cleanrepair.php
 * @param tidy $tidy The Tidy object.
 * @return bool TRUE on success or FALSE on failure.
 */
function tidy_clean_repair(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):bool {}

/**
 * (PHP 5, PECL tidy >= 0.7.0)

 * Repair a string using an optionally provided configuration file
 * @link https://php.net/manual/en/tidy.repairstring.php
 * @param string $string 

 * The data to be repaired.
 * 
 * @param mixed $config [optional] 

 * The config config can be passed either as an
 * array or as a string. If a string is passed, it is interpreted as the
 * name of the configuration file, otherwise, it is interpreted as the
 * options themselves.
 * 
 * 

 * Check http://tidy.sourceforge.net/docs/quickref.html for
 * an explanation about each option.
 * 
 * @param string|null $encoding [optional] 

 * The encoding parameter sets the encoding for
 * input/output documents. The possible values for encoding are:
 * ascii, latin0, latin1,
 * raw, utf8, iso2022,
 * mac, win1252, ibm858,
 * utf16, utf16le, utf16be,
 * big5, and shiftjis.
 * 
 * @return string|false the repaired string.
 */
function tidy_repair_string(string $string, array|string|null $config = null, null|string $encoding = null):string|false {}

/**
 * (PHP 5, PECL tidy >= 0.7.0)

 * Repair a file and return it as a string
 * @link https://php.net/manual/en/tidy.repairfile.php
 * @param string $filename 

 * The file to be repaired.
 * 
 * @param mixed $config [optional] 

 * The config config can be passed either as an
 * array or as a string. If a string is passed, it is interpreted as the
 * name of the configuration file, otherwise, it is interpreted as the
 * options themselves.
 * 
 * 

 * Check http://tidy.sourceforge.net/docs/quickref.html for an
 * explanation about each option.
 * 
 * @param string|null $encoding [optional] 

 * The encoding parameter sets the encoding for
 * input/output documents. The possible values for encoding are:
 * ascii, latin0, latin1,
 * raw, utf8, iso2022,
 * mac, win1252, ibm858,
 * utf16, utf16le, utf16be,
 * big5, and shiftjis.
 * 
 * @param bool $useIncludePath [optional] 

 * Search for the file in the include_path.
 * 
 * @return string|false the repaired contents as a string.
 */
function tidy_repair_file(string $filename, array|string|null $config = null, null|string $encoding = null, bool $useIncludePath = false):string|false {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Run configured diagnostics on parsed and repaired markup
 * @link https://php.net/manual/en/tidy.diagnose.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return bool TRUE on success or FALSE on failure.
 */
function tidy_diagnose(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):bool {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Get release date (version) for Tidy library
 * @link https://php.net/manual/en/tidy.getrelease.php
 * @return string a string with the release date of the Tidy library.
 */
function tidy_get_release():string {}

/**
 * (PHP 5, PECL tidy >= 0.7.0)

 * Get current Tidy configuration
 * @link https://php.net/manual/en/tidy.getconfig.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return array an array of configuration options.
 * 

 * For an explanation about each option, visit http://tidy.sourceforge.net/docs/quickref.html.
 * 
 */
function tidy_get_config(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):array {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Get status of specified document
 * @link https://php.net/manual/en/tidy.getstatus.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return int 0 if no error/warning was raised, 1 for warnings or accessibility
 * errors, or 2 for errors.
 */
function tidy_get_status(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):int {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Get the Detected HTML version for the specified document
 * @link https://php.net/manual/en/tidy.gethtmlver.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return int the detected HTML version.
 * 

 * This function is not yet implemented in the Tidylib itself, so it always
 * return 0.
 * 
 */
function tidy_get_html_ver(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):int {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Indicates if the document is a XHTML document
 * @link https://php.net/manual/en/tidy.isxhtml.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return bool This function returns TRUE if the specified tidy
 * object is a XHTML document, or FALSE otherwise.
 * 

 * 

 * This function is not yet implemented in the Tidylib itself, so it always
 * return FALSE.
 */
function tidy_is_xhtml(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):bool {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Indicates if the document is a generic (non HTML/XHTML) XML document
 * @link https://php.net/manual/en/tidy.isxml.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return bool This function returns TRUE if the specified tidy
 * object is a generic XML document (non HTML/XHTML),
 * or FALSE otherwise.
 * 

 * 

 * This function is not yet implemented in the Tidylib itself, so it always
 * return FALSE.
 */
function tidy_is_xml(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):bool {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Returns the Number of Tidy errors encountered for specified document
 * @link https://php.net/manual/en/function.tidy-error-count.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return int the number of errors.
 */
function tidy_error_count(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy): int {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Returns the Number of Tidy warnings encountered for specified document
 * @link https://php.net/manual/en/function.tidy-warning-count.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return int the number of warnings.
 */
function tidy_warning_count(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):int {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Returns the Number of Tidy accessibility warnings encountered for specified document
 * @link https://php.net/manual/en/function.tidy-access-count.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return int the number of warnings.
 */
function tidy_access_count(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy): int {}

/**
 * (PHP 5, PECL tidy >= 0.5.2)

 * Returns the Number of Tidy configuration errors encountered for specified document
 * @link https://php.net/manual/en/function.tidy-config-count.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return int the number of errors.
 */
function tidy_config_count(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):int {}

/**
 * Returns the documentation for the given option name
 * @link https://php.net/manual/en/tidy.getoptdoc.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @param string $option 

 * The option name
 * 
 * @return string|false a string if the option exists and has documentation available, or
 * FALSE otherwise.
 */
function tidy_get_opt_doc(tidy $tidy, string $option):string|false {}

/**
 * (PHP 5, PECL tidy 0.5.2-1.0.0)

 * Returns a tidyNode object representing the root of the tidy parse tree
 * @link https://php.net/manual/en/tidy.root.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return tidyNode|null the tidyNode object.
 */
function tidy_get_root(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):?tidyNode {}

/**
 * (PHP 5, PECL tidy 0.5.2-1.0.0)

 * Returns a tidyNode object starting from the <head> tag of the tidy parse tree
 * @link https://php.net/manual/en/tidy.head.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return tidyNode|null the tidyNode object.
 */
function tidy_get_head(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):?tidyNode {}

/**
 * (PHP 5, PECL tidy 0.5.2-1.0.0)

 * Returns a tidyNode object starting from the <html> tag of the tidy parse tree
 * @link https://php.net/manual/en/tidy.html.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return tidyNode|null the tidyNode object.
 */
function tidy_get_html(#[PhpStormStubsElementAvailable(from: '8.0')] tidy $tidy):?tidyNode {}

/**
 * (PHP 5, PECL tidy 0.5.2-1.0)

 * Returns a tidyNode object starting from the <body> tag of the tidy parse tree
 * @link https://php.net/manual/en/tidy.body.php
 * @param tidy $tidy 

 * The Tidy object.
 * 
 * @return tidyNode|null a tidyNode object starting from the
 * <body> tag of the tidy parse tree.
 */
function tidy_get_body(tidy $tidy): ?tidyNode {}

/**
 * ob_start callback function to repair the buffer
 * @link https://php.net/manual/en/function.ob-tidyhandler.php
 * @param string $input 

 * The buffer.
 * 
 * @param int $mode [optional] 

 * The buffer mode.
 * 
 * @return string the modified buffer.
 */
function ob_tidyhandler($input, $mode = null) {}

/**
 * description
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_TAG_UNKNOWN', 0);
define('TIDY_TAG_A', 1);
define('TIDY_TAG_ABBR', 2);
define('TIDY_TAG_ACRONYM', 3);
define('TIDY_TAG_ADDRESS', 4);
define('TIDY_TAG_ALIGN', 5);
define('TIDY_TAG_APPLET', 6);
define('TIDY_TAG_AREA', 7);
define('TIDY_TAG_B', 8);
define('TIDY_TAG_BASE', 9);
define('TIDY_TAG_BASEFONT', 10);
define('TIDY_TAG_BDO', 11);
define('TIDY_TAG_BGSOUND', 12);
define('TIDY_TAG_BIG', 13);
define('TIDY_TAG_BLINK', 14);
define('TIDY_TAG_BLOCKQUOTE', 15);
define('TIDY_TAG_BODY', 16);
define('TIDY_TAG_BR', 17);
define('TIDY_TAG_BUTTON', 18);
define('TIDY_TAG_CAPTION', 19);
define('TIDY_TAG_CENTER', 20);
define('TIDY_TAG_CITE', 21);
define('TIDY_TAG_CODE', 22);
define('TIDY_TAG_COL', 23);
define('TIDY_TAG_COLGROUP', 24);
define('TIDY_TAG_COMMENT', 25);
define('TIDY_TAG_DD', 26);
define('TIDY_TAG_DEL', 27);
define('TIDY_TAG_DFN', 28);
define('TIDY_TAG_DIR', 29);
define('TIDY_TAG_DIV', 30);
define('TIDY_TAG_DL', 31);
define('TIDY_TAG_DT', 32);
define('TIDY_TAG_EM', 33);
define('TIDY_TAG_EMBED', 34);
define('TIDY_TAG_FIELDSET', 35);
define('TIDY_TAG_FONT', 36);
define('TIDY_TAG_FORM', 37);
define('TIDY_TAG_FRAME', 38);
define('TIDY_TAG_FRAMESET', 39);
define('TIDY_TAG_H1', 40);
define('TIDY_TAG_H2', 41);
define('TIDY_TAG_H3', 42);
define('TIDY_TAG_H4', 43);
define('TIDY_TAG_H5', 44);
define('TIDY_TAG_H6', 45);
define('TIDY_TAG_HEAD', 46);
define('TIDY_TAG_HR', 47);
define('TIDY_TAG_HTML', 48);
define('TIDY_TAG_I', 49);
define('TIDY_TAG_IFRAME', 50);
define('TIDY_TAG_ILAYER', 51);
define('TIDY_TAG_IMG', 52);
define('TIDY_TAG_INPUT', 53);
define('TIDY_TAG_INS', 54);
define('TIDY_TAG_ISINDEX', 55);
define('TIDY_TAG_KBD', 56);
define('TIDY_TAG_KEYGEN', 57);
define('TIDY_TAG_LABEL', 58);
define('TIDY_TAG_LAYER', 59);
define('TIDY_TAG_LEGEND', 60);
define('TIDY_TAG_LI', 61);
define('TIDY_TAG_LINK', 62);
define('TIDY_TAG_LISTING', 63);
define('TIDY_TAG_MAP', 64);
define('TIDY_TAG_MARQUEE', 65);
define('TIDY_TAG_MENU', 66);
define('TIDY_TAG_META', 67);
define('TIDY_TAG_MULTICOL', 68);
define('TIDY_TAG_NOBR', 69);
define('TIDY_TAG_NOEMBED', 70);
define('TIDY_TAG_NOFRAMES', 71);
define('TIDY_TAG_NOLAYER', 72);
define('TIDY_TAG_NOSAVE', 73);
define('TIDY_TAG_NOSCRIPT', 74);
define('TIDY_TAG_OBJECT', 75);
define('TIDY_TAG_OL', 76);
define('TIDY_TAG_OPTGROUP', 77);
define('TIDY_TAG_OPTION', 78);
define('TIDY_TAG_P', 79);
define('TIDY_TAG_PARAM', 80);
define('TIDY_TAG_PLAINTEXT', 81);
define('TIDY_TAG_PRE', 82);
define('TIDY_TAG_Q', 83);
define('TIDY_TAG_RB', 84);
define('TIDY_TAG_RBC', 85);
define('TIDY_TAG_RP', 86);
define('TIDY_TAG_RT', 87);
define('TIDY_TAG_RTC', 88);
define('TIDY_TAG_RUBY', 89);
define('TIDY_TAG_S', 90);
define('TIDY_TAG_SAMP', 91);
define('TIDY_TAG_SCRIPT', 92);
define('TIDY_TAG_SELECT', 93);
define('TIDY_TAG_SERVER', 94);
define('TIDY_TAG_SERVLET', 95);
define('TIDY_TAG_SMALL', 96);
define('TIDY_TAG_SPACER', 97);
define('TIDY_TAG_SPAN', 98);
define('TIDY_TAG_STRIKE', 99);
define('TIDY_TAG_STRONG', 100);
define('TIDY_TAG_STYLE', 101);
define('TIDY_TAG_SUB', 102);
define('TIDY_TAG_SUP', 103);
define('TIDY_TAG_TABLE', 104);
define('TIDY_TAG_TBODY', 105);
define('TIDY_TAG_TD', 106);
define('TIDY_TAG_TEXTAREA', 107);
define('TIDY_TAG_TFOOT', 108);
define('TIDY_TAG_TH', 109);
define('TIDY_TAG_THEAD', 110);
define('TIDY_TAG_TITLE', 111);
define('TIDY_TAG_TR', 112);
define('TIDY_TAG_TT', 113);
define('TIDY_TAG_U', 114);
define('TIDY_TAG_UL', 115);
define('TIDY_TAG_VAR', 116);
define('TIDY_TAG_WBR', 117);
define('TIDY_TAG_XMP', 118);
/**
 * @since 7.4
 */
define('TIDY_TAG_ARTICLE', 123);
/**
 * @since 7.4
 */
define('TIDY_TAG_ASIDE', 124);
/**
 * @since 7.4
 */
define('TIDY_TAG_AUDIO', 125);
/**
 * @since 7.4
 */
define('TIDY_TAG_BDI', 126);
/**
 * @since 7.4
 */
define('TIDY_TAG_CANVAS', 127);
/**
 * @since 7.4
 */
define('TIDY_TAG_COMMAND', 128);
/**
 * @since 7.4
 */
define('TIDY_TAG_DATALIST', 129);
/**
 * @since 7.4
 */
define('TIDY_TAG_DETAILS', 130);
/**
 * @since 7.4
 */
define('TIDY_TAG_DIALOG', 131);
/**
 * @since 7.4
 */
define('TIDY_TAG_FIGCAPTION', 132);
/**
 * @since 7.4
 */
define('TIDY_TAG_FIGURE', 133);
/**
 * @since 7.4
 */
define('TIDY_TAG_FOOTER', 134);
/**
 * @since 7.4
 */
define('TIDY_TAG_HEADER', 135);
/**
 * @since 7.4
 */
define('TIDY_TAG_HGROUP', 136);
/**
 * @since 7.4
 */
define('TIDY_TAG_MAIN', 137);
/**
 * @since 7.4
 */
define('TIDY_TAG_MARK', 138);
/**
 * @since 7.4
 */
define('TIDY_TAG_MENUITEM', 139);
/**
 * @since 7.4
 */
define('TIDY_TAG_METER', 140);
/**
 * @since 7.4
 */
define('TIDY_TAG_NAV', 141);
/**
 * @since 7.4
 */
define('TIDY_TAG_OUTPUT', 142);
/**
 * @since 7.4
 */
define('TIDY_TAG_PROGRESS', 143);
/**
 * @since 7.4
 */
define('TIDY_TAG_SECTION', 144);
/**
 * @since 7.4
 */
define('TIDY_TAG_SOURCE', 145);
/**
 * @since 7.4
 */
define('TIDY_TAG_SUMMARY', 146);
/**
 * @since 7.4
 */
define('TIDY_TAG_TEMPLATE', 147);
/**
 * @since 7.4
 */
define('TIDY_TAG_TIME', 148);
/**
 * @since 7.4
 */
define('TIDY_TAG_TRACK', 149);
/**
 * @since 7.4
 */
define('TIDY_TAG_VIDEO', 150);

/**
 * root node
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_ROOT', 0);

/**
 * doctype
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_DOCTYPE', 1);

/**
 * HTML comment
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_COMMENT', 2);

/**
 * Processing Instruction
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_PROCINS', 3);

/**
 * Text
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_TEXT', 4);

/**
 * start tag
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_START', 5);

/**
 * end tag
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_END', 6);

/**
 * empty tag
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_STARTEND', 7);

/**
 * CDATA
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_CDATA', 8);

/**
 * XML section
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_SECTION', 9);

/**
 * ASP code
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_ASP', 10);

/**
 * JSTE code
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_JSTE', 11);

/**
 * PHP code
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_PHP', 12);

/**
 * XML declaration
 * @link https://php.net/manual/en/tidy.constants.php
 */
define('TIDY_NODETYPE_XMLDECL', 13);

// End of tidy v.2.0
 'amqp/amqp.stub', 'AMQPChannel' => 'amqp/amqp.stub', 'AMQPChannelException' => 'amqp/amqp.stub', 'AMQPConnection' => 'amqp/amqp.stub', 'AMQPConnectionException' => 'amqp/amqp.stub', 'AMQPDecimal' => 'amqp/amqp.stub', 'AMQPEnvelope' => 'amqp/amqp.stub', 'AMQPEnvelopeException' => 'amqp/amqp.stub', 'AMQPException' => 'amqp/amqp.stub', 'AMQPExchange' => 'amqp/amqp.stub', 'AMQPExchangeException' => 'amqp/amqp.stub', 'AMQPExchangeValue' => 'amqp/amqp.stub', 'AMQPQueue' => 'amqp/amqp.stub', 'AMQPQueueException' => 'amqp/amqp.stub', 'AMQPTimestamp' => 'amqp/amqp.stub', 'AMQPValue' => 'amqp/amqp.stub', 'AMQPValueException' => 'amqp/amqp.stub', 'APCIterator' => 'apcu/apcu.stub', 'APCUIterator' => 'apcu/apcu.stub', 'AddressInfo' => 'sockets/sockets.stub', 'Aerospike' => 'aerospike/aerospike.stub', 'Aerospike\\Bytes' => 'aerospike/Bytes.stub', 'AllowDynamicProperties' => 'Core/Core_c.stub', 'AppendIterator' => 'SPL/SPL.stub', 'ArgumentCountError' => 'Core/Core_c.stub', 'ArithmeticError' => 'Core/Core_c.stub', 'ArrayAccess' => 'Core/Core_c.stub', 'ArrayIterator' => 'SPL/SPL.stub', 'ArrayObject' => 'SPL/SPL.stub', 'AssertionError' => 'standard/standard_9.stub', 'Attribute' => 'Core/Core_c.stub', 'BackedEnum' => 'Core/Core_c.stub', 'BadFunctionCallException' => 'SPL/SPL.stub', 'BadMethodCallException' => 'SPL/SPL.stub', 'BlackfireProbe' => 'blackfire/blackfire.stub', 'COM' => 'com_dotnet/com_dotnet.stub', 'CURLFile' => 'curl/curl.stub', 'CURLStringFile' => 'curl/CURLStringFile.stub', 'CachingIterator' => 'SPL/SPL.stub', 'CallbackFilterIterator' => 'SPL/SPL.stub', 'Cassandra' => 'cassandra/cassandra.stub', 'Cassandra\\Aggregate' => 'cassandra/cassandra.stub', 'Cassandra\\BatchStatement' => 'cassandra/cassandra.stub', 'Cassandra\\Bigint' => 'cassandra/cassandra.stub', 'Cassandra\\Blob' => 'cassandra/cassandra.stub', 'Cassandra\\Cluster' => 'cassandra/cassandra.stub', 'Cassandra\\Cluster\\Builder' => 'cassandra/cassandra.stub', 'Cassandra\\Collection' => 'cassandra/cassandra.stub', 'Cassandra\\Column' => 'cassandra/cassandra.stub', 'Cassandra\\Custom' => 'cassandra/cassandra.stub', 'Cassandra\\Date' => 'cassandra/cassandra.stub', 'Cassandra\\Decimal' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultAggregate' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultCluster' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultColumn' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultFunction' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultIndex' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultKeyspace' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultMaterializedView' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultSchema' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultSession' => 'cassandra/cassandra.stub', 'Cassandra\\DefaultTable' => 'cassandra/cassandra.stub', 'Cassandra\\Duration' => 'cassandra/cassandra.stub', 'Cassandra\\Exception' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\AlreadyExistsException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\AuthenticationException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\ConfigurationException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\DivideByZeroException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\DomainException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\ExecutionException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\InvalidArgumentException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\InvalidQueryException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\InvalidSyntaxException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\IsBootstrappingException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\LogicException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\OverloadedException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\ProtocolException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\RangeException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\ReadTimeoutException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\RuntimeException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\ServerException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\TimeoutException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\TruncateException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\UnauthorizedException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\UnavailableException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\UnpreparedException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\ValidationException' => 'cassandra/cassandra.stub', 'Cassandra\\Exception\\WriteTimeoutException' => 'cassandra/cassandra.stub', 'Cassandra\\ExecutionOptions' => 'cassandra/cassandra.stub', 'Cassandra\\Float_' => 'cassandra/cassandra.stub', 'Cassandra\\Function_' => 'cassandra/cassandra.stub', 'Cassandra\\Future' => 'cassandra/cassandra.stub', 'Cassandra\\FutureClose' => 'cassandra/cassandra.stub', 'Cassandra\\FuturePreparedStatement' => 'cassandra/cassandra.stub', 'Cassandra\\FutureRows' => 'cassandra/cassandra.stub', 'Cassandra\\FutureSession' => 'cassandra/cassandra.stub', 'Cassandra\\FutureValue' => 'cassandra/cassandra.stub', 'Cassandra\\Index' => 'cassandra/cassandra.stub', 'Cassandra\\Inet' => 'cassandra/cassandra.stub', 'Cassandra\\Keyspace' => 'cassandra/cassandra.stub', 'Cassandra\\Map' => 'cassandra/cassandra.stub', 'Cassandra\\MaterializedView' => 'cassandra/cassandra.stub', 'Cassandra\\Numeric' => 'cassandra/cassandra.stub', 'Cassandra\\PreparedStatement' => 'cassandra/cassandra.stub', 'Cassandra\\RetryPolicy' => 'cassandra/cassandra.stub', 'Cassandra\\RetryPolicy\\DefaultPolicy' => 'cassandra/cassandra.stub', 'Cassandra\\RetryPolicy\\DowngradingConsistency' => 'cassandra/cassandra.stub', 'Cassandra\\RetryPolicy\\Fallthrough' => 'cassandra/cassandra.stub', 'Cassandra\\RetryPolicy\\Logging' => 'cassandra/cassandra.stub', 'Cassandra\\Rows' => 'cassandra/cassandra.stub', 'Cassandra\\SSLOptions' => 'cassandra/cassandra.stub', 'Cassandra\\SSLOptions\\Builder' => 'cassandra/cassandra.stub', 'Cassandra\\Schema' => 'cassandra/cassandra.stub', 'Cassandra\\Session' => 'cassandra/cassandra.stub', 'Cassandra\\Set' => 'cassandra/cassandra.stub', 'Cassandra\\SimpleStatement' => 'cassandra/cassandra.stub', 'Cassandra\\Smallint' => 'cassandra/cassandra.stub', 'Cassandra\\Statement' => 'cassandra/cassandra.stub', 'Cassandra\\Table' => 'cassandra/cassandra.stub', 'Cassandra\\Time' => 'cassandra/cassandra.stub', 'Cassandra\\Timestamp' => 'cassandra/cassandra.stub', 'Cassandra\\TimestampGenerator' => 'cassandra/cassandra.stub', 'Cassandra\\TimestampGenerator\\Monotonic' => 'cassandra/cassandra.stub', 'Cassandra\\TimestampGenerator\\ServerSide' => 'cassandra/cassandra.stub', 'Cassandra\\Timeuuid' => 'cassandra/cassandra.stub', 'Cassandra\\Tinyint' => 'cassandra/cassandra.stub', 'Cassandra\\Tuple' => 'cassandra/cassandra.stub', 'Cassandra\\Type' => 'cassandra/cassandra.stub', 'Cassandra\\Type\\Collection' => 'cassandra/cassandra.stub', 'Cassandra\\Type\\Custom' => 'cassandra/cassandra.stub', 'Cassandra\\Type\\Map' => 'cassandra/cassandra.stub', 'Cassandra\\Type\\Scalar' => 'cassandra/cassandra.stub', 'Cassandra\\Type\\Set' => 'cassandra/cassandra.stub', 'Cassandra\\Type\\Tuple' => 'cassandra/cassandra.stub', 'Cassandra\\Type\\UserType' => 'cassandra/cassandra.stub', 'Cassandra\\UserTypeValue' => 'cassandra/cassandra.stub', 'Cassandra\\Uuid' => 'cassandra/cassandra.stub', 'Cassandra\\UuidInterface' => 'cassandra/cassandra.stub', 'Cassandra\\Value' => 'cassandra/cassandra.stub', 'Cassandra\\Varint' => 'cassandra/cassandra.stub', 'ClosedGeneratorException' => 'standard/_types.stub', 'Closure' => 'Core/Core_c.stub', 'Collator' => 'intl/intl.stub', 'Collectable' => 'pthreads/pthreads.stub', 'CompileError' => 'Core/Core_c.stub', 'Couchbase\\AnalyticsEncryptionLevel' => 'couchbase/couchbase.stub', 'Couchbase\\AnalyticsException' => 'couchbase/couchbase.stub', 'Couchbase\\AnalyticsIndexManager' => 'couchbase/couchbase.stub', 'Couchbase\\AnalyticsLink' => 'couchbase/couchbase.stub', 'Couchbase\\AnalyticsLinkType' => 'couchbase/couchbase.stub', 'Couchbase\\AnalyticsOptions' => 'couchbase/couchbase.stub', 'Couchbase\\AnalyticsResult' => 'couchbase/couchbase.stub', 'Couchbase\\AppendOptions' => 'couchbase/couchbase.stub', 'Couchbase\\AuthenticationException' => 'couchbase/couchbase.stub', 'Couchbase\\AzureBlobExternalAnalyticsLink' => 'couchbase/couchbase.stub', 'Couchbase\\BadInputException' => 'couchbase/couchbase.stub', 'Couchbase\\BaseException' => 'couchbase/couchbase.stub', 'Couchbase\\BinaryCollection' => 'couchbase/couchbase.stub', 'Couchbase\\BindingsException' => 'couchbase/couchbase.stub', 'Couchbase\\BooleanFieldSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\BooleanSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\Bucket' => 'couchbase/couchbase.stub', 'Couchbase\\BucketManager' => 'couchbase/couchbase.stub', 'Couchbase\\BucketMissingException' => 'couchbase/couchbase.stub', 'Couchbase\\BucketSettings' => 'couchbase/couchbase.stub', 'Couchbase\\CasMismatchException' => 'couchbase/couchbase.stub', 'Couchbase\\Cluster' => 'couchbase/couchbase.stub', 'Couchbase\\ClusterOptions' => 'couchbase/couchbase.stub', 'Couchbase\\Collection' => 'couchbase/couchbase.stub', 'Couchbase\\CollectionManager' => 'couchbase/couchbase.stub', 'Couchbase\\CollectionMissingException' => 'couchbase/couchbase.stub', 'Couchbase\\CollectionSpec' => 'couchbase/couchbase.stub', 'Couchbase\\ConjunctionSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\ConnectAnalyticsLinkOptions' => 'couchbase/couchbase.stub', 'Couchbase\\Coordinate' => 'couchbase/couchbase.stub', 'Couchbase\\CouchbaseRemoteAnalyticsLink' => 'couchbase/couchbase.stub', 'Couchbase\\CounterResult' => 'couchbase/couchbase.stub', 'Couchbase\\CreateAnalyticsDatasetOptions' => 'couchbase/couchbase.stub', 'Couchbase\\CreateAnalyticsDataverseOptions' => 'couchbase/couchbase.stub', 'Couchbase\\CreateAnalyticsIndexOptions' => 'couchbase/couchbase.stub', 'Couchbase\\CreateAnalyticsLinkOptions' => 'couchbase/couchbase.stub', 'Couchbase\\CreateQueryIndexOptions' => 'couchbase/couchbase.stub', 'Couchbase\\CreateQueryPrimaryIndexOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DateRangeFacetResult' => 'couchbase/couchbase.stub', 'Couchbase\\DateRangeSearchFacet' => 'couchbase/couchbase.stub', 'Couchbase\\DateRangeSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\DecrementOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DesignDocument' => 'couchbase/couchbase.stub', 'Couchbase\\DisconnectAnalyticsLinkOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DisjunctionSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\DmlFailureException' => 'couchbase/couchbase.stub', 'Couchbase\\DocIdSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\DocumentNotFoundException' => 'couchbase/couchbase.stub', 'Couchbase\\DropAnalyticsDatasetOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DropAnalyticsDataverseOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DropAnalyticsIndexOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DropAnalyticsLinkOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DropQueryIndexOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DropQueryPrimaryIndexOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DropUserOptions' => 'couchbase/couchbase.stub', 'Couchbase\\DurabilityException' => 'couchbase/couchbase.stub', 'Couchbase\\DurabilityLevel' => 'couchbase/couchbase.stub', 'Couchbase\\EncryptionSettings' => 'couchbase/couchbase.stub', 'Couchbase\\EvictionPolicy' => 'couchbase/couchbase.stub', 'Couchbase\\ExistsOptions' => 'couchbase/couchbase.stub', 'Couchbase\\ExistsResult' => 'couchbase/couchbase.stub', 'Couchbase\\GeoBoundingBoxSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\GeoDistanceSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\GeoPolygonQuery' => 'couchbase/couchbase.stub', 'Couchbase\\GetAllReplicasOptions' => 'couchbase/couchbase.stub', 'Couchbase\\GetAllUsersOptions' => 'couchbase/couchbase.stub', 'Couchbase\\GetAnalyticsLinksOptions' => 'couchbase/couchbase.stub', 'Couchbase\\GetAndLockOptions' => 'couchbase/couchbase.stub', 'Couchbase\\GetAndTouchOptions' => 'couchbase/couchbase.stub', 'Couchbase\\GetAnyReplicaOptions' => 'couchbase/couchbase.stub', 'Couchbase\\GetOptions' => 'couchbase/couchbase.stub', 'Couchbase\\GetReplicaResult' => 'couchbase/couchbase.stub', 'Couchbase\\GetResult' => 'couchbase/couchbase.stub', 'Couchbase\\GetUserOptions' => 'couchbase/couchbase.stub', 'Couchbase\\Group' => 'couchbase/couchbase.stub', 'Couchbase\\HttpException' => 'couchbase/couchbase.stub', 'Couchbase\\IncrementOptions' => 'couchbase/couchbase.stub', 'Couchbase\\IndexFailureException' => 'couchbase/couchbase.stub', 'Couchbase\\IndexNotFoundException' => 'couchbase/couchbase.stub', 'Couchbase\\InsertOptions' => 'couchbase/couchbase.stub', 'Couchbase\\InvalidConfigurationException' => 'couchbase/couchbase.stub', 'Couchbase\\InvalidRangeException' => 'couchbase/couchbase.stub', 'Couchbase\\InvalidStateException' => 'couchbase/couchbase.stub', 'Couchbase\\KeyDeletedException' => 'couchbase/couchbase.stub', 'Couchbase\\KeyExistsException' => 'couchbase/couchbase.stub', 'Couchbase\\KeyLockedException' => 'couchbase/couchbase.stub', 'Couchbase\\KeyValueException' => 'couchbase/couchbase.stub', 'Couchbase\\KeyspaceNotFoundException' => 'couchbase/couchbase.stub', 'Couchbase\\LoggingMeter' => 'couchbase/couchbase.stub', 'Couchbase\\LookupCountSpec' => 'couchbase/couchbase.stub', 'Couchbase\\LookupExistsSpec' => 'couchbase/couchbase.stub', 'Couchbase\\LookupGetFullSpec' => 'couchbase/couchbase.stub', 'Couchbase\\LookupGetSpec' => 'couchbase/couchbase.stub', 'Couchbase\\LookupInOptions' => 'couchbase/couchbase.stub', 'Couchbase\\LookupInResult' => 'couchbase/couchbase.stub', 'Couchbase\\LookupInSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MatchAllSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\MatchNoneSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\MatchPhraseSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\MatchSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\Meter' => 'couchbase/couchbase.stub', 'Couchbase\\MutateArrayAddUniqueSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateArrayAppendSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateArrayInsertSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateArrayPrependSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateCounterSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateInOptions' => 'couchbase/couchbase.stub', 'Couchbase\\MutateInResult' => 'couchbase/couchbase.stub', 'Couchbase\\MutateInSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateInsertSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateRemoveSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateReplaceSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutateUpsertSpec' => 'couchbase/couchbase.stub', 'Couchbase\\MutationResult' => 'couchbase/couchbase.stub', 'Couchbase\\MutationState' => 'couchbase/couchbase.stub', 'Couchbase\\MutationToken' => 'couchbase/couchbase.stub', 'Couchbase\\NetworkException' => 'couchbase/couchbase.stub', 'Couchbase\\NoopMeter' => 'couchbase/couchbase.stub', 'Couchbase\\NoopTracer' => 'couchbase/couchbase.stub', 'Couchbase\\NumericRangeFacetResult' => 'couchbase/couchbase.stub', 'Couchbase\\NumericRangeSearchFacet' => 'couchbase/couchbase.stub', 'Couchbase\\NumericRangeSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\Origin' => 'couchbase/couchbase.stub', 'Couchbase\\ParsingFailureException' => 'couchbase/couchbase.stub', 'Couchbase\\PartialViewException' => 'couchbase/couchbase.stub', 'Couchbase\\PathExistsException' => 'couchbase/couchbase.stub', 'Couchbase\\PathNotFoundException' => 'couchbase/couchbase.stub', 'Couchbase\\PhraseSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\PlanningFailureException' => 'couchbase/couchbase.stub', 'Couchbase\\PrefixSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\PreparedStatementException' => 'couchbase/couchbase.stub', 'Couchbase\\PrependOptions' => 'couchbase/couchbase.stub', 'Couchbase\\QueryErrorException' => 'couchbase/couchbase.stub', 'Couchbase\\QueryException' => 'couchbase/couchbase.stub', 'Couchbase\\QueryIndex' => 'couchbase/couchbase.stub', 'Couchbase\\QueryIndexManager' => 'couchbase/couchbase.stub', 'Couchbase\\QueryMetaData' => 'couchbase/couchbase.stub', 'Couchbase\\QueryOptions' => 'couchbase/couchbase.stub', 'Couchbase\\QueryProfile' => 'couchbase/couchbase.stub', 'Couchbase\\QueryResult' => 'couchbase/couchbase.stub', 'Couchbase\\QueryScanConsistency' => 'couchbase/couchbase.stub', 'Couchbase\\QueryServiceException' => 'couchbase/couchbase.stub', 'Couchbase\\QueryStringSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\QuotaLimitedException' => 'couchbase/couchbase.stub', 'Couchbase\\RateLimitedException' => 'couchbase/couchbase.stub', 'Couchbase\\RegexpSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\RemoveOptions' => 'couchbase/couchbase.stub', 'Couchbase\\ReplaceAnalyticsLinkOptions' => 'couchbase/couchbase.stub', 'Couchbase\\ReplaceOptions' => 'couchbase/couchbase.stub', 'Couchbase\\RequestCanceledException' => 'couchbase/couchbase.stub', 'Couchbase\\RequestSpan' => 'couchbase/couchbase.stub', 'Couchbase\\RequestTracer' => 'couchbase/couchbase.stub', 'Couchbase\\Result' => 'couchbase/couchbase.stub', 'Couchbase\\Role' => 'couchbase/couchbase.stub', 'Couchbase\\RoleAndDescription' => 'couchbase/couchbase.stub', 'Couchbase\\RoleAndOrigin' => 'couchbase/couchbase.stub', 'Couchbase\\S3ExternalAnalyticsLink' => 'couchbase/couchbase.stub', 'Couchbase\\Scope' => 'couchbase/couchbase.stub', 'Couchbase\\ScopeMissingException' => 'couchbase/couchbase.stub', 'Couchbase\\ScopeSpec' => 'couchbase/couchbase.stub', 'Couchbase\\SearchException' => 'couchbase/couchbase.stub', 'Couchbase\\SearchFacet' => 'couchbase/couchbase.stub', 'Couchbase\\SearchFacetResult' => 'couchbase/couchbase.stub', 'Couchbase\\SearchHighlightMode' => 'couchbase/couchbase.stub', 'Couchbase\\SearchIndex' => 'couchbase/couchbase.stub', 'Couchbase\\SearchIndexManager' => 'couchbase/couchbase.stub', 'Couchbase\\SearchMetaData' => 'couchbase/couchbase.stub', 'Couchbase\\SearchOptions' => 'couchbase/couchbase.stub', 'Couchbase\\SearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\SearchResult' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSort' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSortField' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSortGeoDistance' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSortId' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSortMissing' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSortMode' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSortScore' => 'couchbase/couchbase.stub', 'Couchbase\\SearchSortType' => 'couchbase/couchbase.stub', 'Couchbase\\ServiceMissingException' => 'couchbase/couchbase.stub', 'Couchbase\\StorageBackend' => 'couchbase/couchbase.stub', 'Couchbase\\StoreSemantics' => 'couchbase/couchbase.stub', 'Couchbase\\SubdocumentException' => 'couchbase/couchbase.stub', 'Couchbase\\TempFailException' => 'couchbase/couchbase.stub', 'Couchbase\\TermFacetResult' => 'couchbase/couchbase.stub', 'Couchbase\\TermRangeSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\TermSearchFacet' => 'couchbase/couchbase.stub', 'Couchbase\\TermSearchQuery' => 'couchbase/couchbase.stub', 'Couchbase\\ThresholdLoggingTracer' => 'couchbase/couchbase.stub', 'Couchbase\\TimeoutException' => 'couchbase/couchbase.stub', 'Couchbase\\TouchOptions' => 'couchbase/couchbase.stub', 'Couchbase\\UnlockOptions' => 'couchbase/couchbase.stub', 'Couchbase\\UpsertOptions' => 'couchbase/couchbase.stub', 'Couchbase\\UpsertUserOptions' => 'couchbase/couchbase.stub', 'Couchbase\\User' => 'couchbase/couchbase.stub', 'Couchbase\\UserAndMetadata' => 'couchbase/couchbase.stub', 'Couchbase\\UserManager' => 'couchbase/couchbase.stub', 'Couchbase\\ValueRecorder' => 'couchbase/couchbase.stub', 'Couchbase\\ValueTooBigException' => 'couchbase/couchbase.stub', 'Couchbase\\View' => 'couchbase/couchbase.stub', 'Couchbase\\ViewConsistency' => 'couchbase/couchbase.stub', 'Couchbase\\ViewException' => 'couchbase/couchbase.stub', 'Couchbase\\ViewIndexManager' => 'couchbase/couchbase.stub', 'Couchbase\\ViewMetaData' => 'couchbase/couchbase.stub', 'Couchbase\\ViewOptions' => 'couchbase/couchbase.stub', 'Couchbase\\ViewOrdering' => 'couchbase/couchbase.stub', 'Couchbase\\ViewResult' => 'couchbase/couchbase.stub', 'Couchbase\\ViewRow' => 'couchbase/couchbase.stub', 'Couchbase\\WatchQueryIndexesOptions' => 'couchbase/couchbase.stub', 'Couchbase\\WildcardSearchQuery' => 'couchbase/couchbase.stub', 'Countable' => 'Core/Core_c.stub', 'Crypto\\Base64' => 'crypto/crypto.stub', 'Crypto\\Base64Exception' => 'crypto/crypto.stub', 'Crypto\\CMAC' => 'crypto/crypto.stub', 'Crypto\\Cipher' => 'crypto/crypto.stub', 'Crypto\\CipherException' => 'crypto/crypto.stub', 'Crypto\\HMAC' => 'crypto/crypto.stub', 'Crypto\\Hash' => 'crypto/crypto.stub', 'Crypto\\HashException' => 'crypto/crypto.stub', 'Crypto\\KDF' => 'crypto/crypto.stub', 'Crypto\\KDFException' => 'crypto/crypto.stub', 'Crypto\\MAC' => 'crypto/crypto.stub', 'Crypto\\MACException' => 'crypto/crypto.stub', 'Crypto\\PBKDF2' => 'crypto/crypto.stub', 'Crypto\\PBKDF2Exception' => 'crypto/crypto.stub', 'Crypto\\Rand' => 'crypto/crypto.stub', 'Crypto\\RandException' => 'crypto/crypto.stub', 'CurlHandle' => 'curl/curl.stub', 'CurlMultiHandle' => 'curl/curl.stub', 'CurlShareHandle' => 'curl/curl.stub', 'DOMAttr' => 'dom/dom_c.stub', 'DOMCdataSection' => 'dom/dom_c.stub', 'DOMCharacterData' => 'dom/dom_c.stub', 'DOMChildNode' => 'dom/dom_c.stub', 'DOMComment' => 'dom/dom_c.stub', 'DOMConfiguration' => 'dom/dom_c.stub', 'DOMDocument' => 'dom/dom_c.stub', 'DOMDocumentFragment' => 'dom/dom_c.stub', 'DOMDocumentType' => 'dom/dom_c.stub', 'DOMDomError' => 'dom/dom_c.stub', 'DOMElement' => 'dom/dom_c.stub', 'DOMEntity' => 'dom/dom_c.stub', 'DOMEntityReference' => 'dom/dom_c.stub', 'DOMErrorHandler' => 'dom/dom_c.stub', 'DOMException' => 'dom/dom_c.stub', 'DOMImplementation' => 'dom/dom_c.stub', 'DOMImplementationList' => 'dom/dom_c.stub', 'DOMImplementationSource' => 'dom/dom_c.stub', 'DOMLocator' => 'dom/dom_c.stub', 'DOMNameList' => 'dom/dom_c.stub', 'DOMNameSpaceNode' => 'dom/dom_c.stub', 'DOMNamedNodeMap' => 'dom/dom_c.stub', 'DOMNode' => 'dom/dom_c.stub', 'DOMNodeList' => 'dom/dom_c.stub', 'DOMNotation' => 'dom/dom_c.stub', 'DOMParentNode' => 'dom/dom_c.stub', 'DOMProcessingInstruction' => 'dom/dom_c.stub', 'DOMStringExtend' => 'dom/dom_c.stub', 'DOMStringList' => 'dom/dom_c.stub', 'DOMText' => 'dom/dom_c.stub', 'DOMTypeinfo' => 'dom/dom_c.stub', 'DOMUserDataHandler' => 'dom/dom_c.stub', 'DOMXPath' => 'dom/dom_c.stub', 'DOTNET' => 'com_dotnet/com_dotnet.stub', 'DateError' => 'date/date_c.stub', 'DateException' => 'date/date_c.stub', 'DateInterval' => 'date/date_c.stub', 'DateInvalidOperationException' => 'date/date_c.stub', 'DateInvalidTimeZoneException' => 'date/date_c.stub', 'DateMalformedIntervalStringException' => 'date/date_c.stub', 'DateMalformedPeriodStringException' => 'date/date_c.stub', 'DateMalformedStringException' => 'date/date_c.stub', 'DateObjectError' => 'date/date_c.stub', 'DatePeriod' => 'date/date_c.stub', 'DateRangeError' => 'date/date_c.stub', 'DateTime' => 'date/date_c.stub', 'DateTimeImmutable' => 'date/date_c.stub', 'DateTimeInterface' => 'date/date_c.stub', 'DateTimeZone' => 'date/date_c.stub', 'Dba\\Connection' => 'dba/Connection.stub', 'Decimal\\Decimal' => 'decimal/decimal.stub', 'DeflateContext' => 'zlib/zlib.stub', 'Deprecated' => 'Core/Core_c.stub', 'Directory' => 'standard/standard_0.stub', 'DirectoryIterator' => 'SPL/SPL_c1.stub', 'DivisionByZeroError' => 'Core/Core_c.stub', 'Dom\\AdjacentPosition' => 'dom/dom_n.stub', 'Dom\\Attr' => 'dom/dom_n.stub', 'Dom\\BrokenRandomEngineError' => 'dom/dom_n.stub', 'Dom\\CDATASection' => 'dom/dom_n.stub', 'Dom\\CharacterData' => 'dom/dom_n.stub', 'Dom\\ChildNode' => 'dom/dom_n.stub', 'Dom\\Comment' => 'dom/dom_n.stub', 'Dom\\Document' => 'dom/dom_n.stub', 'Dom\\DocumentFragment' => 'dom/dom_n.stub', 'Dom\\DocumentType' => 'dom/dom_n.stub', 'Dom\\DtdNamedNodeMap' => 'dom/dom_n.stub', 'Dom\\Element' => 'dom/dom_n.stub', 'Dom\\Entity' => 'dom/dom_n.stub', 'Dom\\EntityReference' => 'dom/dom_n.stub', 'Dom\\HTMLCollection' => 'dom/dom_n.stub', 'Dom\\HTMLDocument' => 'dom/dom_n.stub', 'Dom\\HTMLElement' => 'dom/dom_n.stub', 'Dom\\Implementation' => 'dom/dom_n.stub', 'Dom\\Mysql' => 'dom/dom_n.stub', 'Dom\\NamedNodeMap' => 'dom/dom_n.stub', 'Dom\\NamespaceInfo' => 'dom/dom_n.stub', 'Dom\\Node' => 'dom/dom_n.stub', 'Dom\\NodeList' => 'dom/dom_n.stub', 'Dom\\Notation' => 'dom/dom_n.stub', 'Dom\\ParentNode' => 'dom/dom_n.stub', 'Dom\\ProcessingInstruction' => 'dom/dom_n.stub', 'Dom\\RandomError' => 'dom/dom_n.stub', 'Dom\\RandomException' => 'dom/dom_n.stub', 'Dom\\Sqlite' => 'dom/dom_n.stub', 'Dom\\Text' => 'dom/dom_n.stub', 'Dom\\TokenList' => 'dom/dom_n.stub', 'Dom\\XMLDocument' => 'dom/dom_n.stub', 'Dom\\XPath' => 'dom/dom_n.stub', 'DomainException' => 'SPL/SPL.stub', 'Ds\\Collection' => 'ds/ds.stub', 'Ds\\Deque' => 'ds/ds.stub', 'Ds\\Hashable' => 'ds/ds.stub', 'Ds\\Map' => 'ds/ds.stub', 'Ds\\Pair' => 'ds/ds.stub', 'Ds\\PriorityQueue' => 'ds/ds.stub', 'Ds\\Queue' => 'ds/ds.stub', 'Ds\\Sequence' => 'ds/ds.stub', 'Ds\\Set' => 'ds/ds.stub', 'Ds\\Stack' => 'ds/ds.stub', 'Ds\\Vector' => 'ds/ds.stub', 'Elastic\\Apm\\CustomErrorData' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\DistributedTracingData' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\ElasticApm' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\ExecutionSegmentContextInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\ExecutionSegmentInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\SpanContextDbInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\SpanContextDestinationInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\SpanContextHttpInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\SpanContextInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\SpanInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\TransactionBuilderInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\TransactionContextInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\TransactionContextRequestInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\TransactionContextRequestUrlInterface' => 'elastic_apm/elastic_apm.stub', 'Elastic\\Apm\\TransactionInterface' => 'elastic_apm/elastic_apm.stub', 'EmptyIterator' => 'SPL/SPL.stub', 'EnchantBroker' => 'enchant/enchant.stub', 'EnchantDictionary' => 'enchant/enchant.stub', 'Error' => 'Core/Core_c.stub', 'ErrorException' => 'Core/Core_c.stub', 'Ev' => 'Ev/Ev.stub', 'EvCheck' => 'Ev/Ev.stub', 'EvChild' => 'Ev/Ev.stub', 'EvEmbed' => 'Ev/Ev.stub', 'EvFork' => 'Ev/Ev.stub', 'EvIdle' => 'Ev/Ev.stub', 'EvIo' => 'Ev/Ev.stub', 'EvLoop' => 'Ev/Ev.stub', 'EvPeriodic' => 'Ev/Ev.stub', 'EvPrepare' => 'Ev/Ev.stub', 'EvSignal' => 'Ev/Ev.stub', 'EvStat' => 'Ev/Ev.stub', 'EvTimer' => 'Ev/Ev.stub', 'EvWatcher' => 'Ev/Ev.stub', 'Event' => 'event/event.stub', 'EventBase' => 'event/event.stub', 'EventBuffer' => 'event/event.stub', 'EventBufferEvent' => 'event/event.stub', 'EventConfig' => 'event/event.stub', 'EventDnsBase' => 'event/event.stub', 'EventHttp' => 'event/event.stub', 'EventHttpConnection' => 'event/event.stub', 'EventHttpRequest' => 'event/event.stub', 'EventListener' => 'event/event.stub', 'EventSslContext' => 'event/event.stub', 'EventUtil' => 'event/event.stub', 'Exception' => 'Core/Core_c.stub', 'FANNConnection' => 'fann/fann.stub', 'FFI' => 'FFI/FFI.stub', 'FFI\\CData' => 'FFI/FFI.stub', 'FFI\\CType' => 'FFI/FFI.stub', 'FFI\\Exception' => 'FFI/FFI.stub', 'FFI\\ParserException' => 'FFI/FFI.stub', 'FTP\\Connection' => 'ftp/Connection.stub', 'Fiber' => 'Core/Core_c.stub', 'FiberError' => 'Core/Core_c.stub', 'FilesystemIterator' => 'SPL/SPL_c1.stub', 'FilterIterator' => 'SPL/SPL.stub', 'GEOSGeometry' => 'geos/geos.stub', 'GEOSWKBReader' => 'geos/geos.stub', 'GEOSWKBWriter' => 'geos/geos.stub', 'GEOSWKTReader' => 'geos/geos.stub', 'GEOSWKTWriter' => 'geos/geos.stub', 'GMP' => 'gmp/gmp.stub', 'GdFont' => 'gd/GdFont.stub', 'GdImage' => 'gd/gd.stub', 'GearmanClient' => 'gearman/gearman.stub', 'GearmanException' => 'gearman/gearman.stub', 'GearmanJob' => 'gearman/gearman.stub', 'GearmanTask' => 'gearman/gearman.stub', 'GearmanWorker' => 'gearman/gearman.stub', 'Generator' => 'standard/_types.stub', 'GlobIterator' => 'SPL/SPL_c1.stub', 'Gmagick' => 'gmagick/gmagick.stub', 'GmagickDraw' => 'gmagick/gmagick.stub', 'GmagickException' => 'gmagick/gmagick.stub', 'GmagickPixel' => 'gmagick/gmagick.stub', 'GmagickPixelException' => 'gmagick/gmagick.stub', 'Grpc\\Call' => 'grpc/grpc.stub', 'Grpc\\CallCredentials' => 'grpc/grpc.stub', 'Grpc\\Channel' => 'grpc/grpc.stub', 'Grpc\\ChannelCredentials' => 'grpc/grpc.stub', 'Grpc\\Server' => 'grpc/grpc.stub', 'Grpc\\ServerCredentials' => 'grpc/grpc.stub', 'Grpc\\Timeval' => 'grpc/grpc.stub', 'HashContext' => 'hash/hash.stub', 'HttpDeflateStream' => 'http/http.stub', 'HttpEncodingException' => 'http/http.stub', 'HttpException' => 'http/http.stub', 'HttpHeaderException' => 'http/http.stub', 'HttpInflateStream' => 'http/http.stub', 'HttpInvalidParamException' => 'http/http.stub', 'HttpMalformedHeadersException' => 'http/http.stub', 'HttpMessage' => 'http/http.stub', 'HttpMessageTypeException' => 'http/http.stub', 'HttpQueryString' => 'http/http.stub', 'HttpQueryStringException' => 'http/http.stub', 'HttpRequest' => 'http/http.stub', 'HttpRequestDataShare' => 'http/http.stub', 'HttpRequestException' => 'http/http.stub', 'HttpRequestMethodException' => 'http/http.stub', 'HttpRequestPool' => 'http/http.stub', 'HttpRequestPoolException' => 'http/http.stub', 'HttpResponse' => 'http/http.stub', 'HttpResponseException' => 'http/http.stub', 'HttpRuntimeException' => 'http/http.stub', 'HttpSocketException' => 'http/http.stub', 'HttpUrlException' => 'http/http.stub', 'HttpUtil' => 'http/http.stub', 'IMAP\\Connection' => 'imap/Connection.stub', 'Imagick' => 'imagick/imagick.stub', 'ImagickDraw' => 'imagick/imagick.stub', 'ImagickDrawException' => 'imagick/imagick.stub', 'ImagickException' => 'imagick/imagick.stub', 'ImagickKernel' => 'imagick/imagick.stub', 'ImagickKernelException' => 'imagick/imagick.stub', 'ImagickPixel' => 'imagick/imagick.stub', 'ImagickPixelException' => 'imagick/imagick.stub', 'ImagickPixelIterator' => 'imagick/imagick.stub', 'ImagickPixelIteratorException' => 'imagick/imagick.stub', 'InfiniteIterator' => 'SPL/SPL.stub', 'InflateContext' => 'zlib/zlib.stub', 'InternalIterator' => 'Core/Core_c.stub', 'IntlBreakIterator' => 'intl/intl.stub', 'IntlCalendar' => 'intl/intl.stub', 'IntlChar' => 'intl/IntlChar.stub', 'IntlCodePointBreakIterator' => 'intl/intl.stub', 'IntlDateFormatter' => 'intl/intl.stub', 'IntlDatePatternGenerator' => 'intl/IntlDatePatternGenerator.stub', 'IntlException' => 'intl/intl.stub', 'IntlGregorianCalendar' => 'intl/intl.stub', 'IntlIterator' => 'intl/intl.stub', 'IntlPartsIterator' => 'intl/intl.stub', 'IntlRuleBasedBreakIterator' => 'intl/intl.stub', 'IntlTimeZone' => 'intl/intl.stub', 'InvalidArgumentException' => 'SPL/SPL.stub', 'Iterator' => 'Core/Core_c.stub', 'IteratorAggregate' => 'Core/Core_c.stub', 'IteratorIterator' => 'SPL/SPL.stub', 'JavaException' => 'zend/zend.stub', 'JsonException' => 'json/json.stub', 'JsonIncrementalParser' => 'json/json.stub', 'JsonSerializable' => 'json/json.stub', 'Judy' => 'judy/judy.stub', 'LDAP\\Connection' => 'ldap/Connection.stub', 'LDAP\\Result' => 'ldap/Result.stub', 'LDAP\\ResultEntry' => 'ldap/ResultEntry.stub', 'LengthException' => 'SPL/SPL.stub', 'LevelDB' => 'leveldb/LevelDB.stub', 'LevelDBException' => 'leveldb/LevelDB.stub', 'LevelDBIterator' => 'leveldb/LevelDB.stub', 'LevelDBSnapshot' => 'leveldb/LevelDB.stub', 'LevelDBWriteBatch' => 'leveldb/LevelDB.stub', 'LibXMLError' => 'libxml/libxml.stub', 'LimitIterator' => 'SPL/SPL.stub', 'Locale' => 'intl/intl.stub', 'LogicException' => 'SPL/SPL.stub', 'Lua' => 'lua/lua.stub', 'LuaSandbox' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxError' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxErrorError' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxFatalError' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxFunction' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxMemoryError' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxRuntimeError' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxSyntaxError' => 'LuaSandbox/LuaSandbox.stub', 'LuaSandboxTimeoutError' => 'LuaSandbox/LuaSandbox.stub', 'Memcache' => 'memcache/memcache.stub', 'MemcachePool' => 'memcache/memcache.stub', 'Memcached' => 'memcached/memcached.stub', 'MemcachedException' => 'memcached/memcached.stub', 'MessageFormatter' => 'intl/intl.stub', 'MessagePack' => 'msgpack/msgpack.stub', 'MessagePackUnpacker' => 'msgpack/msgpack.stub', 'Mongo' => 'mongo/mongo.stub', 'MongoBinData' => 'mongo/mongo.stub', 'MongoClient' => 'mongo/mongo.stub', 'MongoCode' => 'mongo/mongo.stub', 'MongoCollection' => 'mongo/mongo.stub', 'MongoCommandCursor' => 'mongo/mongo.stub', 'MongoConnectionException' => 'mongo/mongo.stub', 'MongoCursor' => 'mongo/mongo.stub', 'MongoCursorException' => 'mongo/mongo.stub', 'MongoCursorInterface' => 'mongo/mongo.stub', 'MongoCursorTimeoutException' => 'mongo/mongo.stub', 'MongoDB' => 'mongo/mongo.stub', 'MongoDBRef' => 'mongo/mongo.stub', 'MongoDB\\BSON\\Binary' => 'mongodb/BSON/Binary.stub', 'MongoDB\\BSON\\BinaryInterface' => 'mongodb/BSON/BinaryInterface.stub', 'MongoDB\\BSON\\DBPointer' => 'mongodb/BSON/DBPointer.stub', 'MongoDB\\BSON\\Decimal128' => 'mongodb/BSON/Decimal128.stub', 'MongoDB\\BSON\\Decimal128Interface' => 'mongodb/BSON/Decimal128Interface.stub', 'MongoDB\\BSON\\Document' => 'mongodb/BSON/Document.stub', 'MongoDB\\BSON\\Int64' => 'mongodb/BSON/Int64.stub', 'MongoDB\\BSON\\Iterator' => 'mongodb/BSON/Iterator.stub', 'MongoDB\\BSON\\Javascript' => 'mongodb/BSON/Javascript.stub', 'MongoDB\\BSON\\JavascriptInterface' => 'mongodb/BSON/JavascriptInterface.stub', 'MongoDB\\BSON\\MaxKey' => 'mongodb/BSON/MaxKey.stub', 'MongoDB\\BSON\\MaxKeyInterface' => 'mongodb/BSON/MaxKeyInterface.stub', 'MongoDB\\BSON\\MinKey' => 'mongodb/BSON/MinKey.stub', 'MongoDB\\BSON\\MinKeyInterface' => 'mongodb/BSON/MinKeyInterface.stub', 'MongoDB\\BSON\\ObjectId' => 'mongodb/BSON/ObjectId.stub', 'MongoDB\\BSON\\ObjectIdInterface' => 'mongodb/BSON/ObjectIdInterface.stub', 'MongoDB\\BSON\\PackedArray' => 'mongodb/BSON/PackedArray.stub', 'MongoDB\\BSON\\Persistable' => 'mongodb/BSON/Persistable.stub', 'MongoDB\\BSON\\Regex' => 'mongodb/BSON/Regex.stub', 'MongoDB\\BSON\\RegexInterface' => 'mongodb/BSON/RegexInterface.stub', 'MongoDB\\BSON\\Serializable' => 'mongodb/BSON/Serializable.stub', 'MongoDB\\BSON\\Symbol' => 'mongodb/BSON/Symbol.stub', 'MongoDB\\BSON\\Timestamp' => 'mongodb/BSON/Timestamp.stub', 'MongoDB\\BSON\\TimestampInterface' => 'mongodb/BSON/TimestampInterface.stub', 'MongoDB\\BSON\\Type' => 'mongodb/BSON/Type.stub', 'MongoDB\\BSON\\UTCDateTime' => 'mongodb/BSON/UTCDateTime.stub', 'MongoDB\\BSON\\UTCDateTimeInterface' => 'mongodb/BSON/UTCDateTimeInterface.stub', 'MongoDB\\BSON\\Undefined' => 'mongodb/BSON/Undefined.stub', 'MongoDB\\BSON\\Unserializable' => 'mongodb/BSON/Unserializable.stub', 'MongoDB\\Driver\\BulkWrite' => 'mongodb/BulkWrite.stub', 'MongoDB\\Driver\\ClientEncryption' => 'mongodb/ClientEncryption.stub', 'MongoDB\\Driver\\Command' => 'mongodb/Command.stub', 'MongoDB\\Driver\\Cursor' => 'mongodb/Cursor.stub', 'MongoDB\\Driver\\CursorId' => 'mongodb/CursorId.stub', 'MongoDB\\Driver\\CursorInterface' => 'mongodb/CursorInterface.stub', 'MongoDB\\Driver\\Exception\\AuthenticationException' => 'mongodb/Exception/AuthenticationException.stub', 'MongoDB\\Driver\\Exception\\BulkWriteException' => 'mongodb/Exception/BulkWriteException.stub', 'MongoDB\\Driver\\Exception\\CommandException' => 'mongodb/Exception/CommandException.stub', 'MongoDB\\Driver\\Exception\\ConnectionException' => 'mongodb/Exception/ConnectionException.stub', 'MongoDB\\Driver\\Exception\\ConnectionTimeoutException' => 'mongodb/Exception/ConnectionTimeoutException.stub', 'MongoDB\\Driver\\Exception\\EncryptionException' => 'mongodb/Exception/EncryptionException.stub', 'MongoDB\\Driver\\Exception\\Exception' => 'mongodb/Exception/Exception.stub', 'MongoDB\\Driver\\Exception\\ExecutionTimeoutException' => 'mongodb/Exception/ExecutionTimeoutException.stub', 'MongoDB\\Driver\\Exception\\InvalidArgumentException' => 'mongodb/Exception/InvalidArgumentException.stub', 'MongoDB\\Driver\\Exception\\LogicException' => 'mongodb/Exception/LogicException.stub', 'MongoDB\\Driver\\Exception\\RuntimeException' => 'mongodb/Exception/RuntimeException.stub', 'MongoDB\\Driver\\Exception\\SSLConnectionException' => 'mongodb/Exception/SSLConnectionException.stub', 'MongoDB\\Driver\\Exception\\ServerException' => 'mongodb/Exception/ServerException.stub', 'MongoDB\\Driver\\Exception\\UnexpectedValueException' => 'mongodb/Exception/UnexpectedValueException.stub', 'MongoDB\\Driver\\Exception\\WriteConcernException' => 'mongodb/Exception/WriteConcernException.stub', 'MongoDB\\Driver\\Exception\\WriteException' => 'mongodb/Exception/WriteException.stub', 'MongoDB\\Driver\\Manager' => 'mongodb/Manager.stub', 'MongoDB\\Driver\\Monitoring\\CommandFailedEvent' => 'mongodb/Monitoring/CommandFailedEvent.stub', 'MongoDB\\Driver\\Monitoring\\CommandStartedEvent' => 'mongodb/Monitoring/CommandStartedEvent.stub', 'MongoDB\\Driver\\Monitoring\\CommandSubscriber' => 'mongodb/Monitoring/CommandSubscriber.stub', 'MongoDB\\Driver\\Monitoring\\CommandSucceededEvent' => 'mongodb/Monitoring/CommandSucceededEvent.stub', 'MongoDB\\Driver\\Monitoring\\LogSubscriber' => 'mongodb/Monitoring/LogSubscriber.stub', 'MongoDB\\Driver\\Monitoring\\SDAMSubscriber' => 'mongodb/Monitoring/SDAMSubscriber.stub', 'MongoDB\\Driver\\Monitoring\\ServerChangedEvent' => 'mongodb/Monitoring/ServerChangedEvent.stub', 'MongoDB\\Driver\\Monitoring\\ServerClosedEvent' => 'mongodb/Monitoring/ServerClosedEvent.stub', 'MongoDB\\Driver\\Monitoring\\ServerHeartbeatFailedEvent' => 'mongodb/Monitoring/ServerHeartbeatFailedEvent.stub', 'MongoDB\\Driver\\Monitoring\\ServerHeartbeatStartedEvent' => 'mongodb/Monitoring/ServerHeartbeatStartedEvent.stub', 'MongoDB\\Driver\\Monitoring\\ServerHeartbeatSucceededEvent' => 'mongodb/Monitoring/ServerHeartbeatSucceededEvent.stub', 'MongoDB\\Driver\\Monitoring\\ServerOpeningEvent' => 'mongodb/Monitoring/ServerOpeningEvent.stub', 'MongoDB\\Driver\\Monitoring\\Subscriber' => 'mongodb/Monitoring/Subscriber.stub', 'MongoDB\\Driver\\Monitoring\\TopologyChangedEvent' => 'mongodb/Monitoring/TopologyChangedEvent.stub', 'MongoDB\\Driver\\Monitoring\\TopologyClosedEvent' => 'mongodb/Monitoring/TopologyClosedEvent.stub', 'MongoDB\\Driver\\Monitoring\\TopologyOpeningEvent' => 'mongodb/Monitoring/TopologyOpeningEvent.stub', 'MongoDB\\Driver\\Query' => 'mongodb/Query.stub', 'MongoDB\\Driver\\ReadConcern' => 'mongodb/ReadConcern.stub', 'MongoDB\\Driver\\ReadPreference' => 'mongodb/ReadPreference.stub', 'MongoDB\\Driver\\Server' => 'mongodb/Server.stub', 'MongoDB\\Driver\\ServerApi' => 'mongodb/ServerApi.stub', 'MongoDB\\Driver\\ServerDescription' => 'mongodb/ServerDescription.stub', 'MongoDB\\Driver\\Session' => 'mongodb/Session.stub', 'MongoDB\\Driver\\TopologyDescription' => 'mongodb/TopologyDescription.stub', 'MongoDB\\Driver\\WriteConcern' => 'mongodb/WriteConcern.stub', 'MongoDB\\Driver\\WriteConcernError' => 'mongodb/WriteConcernError.stub', 'MongoDB\\Driver\\WriteError' => 'mongodb/WriteError.stub', 'MongoDB\\Driver\\WriteResult' => 'mongodb/WriteResult.stub', 'MongoDate' => 'mongo/mongo.stub', 'MongoDuplicateKeyException' => 'mongo/mongo.stub', 'MongoException' => 'mongo/mongo.stub', 'MongoExecutionTimeoutException' => 'mongo/mongo.stub', 'MongoGridFS' => 'mongo/mongo.stub', 'MongoGridFSCursor' => 'mongo/mongo.stub', 'MongoGridFSException' => 'mongo/mongo.stub', 'MongoGridFSFile' => 'mongo/mongo.stub', 'MongoId' => 'mongo/mongo.stub', 'MongoInt32' => 'mongo/mongo.stub', 'MongoInt64' => 'mongo/mongo.stub', 'MongoLog' => 'mongo/mongo.stub', 'MongoMaxKey' => 'mongo/mongo.stub', 'MongoMinKey' => 'mongo/mongo.stub', 'MongoPool' => 'mongo/mongo.stub', 'MongoProtocolException' => 'mongo/mongo.stub', 'MongoRegex' => 'mongo/mongo.stub', 'MongoResultException' => 'mongo/mongo.stub', 'MongoTimestamp' => 'mongo/mongo.stub', 'MongoUpdateBatch' => 'mongo/mongo.stub', 'MongoWriteBatch' => 'mongo/mongo.stub', 'MongoWriteConcernException' => 'mongo/mongo.stub', 'Mosquitto\\Client' => 'mosquitto-php/mosquitto-php.stub', 'Mosquitto\\Exception' => 'mosquitto-php/mosquitto-php.stub', 'Mosquitto\\Message' => 'mosquitto-php/mosquitto-php.stub', 'MultipleIterator' => 'SPL/SPL_c1.stub', 'NoRewindIterator' => 'SPL/SPL.stub', 'Normalizer' => 'intl/intl.stub', 'NumberFormatter' => 'intl/intl.stub', 'OAuth' => 'oauth/oauth.stub', 'OAuthException' => 'oauth/oauth.stub', 'OAuthProvider' => 'oauth/oauth.stub', 'OCICollection' => 'oci8/oci8v3.stub', 'OCILob' => 'oci8/oci8v3.stub', 'OCI_Collection' => 'oci8/oci8.stub', 'OCI_Lob' => 'oci8/oci8.stub', 'OpenSSLAsymmetricKey' => 'openssl/openssl.stub', 'OpenSSLCertificate' => 'openssl/openssl.stub', 'OpenSSLCertificateSigningRequest' => 'openssl/openssl.stub', 'OutOfBoundsException' => 'SPL/SPL.stub', 'OutOfRangeException' => 'SPL/SPL.stub', 'OuterIterator' => 'SPL/SPL.stub', 'OverflowException' => 'SPL/SPL.stub', 'Override' => 'Core/Core_c.stub', 'OwsrequestObj' => 'mapscript/mapscript.stub', 'PDFlib' => 'pdflib/PDFlib.stub', 'PDFlibException' => 'pdflib/PDFlib.stub', 'PDO' => 'PDO/PDO.stub', 'PDOException' => 'PDO/PDO.stub', 'PDORow' => 'PDO/PDO.stub', 'PDOStatement' => 'PDO/PDO.stub', 'PSpell\\Config' => 'pspell/pspell_c.stub', 'PSpell\\Dictionary' => 'pspell/pspell_c.stub', 'ParentIterator' => 'SPL/SPL.stub', 'Parle\\ErrorInfo' => 'Parle/ErrorInfo.stub', 'Parle\\Lexer' => 'Parle/Lexer.stub', 'Parle\\LexerException' => 'Parle/LexerException.stub', 'Parle\\Parser' => 'Parle/Parser.stub', 'Parle\\ParserException' => 'Parle/ParserException.stub', 'Parle\\RLexer' => 'Parle/RLexer.stub', 'Parle\\RParser' => 'Parle/RParser.stub', 'Parle\\Stack' => 'Parle/Stack.stub', 'Parle\\Token' => 'Parle/Token.stub', 'ParseError' => 'Core/Core_c.stub', 'Pcntl\\QosClass' => 'pcntl/pcntl_c.stub', 'Pdo\\Mysql' => 'PDO/PDO.stub', 'Pdo\\Sqlite' => 'PDO/PDO.stub', 'PgSql\\Connection' => 'pgsql/pgsql_c.stub', 'PgSql\\Lob' => 'pgsql/pgsql_c.stub', 'PgSql\\Result' => 'pgsql/pgsql_c.stub', 'Phar' => 'Phar/Phar.stub', 'PharData' => 'Phar/Phar.stub', 'PharException' => 'Phar/Phar.stub', 'PharFileInfo' => 'Phar/Phar.stub', 'PhpToken' => 'tokenizer/PhpToken.stub', 'Pool' => 'pthreads/pthreads.stub', 'PropertyHookType' => 'Reflection/PropertyHookType.stub', 'RRDCreator' => 'rrd/rrd.stub', 'RRDGraph' => 'rrd/rrd.stub', 'RRDUpdater' => 'rrd/rrd.stub', 'Random\\BrokenRandomEngineError' => 'random/random.stub', 'Random\\CryptoSafeEngine' => 'random/random.stub', 'Random\\Engine' => 'random/random.stub', 'Random\\Engine\\Mt19937' => 'random/random.stub', 'Random\\Engine\\PcgOneseq128XslRr64' => 'random/random.stub', 'Random\\Engine\\Secure' => 'random/random.stub', 'Random\\Engine\\Xoshiro256StarStar' => 'random/random.stub', 'Random\\IntervalBoundary' => 'random/random.stub', 'Random\\RandomError' => 'random/random.stub', 'Random\\RandomException' => 'random/random.stub', 'Random\\Randomizer' => 'random/random.stub', 'RangeException' => 'SPL/SPL.stub', 'RarArchive' => 'rar/rar.stub', 'RarEntry' => 'rar/rar.stub', 'RarException' => 'rar/rar.stub', 'RdKafka' => 'rdkafka/RdKafka.stub', 'RdKafka\\Conf' => 'rdkafka/RdKafka/Conf.stub', 'RdKafka\\Consumer' => 'rdkafka/RdKafka/Consumer.stub', 'RdKafka\\ConsumerTopic' => 'rdkafka/RdKafka/ConsumerTopic.stub', 'RdKafka\\Exception' => 'rdkafka/RdKafka/Exception.stub', 'RdKafka\\KafkaConsumer' => 'rdkafka/RdKafka/KafkaConsumer.stub', 'RdKafka\\KafkaConsumerTopic' => 'rdkafka/RdKafka/KafkaConsumerTopic.stub', 'RdKafka\\KafkaErrorException' => 'rdkafka/RdKafka/KafkaErrorException.stub', 'RdKafka\\Message' => 'rdkafka/RdKafka/Message.stub', 'RdKafka\\Metadata' => 'rdkafka/RdKafka/Metadata.stub', 'RdKafka\\Metadata\\Broker' => 'rdkafka/RdKafka/Metadata/Broker.stub', 'RdKafka\\Metadata\\Collection' => 'rdkafka/RdKafka/Metadata/Collection.stub', 'RdKafka\\Metadata\\Partition' => 'rdkafka/RdKafka/Metadata/Partition.stub', 'RdKafka\\Metadata\\Topic' => 'rdkafka/RdKafka/Metadata/Topic.stub', 'RdKafka\\Producer' => 'rdkafka/RdKafka/Producer.stub', 'RdKafka\\ProducerTopic' => 'rdkafka/RdKafka/ProducerTopic.stub', 'RdKafka\\Queue' => 'rdkafka/RdKafka/Queue.stub', 'RdKafka\\Topic' => 'rdkafka/RdKafka/Topic.stub', 'RdKafka\\TopicConf' => 'rdkafka/RdKafka/TopicConf.stub', 'RdKafka\\TopicPartition' => 'rdkafka/RdKafka/TopicPartition.stub', 'RecursiveArrayIterator' => 'SPL/SPL.stub', 'RecursiveCachingIterator' => 'SPL/SPL.stub', 'RecursiveCallbackFilterIterator' => 'SPL/SPL.stub', 'RecursiveDirectoryIterator' => 'SPL/SPL_c1.stub', 'RecursiveFilterIterator' => 'SPL/SPL.stub', 'RecursiveIterator' => 'SPL/SPL.stub', 'RecursiveIteratorIterator' => 'SPL/SPL.stub', 'RecursiveRegexIterator' => 'SPL/SPL.stub', 'RecursiveTreeIterator' => 'SPL/SPL.stub', 'Redis' => 'redis/Redis.stub', 'RedisArray' => 'redis/RedisArray.stub', 'RedisCluster' => 'redis/RedisCluster.stub', 'RedisClusterException' => 'redis/RedisCluster.stub', 'RedisException' => 'redis/Redis.stub', 'RedisSentinel' => 'redis/RedisSentinel.stub', 'Reflection' => 'Reflection/Reflection.stub', 'ReflectionAttribute' => 'Reflection/ReflectionAttribute.stub', 'ReflectionClass' => 'Reflection/ReflectionClass.stub', 'ReflectionClassConstant' => 'Reflection/ReflectionClassConstant.stub', 'ReflectionConstant' => 'Reflection/ReflectionConstant.stub', 'ReflectionEnum' => 'Reflection/ReflectionEnum.stub', 'ReflectionEnumBackedCase' => 'Reflection/ReflectionEnumBackedCase.stub', 'ReflectionEnumUnitCase' => 'Reflection/ReflectionEnumUnitCase.stub', 'ReflectionException' => 'Reflection/ReflectionException.stub', 'ReflectionExtension' => 'Reflection/ReflectionExtension.stub', 'ReflectionFiber' => 'Reflection/ReflectionFiber.stub', 'ReflectionFunction' => 'Reflection/ReflectionFunction.stub', 'ReflectionFunctionAbstract' => 'Reflection/ReflectionFunctionAbstract.stub', 'ReflectionGenerator' => 'Reflection/ReflectionGenerator.stub', 'ReflectionIntersectionType' => 'Reflection/ReflectionIntersectionType.stub', 'ReflectionMethod' => 'Reflection/ReflectionMethod.stub', 'ReflectionNamedType' => 'Reflection/ReflectionNamedType.stub', 'ReflectionObject' => 'Reflection/ReflectionObject.stub', 'ReflectionParameter' => 'Reflection/ReflectionParameter.stub', 'ReflectionProperty' => 'Reflection/ReflectionProperty.stub', 'ReflectionReference' => 'Reflection/ReflectionReference.stub', 'ReflectionType' => 'Reflection/ReflectionType.stub', 'ReflectionUnionType' => 'Reflection/ReflectionUnionType.stub', 'ReflectionZendExtension' => 'Reflection/ReflectionZendExtension.stub', 'Reflector' => 'Reflection/Reflector.stub', 'RegexIterator' => 'SPL/SPL.stub', 'Relay\\Cluster' => 'relay/Cluster.stub', 'Relay\\Event' => 'relay/Event.stub', 'Relay\\Event\\Flushed' => 'relay/Events.stub', 'Relay\\Event\\Invalidated' => 'relay/Events.stub', 'Relay\\Exception' => 'relay/Exception.stub', 'Relay\\KeyType' => 'relay/KeyType.stub', 'Relay\\Relay' => 'relay/Relay.stub', 'Relay\\Sentinel' => 'relay/Sentinel.stub', 'Relay\\Table' => 'relay/Table.stub', 'RequestParseBodyException' => 'Core/Core_c.stub', 'ResourceBundle' => 'intl/intl.stub', 'ReturnTypeWillChange' => 'Core/Core_c.stub', 'RoundingMode' => 'standard/standard_10.stub', 'RuntimeException' => 'SPL/SPL.stub', 'SNMP' => 'snmp/snmp.stub', 'SNMPException' => 'snmp/snmp.stub', 'SQLite3' => 'sqlite3/sqlite3.stub', 'SQLite3Exception' => 'sqlite3/sqlite3.stub', 'SQLite3Result' => 'sqlite3/sqlite3.stub', 'SQLite3Stmt' => 'sqlite3/sqlite3.stub', 'SQLiteDatabase' => 'SQLite/SQLite.stub', 'SQLiteException' => 'SQLite/SQLite.stub', 'SQLiteResult' => 'SQLite/SQLite.stub', 'SQLiteUnbuffered' => 'SQLite/SQLite.stub', 'SVM' => 'svm/SVM.stub', 'SVMModel' => 'svm/SVMModel.stub', 'SWFAction' => 'ming/ming.stub', 'SWFBitmap' => 'ming/ming.stub', 'SWFButton' => 'ming/ming.stub', 'SWFDisplayItem' => 'ming/ming.stub', 'SWFFill' => 'ming/ming.stub', 'SWFFont' => 'ming/ming.stub', 'SWFFontChar' => 'ming/ming.stub', 'SWFGradient' => 'ming/ming.stub', 'SWFMorph' => 'ming/ming.stub', 'SWFMovie' => 'ming/ming.stub', 'SWFShape' => 'ming/ming.stub', 'SWFSound' => 'ming/ming.stub', 'SWFSoundInstance' => 'ming/ming.stub', 'SWFSprite' => 'ming/ming.stub', 'SWFText' => 'ming/ming.stub', 'SWFTextField' => 'ming/ming.stub', 'SWFVideoStream' => 'ming/ming.stub', 'Saxon\\SaxonProcessor' => 'SaxonC/SaxonC.stub', 'Saxon\\SchemaValidator' => 'SaxonC/SaxonC.stub', 'Saxon\\XPathProcessor' => 'SaxonC/SaxonC.stub', 'Saxon\\XQueryProcessor' => 'SaxonC/SaxonC.stub', 'Saxon\\XdmAtomicValue' => 'SaxonC/SaxonC.stub', 'Saxon\\XdmItem' => 'SaxonC/SaxonC.stub', 'Saxon\\XdmNode' => 'SaxonC/SaxonC.stub', 'Saxon\\XdmValue' => 'SaxonC/SaxonC.stub', 'Saxon\\Xslt30Processor' => 'SaxonC/SaxonC.stub', 'Saxon\\XsltProcessor' => 'SaxonC/SaxonC.stub', 'SeekableIterator' => 'SPL/SPL.stub', 'SensitiveParameter' => 'Core/Core_c.stub', 'SensitiveParameterValue' => 'Core/Core_c.stub', 'Serializable' => 'Core/Core_c.stub', 'SessionHandler' => 'session/SessionHandler.stub', 'SessionHandlerInterface' => 'session/SessionHandler.stub', 'SessionIdInterface' => 'session/SessionHandler.stub', 'SessionUpdateTimestampHandlerInterface' => 'session/SessionHandler.stub', 'Shmop' => 'shmop/shmop.stub', 'SimdJsonException' => 'simdjson/simdjson.stub', 'SimdJsonValueError' => 'simdjson/simdjson.stub', 'SimpleKafkaClient' => 'simple_kafka_client/SimpleKafkaClient.stub', 'SimpleKafkaClient\\Configuration' => 'simple_kafka_client/SimpleKafkaClient/Configuration.stub', 'SimpleKafkaClient\\Consumer' => 'simple_kafka_client/SimpleKafkaClient/Consumer.stub', 'SimpleKafkaClient\\ConsumerTopic' => 'simple_kafka_client/SimpleKafkaClient/Topic.stub', 'SimpleKafkaClient\\Exception' => 'simple_kafka_client/SimpleKafkaClient/Exception.stub', 'SimpleKafkaClient\\KafkaErrorException' => 'simple_kafka_client/SimpleKafkaClient/KafkaErrorException.stub', 'SimpleKafkaClient\\Message' => 'simple_kafka_client/SimpleKafkaClient/Message.stub', 'SimpleKafkaClient\\Metadata' => 'simple_kafka_client/SimpleKafkaClient/Metadata.stub', 'SimpleKafkaClient\\Metadata\\Broker' => 'simple_kafka_client/SimpleKafkaClient/Metadata/Broker.stub', 'SimpleKafkaClient\\Metadata\\Collection' => 'simple_kafka_client/SimpleKafkaClient/Metadata/Collection.stub', 'SimpleKafkaClient\\Metadata\\Partition' => 'simple_kafka_client/SimpleKafkaClient/Metadata/Partition.stub', 'SimpleKafkaClient\\Metadata\\Topic' => 'simple_kafka_client/SimpleKafkaClient/Metadata/Topic.stub', 'SimpleKafkaClient\\Producer' => 'simple_kafka_client/SimpleKafkaClient/Producer.stub', 'SimpleKafkaClient\\ProducerTopic' => 'simple_kafka_client/SimpleKafkaClient/Topic.stub', 'SimpleKafkaClient\\Topic' => 'simple_kafka_client/SimpleKafkaClient/Topic.stub', 'SimpleKafkaClient\\TopicPartition' => 'simple_kafka_client/SimpleKafkaClient/TopicPartition.stub', 'SimpleXMLElement' => 'SimpleXML/SimpleXML.stub', 'SimpleXMLIterator' => 'SimpleXML/SimpleXML.stub', 'SoapClient' => 'soap/soap.stub', 'SoapFault' => 'soap/soap.stub', 'SoapHeader' => 'soap/soap.stub', 'SoapParam' => 'soap/soap.stub', 'SoapServer' => 'soap/soap.stub', 'SoapVar' => 'soap/soap.stub', 'Soap\\Sdl' => 'soap/soap_n.stub', 'Soap\\Url' => 'soap/soap_n.stub', 'Socket' => 'sockets/sockets.stub', 'SodiumException' => 'sodium/sodium.stub', 'SolrClient' => 'solr/SolrClient.stub', 'SolrClientException' => 'solr/Exceptions/SolrClientException.stub', 'SolrCollapseFunction' => 'solr/Queries/SolrCollapseFunction.stub', 'SolrDisMaxQuery' => 'solr/Queries/SolrDisMaxQuery.stub', 'SolrDocument' => 'solr/Documents/SolrDocument.stub', 'SolrDocumentField' => 'solr/Documents/SolrDocumentField.stub', 'SolrException' => 'solr/Exceptions/SolrException.stub', 'SolrGenericResponse' => 'solr/Responses/SolrGenericResponse.stub', 'SolrIllegalArgumentException' => 'solr/Exceptions/SolrIllegalArgumentException.stub', 'SolrIllegalOperationException' => 'solr/Exceptions/SolrIllegalOperationException.stub', 'SolrInputDocument' => 'solr/Documents/SolrInputDocument.stub', 'SolrMissingMandatoryParameterException' => 'solr/Exceptions/SolrMissingMandatoryParameterException.stub', 'SolrModifiableParams' => 'solr/Queries/SolrModifiableParams.stub', 'SolrObject' => 'solr/Utils/SolrObject.stub', 'SolrParams' => 'solr/Queries/SolrParams.stub', 'SolrPingResponse' => 'solr/Responses/SolrPingResponse.stub', 'SolrQuery' => 'solr/Queries/SolrQuery.stub', 'SolrQueryResponse' => 'solr/Responses/SolrQueryResponse.stub', 'SolrResponse' => 'solr/Responses/SolrResponse.stub', 'SolrServerException' => 'solr/Exceptions/SolrServerException.stub', 'SolrUpdateResponse' => 'solr/Responses/SolrUpdateResponse.stub', 'SolrUtils' => 'solr/Utils/SolrUtils.stub', 'SplBool' => 'SplType/SplType.stub', 'SplDoublyLinkedList' => 'SPL/SPL_c1.stub', 'SplEnum' => 'SplType/SplType.stub', 'SplFileInfo' => 'SPL/SPL_c1.stub', 'SplFileObject' => 'SPL/SPL_c1.stub', 'SplFixedArray' => 'SPL/SPL_c1.stub', 'SplFloat' => 'SplType/SplType.stub', 'SplHeap' => 'SPL/SPL_c1.stub', 'SplInt' => 'SplType/SplType.stub', 'SplMaxHeap' => 'SPL/SPL_c1.stub', 'SplMinHeap' => 'SPL/SPL_c1.stub', 'SplObjectStorage' => 'SPL/SPL_c1.stub', 'SplObserver' => 'SPL/SPL_c1.stub', 'SplPriorityQueue' => 'SPL/SPL_c1.stub', 'SplQueue' => 'SPL/SPL_c1.stub', 'SplStack' => 'SPL/SPL_c1.stub', 'SplString' => 'SplType/SplType.stub', 'SplSubject' => 'SPL/SPL_c1.stub', 'SplTempFileObject' => 'SPL/SPL_c1.stub', 'SplType' => 'SplType/SplType.stub', 'Spoofchecker' => 'intl/intl.stub', 'Stomp' => 'stomp/stomp.stub', 'StompException' => 'stomp/stomp.stub', 'StompFrame' => 'stomp/stomp.stub', 'StreamBucket' => 'standard/standard_0.stub', 'Stringable' => 'Core/Core_c.stub', 'Svn' => 'svn/svn.stub', 'SvnNode' => 'svn/svn.stub', 'SvnWc' => 'svn/svn.stub', 'SvnWcSchedule' => 'svn/svn.stub', 'Swoole\\Atomic' => 'swoole/Swoole/Atomic.stub', 'Swoole\\Atomic\\Long' => 'swoole/Swoole/Atomic/Long.stub', 'Swoole\\Client' => 'swoole/Swoole/Client.stub', 'Swoole\\Client\\Exception' => 'swoole/Swoole/Client/Exception.stub', 'Swoole\\Connection\\Iterator' => 'swoole/Swoole/Connection/Iterator.stub', 'Swoole\\Coroutine' => 'swoole/Swoole/Coroutine.stub', 'Swoole\\Coroutine\\Channel' => 'swoole/Swoole/Coroutine/Channel.stub', 'Swoole\\Coroutine\\Client' => 'swoole/Swoole/Coroutine/Client.stub', 'Swoole\\Coroutine\\Context' => 'swoole/Swoole/Coroutine/Context.stub', 'Swoole\\Coroutine\\Curl\\Exception' => 'swoole/Swoole/Coroutine/Curl/Exception.stub', 'Swoole\\Coroutine\\Http2\\Client' => 'swoole/Swoole/Coroutine/Http2/Client.stub', 'Swoole\\Coroutine\\Http2\\Client\\Exception' => 'swoole/Swoole/Coroutine/Http2/Client/Exception.stub', 'Swoole\\Coroutine\\Http\\Client' => 'swoole/Swoole/Coroutine/Http/Client.stub', 'Swoole\\Coroutine\\Http\\Client\\Exception' => 'swoole/Swoole/Coroutine/Http/Client/Exception.stub', 'Swoole\\Coroutine\\Http\\Server' => 'swoole/Swoole/Coroutine/Http/Server.stub', 'Swoole\\Coroutine\\Iterator' => 'swoole/Swoole/Coroutine/Iterator.stub', 'Swoole\\Coroutine\\MySQL' => 'swoole/Swoole/Coroutine/MySQL.stub', 'Swoole\\Coroutine\\MySQL\\Exception' => 'swoole/Swoole/Coroutine/MySQL/Exception.stub', 'Swoole\\Coroutine\\MySQL\\Statement' => 'swoole/Swoole/Coroutine/MySQL/Statement.stub', 'Swoole\\Coroutine\\Redis' => 'swoole/Swoole/Coroutine/Redis.stub', 'Swoole\\Coroutine\\Scheduler' => 'swoole/Swoole/Coroutine/Scheduler.stub', 'Swoole\\Coroutine\\Socket' => 'swoole/Swoole/Coroutine/Socket.stub', 'Swoole\\Coroutine\\Socket\\Exception' => 'swoole/Swoole/Coroutine/Socket/Exception.stub', 'Swoole\\Coroutine\\System' => 'swoole/Swoole/Coroutine/System.stub', 'Swoole\\Error' => 'swoole/Swoole/Error.stub', 'Swoole\\Event' => 'swoole/Swoole/Event.stub', 'Swoole\\Exception' => 'swoole/Swoole/Exception.stub', 'Swoole\\ExitException' => 'swoole/Swoole/ExitException.stub', 'Swoole\\Http2\\Request' => 'swoole/Swoole/Http2/Request.stub', 'Swoole\\Http2\\Response' => 'swoole/Swoole/Http2/Response.stub', 'Swoole\\Http\\Request' => 'swoole/Swoole/Http/Request.stub', 'Swoole\\Http\\Response' => 'swoole/Swoole/Http/Response.stub', 'Swoole\\Http\\Server' => 'swoole/Swoole/Http/Server.stub', 'Swoole\\Lock' => 'swoole/Swoole/Lock.stub', 'Swoole\\Process' => 'swoole/Swoole/Process.stub', 'Swoole\\Process\\Pool' => 'swoole/Swoole/Process/Pool.stub', 'Swoole\\Redis\\Server' => 'swoole/Swoole/Redis/Server.stub', 'Swoole\\Runtime' => 'swoole/Swoole/Runtime.stub', 'Swoole\\Server' => 'swoole/Swoole/Server.stub', 'Swoole\\Server\\Event' => 'swoole/Swoole/Server/Event.stub', 'Swoole\\Server\\Packet' => 'swoole/Swoole/Server/Packet.stub', 'Swoole\\Server\\PipeMessage' => 'swoole/Swoole/Server/PipeMessage.stub', 'Swoole\\Server\\Port' => 'swoole/Swoole/Server/Port.stub', 'Swoole\\Server\\StatusInfo' => 'swoole/Swoole/Server/StatusInfo.stub', 'Swoole\\Server\\Task' => 'swoole/Swoole/Server/Task.stub', 'Swoole\\Server\\TaskResult' => 'swoole/Swoole/Server/TaskResult.stub', 'Swoole\\Table' => 'swoole/Swoole/Table.stub', 'Swoole\\Timer' => 'swoole/Swoole/Timer.stub', 'Swoole\\Timer\\Iterator' => 'swoole/Swoole/Timer/Iterator.stub', 'Swoole\\WebSocket\\CloseFrame' => 'swoole/Swoole/WebSocket/CloseFrame.stub', 'Swoole\\WebSocket\\Frame' => 'swoole/Swoole/WebSocket/Frame.stub', 'Swoole\\WebSocket\\Server' => 'swoole/Swoole/WebSocket/Server.stub', 'SyncEvent' => 'sync/sync.stub', 'SyncMutex' => 'sync/sync.stub', 'SyncReaderWriter' => 'sync/sync.stub', 'SyncSemaphore' => 'sync/sync.stub', 'SyncSharedMemory' => 'sync/sync.stub', 'SysvMessageQueue' => 'sysvmsg/sysvmsg.stub', 'SysvSemaphore' => 'sysvsem/sysvsem.stub', 'SysvSharedMemory' => 'sysvshm/sysvshm.stub', 'Thread' => 'pthreads/pthreads.stub', 'Threaded' => 'pthreads/pthreads.stub', 'Throwable' => 'Core/Core_c.stub', 'Transliterator' => 'intl/intl.stub', 'Traversable' => 'Core/Core_c.stub', 'TypeError' => 'Core/Core_c.stub', 'UConverter' => 'intl/intl.stub', 'UV' => 'uv/UV.stub', 'UVAddrinfo' => 'uv/UV.stub', 'UVAsync' => 'uv/UV.stub', 'UVCheck' => 'uv/UV.stub', 'UVFs' => 'uv/UV.stub', 'UVFsEvent' => 'uv/UV.stub', 'UVFsPoll' => 'uv/UV.stub', 'UVIdle' => 'uv/UV.stub', 'UVLock' => 'uv/UV.stub', 'UVLoop' => 'uv/UV.stub', 'UVPipe' => 'uv/UV.stub', 'UVPoll' => 'uv/UV.stub', 'UVPrepare' => 'uv/UV.stub', 'UVProcess' => 'uv/UV.stub', 'UVSignal' => 'uv/UV.stub', 'UVSockAddr' => 'uv/UV.stub', 'UVSockAddrIPv4' => 'uv/UV.stub', 'UVSockAddrIPv6' => 'uv/UV.stub', 'UVStdio' => 'uv/UV.stub', 'UVStream' => 'uv/UV.stub', 'UVTcp' => 'uv/UV.stub', 'UVTimer' => 'uv/UV.stub', 'UVTty' => 'uv/UV.stub', 'UVUdp' => 'uv/UV.stub', 'UVWork' => 'uv/UV.stub', 'UnderflowException' => 'SPL/SPL.stub', 'UnexpectedValueException' => 'SPL/SPL.stub', 'UnhandledMatchError' => 'Core/Core_c.stub', 'UnitEnum' => 'Core/Core_c.stub', 'V8Js' => 'v8js/v8js.stub', 'V8JsMemoryLimitException' => 'v8js/v8js.stub', 'V8JsScriptException' => 'v8js/v8js.stub', 'V8JsTimeLimitException' => 'v8js/v8js.stub', 'VARIANT' => 'com_dotnet/com_dotnet.stub', 'ValueError' => 'Core/Core_c.stub', 'Volatile' => 'pthreads/pthreads.stub', 'Vtiful\\Kernel\\Excel' => 'xlswriter/xlswriter.stub', 'Vtiful\\Kernel\\Format' => 'xlswriter/xlswriter.stub', 'WeakMap' => 'Core/Core_c.stub', 'WeakReference' => 'Core/Core_c.stub', 'Worker' => 'pthreads/pthreads.stub', 'XMLParser' => 'xml/xml.stub', 'XMLReader' => 'xmlreader/xmlreader.stub', 'XMLWriter' => 'xmlwriter/xmlwriter.stub', 'XSLTProcessor' => 'xsl/xsl.stub', 'XXTEA' => 'xxtea/xxtea.stub', 'Yaf\\Action_Abstract' => 'yaf/yaf_namespace.stub', 'Yaf\\Application' => 'yaf/yaf_namespace.stub', 'Yaf\\Bootstrap_Abstract' => 'yaf/yaf_namespace.stub', 'Yaf\\Config\\Ini' => 'yaf/yaf_namespace.stub', 'Yaf\\Config\\Simple' => 'yaf/yaf_namespace.stub', 'Yaf\\Config_Abstract' => 'yaf/yaf_namespace.stub', 'Yaf\\Controller_Abstract' => 'yaf/yaf_namespace.stub', 'Yaf\\Dispatcher' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\DispatchFailed' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\LoadFailed' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\LoadFailed\\Action' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\LoadFailed\\Controller' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\LoadFailed\\Module' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\LoadFailed\\View' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\RouterFailed' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\StartupError' => 'yaf/yaf_namespace.stub', 'Yaf\\Exception\\TypeError' => 'yaf/yaf_namespace.stub', 'Yaf\\Loader' => 'yaf/yaf_namespace.stub', 'Yaf\\Plugin_Abstract' => 'yaf/yaf_namespace.stub', 'Yaf\\Registry' => 'yaf/yaf_namespace.stub', 'Yaf\\Request\\Http' => 'yaf/yaf_namespace.stub', 'Yaf\\Request\\Simple' => 'yaf/yaf_namespace.stub', 'Yaf\\Request_Abstract' => 'yaf/yaf_namespace.stub', 'Yaf\\Response\\Cli' => 'yaf/yaf_namespace.stub', 'Yaf\\Response\\Http' => 'yaf/yaf_namespace.stub', 'Yaf\\Response_Abstract' => 'yaf/yaf_namespace.stub', 'Yaf\\Route\\Map' => 'yaf/yaf_namespace.stub', 'Yaf\\Route\\Regex' => 'yaf/yaf_namespace.stub', 'Yaf\\Route\\Rewrite' => 'yaf/yaf_namespace.stub', 'Yaf\\Route\\Simple' => 'yaf/yaf_namespace.stub', 'Yaf\\Route\\Supervar' => 'yaf/yaf_namespace.stub', 'Yaf\\Route_Interface' => 'yaf/yaf_namespace.stub', 'Yaf\\Route_Static' => 'yaf/yaf_namespace.stub', 'Yaf\\Router' => 'yaf/yaf_namespace.stub', 'Yaf\\Session' => 'yaf/yaf_namespace.stub', 'Yaf\\View\\Simple' => 'yaf/yaf_namespace.stub', 'Yaf\\View_Interface' => 'yaf/yaf_namespace.stub', 'Yaf_Action_Abstract' => 'yaf/yaf.stub', 'Yaf_Application' => 'yaf/yaf.stub', 'Yaf_Bootstrap_Abstract' => 'yaf/yaf.stub', 'Yaf_Config_Abstract' => 'yaf/yaf.stub', 'Yaf_Config_Ini' => 'yaf/yaf.stub', 'Yaf_Config_Simple' => 'yaf/yaf.stub', 'Yaf_Controller_Abstract' => 'yaf/yaf.stub', 'Yaf_Dispatcher' => 'yaf/yaf.stub', 'Yaf_Exception' => 'yaf/yaf.stub', 'Yaf_Exception_DispatchFailed' => 'yaf/yaf.stub', 'Yaf_Exception_LoadFailed' => 'yaf/yaf.stub', 'Yaf_Exception_LoadFailed_Action' => 'yaf/yaf.stub', 'Yaf_Exception_LoadFailed_Controller' => 'yaf/yaf.stub', 'Yaf_Exception_LoadFailed_Module' => 'yaf/yaf.stub', 'Yaf_Exception_LoadFailed_View' => 'yaf/yaf.stub', 'Yaf_Exception_RouterFailed' => 'yaf/yaf.stub', 'Yaf_Exception_StartupError' => 'yaf/yaf.stub', 'Yaf_Exception_TypeError' => 'yaf/yaf.stub', 'Yaf_Loader' => 'yaf/yaf.stub', 'Yaf_Plugin_Abstract' => 'yaf/yaf.stub', 'Yaf_Registry' => 'yaf/yaf.stub', 'Yaf_Request_Abstract' => 'yaf/yaf.stub', 'Yaf_Request_Http' => 'yaf/yaf.stub', 'Yaf_Request_Simple' => 'yaf/yaf.stub', 'Yaf_Response_Abstract' => 'yaf/yaf.stub', 'Yaf_Response_Cli' => 'yaf/yaf.stub', 'Yaf_Response_Http' => 'yaf/yaf.stub', 'Yaf_Route_Interface' => 'yaf/yaf.stub', 'Yaf_Route_Map' => 'yaf/yaf.stub', 'Yaf_Route_Regex' => 'yaf/yaf.stub', 'Yaf_Route_Rewrite' => 'yaf/yaf.stub', 'Yaf_Route_Simple' => 'yaf/yaf.stub', 'Yaf_Route_Static' => 'yaf/yaf.stub', 'Yaf_Route_Supervar' => 'yaf/yaf.stub', 'Yaf_Router' => 'yaf/yaf.stub', 'Yaf_Session' => 'yaf/yaf.stub', 'Yaf_View_Interface' => 'yaf/yaf.stub', 'Yaf_View_Simple' => 'yaf/yaf.stub', 'Yar_Client' => 'yar/yar.stub', 'Yar_Client_Exception' => 'yar/yar.stub', 'Yar_Client_Packager_Exception' => 'yar/yar.stub', 'Yar_Client_Protocol_Exception' => 'yar/yar.stub', 'Yar_Client_Transport_Exception' => 'yar/yar.stub', 'Yar_Concurrent_Client' => 'yar/yar.stub', 'Yar_Server' => 'yar/yar.stub', 'Yar_Server_Exception' => 'yar/yar.stub', 'Yar_Server_Output_Exception' => 'yar/yar.stub', 'Yar_Server_Packager_Exception' => 'yar/yar.stub', 'Yar_Server_Protocol_Exception' => 'yar/yar.stub', 'Yar_Server_Request_Exception' => 'yar/yar.stub', 'ZMQ' => 'zmq/zmq.stub', 'ZMQContext' => 'zmq/zmq.stub', 'ZMQContextException' => 'zmq/zmq.stub', 'ZMQDevice' => 'zmq/zmq.stub', 'ZMQDeviceException' => 'zmq/zmq.stub', 'ZMQException' => 'zmq/zmq.stub', 'ZMQPoll' => 'zmq/zmq.stub', 'ZMQPollException' => 'zmq/zmq.stub', 'ZMQSocket' => 'zmq/zmq.stub', 'ZMQSocketException' => 'zmq/zmq.stub', 'ZendAPI_Job' => 'zend/zend.stub', 'ZendAPI_Queue' => 'zend/zend.stub', 'ZipArchive' => 'zip/zip.stub', 'Zookeeper' => 'zookeeper/zookeeper.stub', 'ZookeeperAuthenticationException' => 'zookeeper/zookeeper.stub', 'ZookeeperConnectionException' => 'zookeeper/zookeeper.stub', 'ZookeeperException' => 'zookeeper/zookeeper.stub', 'ZookeeperMarshallingException' => 'zookeeper/zookeeper.stub', 'ZookeeperNoNodeException' => 'zookeeper/zookeeper.stub', 'ZookeeperOperationTimeoutException' => 'zookeeper/zookeeper.stub', 'ZookeeperSessionException' => 'zookeeper/zookeeper.stub', '__PHP_Incomplete_Class' => 'standard/standard_0.stub', '___PHPSTORM_HELPERS\\PS_UNRESERVE_PREFIX_static' => 'standard/_types.stub', '___PHPSTORM_HELPERS\\PS_UNRESERVE_PREFIX_this' => 'standard/_types.stub', '___PHPSTORM_HELPERS\\object' => 'standard/_types.stub', 'ast\\Metadata' => 'ast/ast.stub', 'ast\\Node' => 'ast/ast.stub', 'classObj' => 'mapscript/mapscript.stub', 'clusterObj' => 'mapscript/mapscript.stub', 'colorObj' => 'mapscript/mapscript.stub', 'com_exception' => 'com_dotnet/com_dotnet.stub', 'errorObj' => 'mapscript/mapscript.stub', 'ffmpeg_animated_gif' => 'ffmpeg/ffmpeg.stub', 'ffmpeg_frame' => 'ffmpeg/ffmpeg.stub', 'ffmpeg_movie' => 'ffmpeg/ffmpeg.stub', 'finfo' => 'fileinfo/fileinfo.stub', 'gnupg' => 'gnupg/gnupg.stub', 'gnupg_keylistiterator' => 'gnupg/gnupg.stub', 'gridObj' => 'mapscript/mapscript.stub', 'hashTableObj' => 'mapscript/mapscript.stub', 'http\\Client' => 'http/http3.stub', 'http\\Client\\Curl\\User' => 'http/http3.stub', 'http\\Client\\Request' => 'http/http3.stub', 'http\\Client\\Response' => 'http/http3.stub', 'http\\Cookie' => 'http/http3.stub', 'http\\Encoding\\Stream' => 'http/http3.stub', 'http\\Encoding\\Stream\\Debrotli' => 'http/http3.stub', 'http\\Encoding\\Stream\\Dechunk' => 'http/http3.stub', 'http\\Encoding\\Stream\\Deflate' => 'http/http3.stub', 'http\\Encoding\\Stream\\Enbrotli' => 'http/http3.stub', 'http\\Encoding\\Stream\\Inflate' => 'http/http3.stub', 'http\\Env' => 'http/http3.stub', 'http\\Env\\Request' => 'http/http3.stub', 'http\\Env\\Response' => 'http/http3.stub', 'http\\Env\\Url' => 'http/http3.stub', 'http\\Exception' => 'http/http3.stub', 'http\\Exception\\BadConversionException' => 'http/http3.stub', 'http\\Exception\\BadHeaderException' => 'http/http3.stub', 'http\\Exception\\BadMessageException' => 'http/http3.stub', 'http\\Exception\\BadMethodCallException' => 'http/http3.stub', 'http\\Exception\\BadQueryStringException' => 'http/http3.stub', 'http\\Exception\\BadUrlException' => 'http/http3.stub', 'http\\Exception\\InvalidArgumentException' => 'http/http3.stub', 'http\\Exception\\RuntimeException' => 'http/http3.stub', 'http\\Exception\\UnexpectedValueException' => 'http/http3.stub', 'http\\Header' => 'http/http3.stub', 'http\\Header\\Parser' => 'http/http3.stub', 'http\\Message' => 'http/http3.stub', 'http\\Message\\Body' => 'http/http3.stub', 'http\\Message\\Parser' => 'http/http3.stub', 'http\\Params' => 'http/http3.stub', 'http\\QueryString' => 'http/http3.stub', 'http\\Url' => 'http/http3.stub', 'imageObj' => 'mapscript/mapscript.stub', 'iterable' => 'Core/Core_c.stub', 'java' => 'zend/zend.stub', 'labelObj' => 'mapscript/mapscript.stub', 'labelcacheMemberObj' => 'mapscript/mapscript.stub', 'labelcacheObj' => 'mapscript/mapscript.stub', 'layerObj' => 'mapscript/mapscript.stub', 'legendObj' => 'mapscript/mapscript.stub', 'lineObj' => 'mapscript/mapscript.stub', 'mapObj' => 'mapscript/mapscript.stub', 'mysql_xdevapi\\BaseResult' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Collection' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CollectionAdd' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CollectionFind' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CollectionModify' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CollectionRemove' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\ColumnResult' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CrudOperationBindable' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CrudOperationLimitable' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CrudOperationSkippable' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\CrudOperationSortable' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\DatabaseObject' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\DocResult' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Exception' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Executable' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\ExecutionStatus' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Expression' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Result' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\RowResult' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Schema' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\SchemaObject' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Session' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\SqlStatement' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\SqlStatementResult' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Statement' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Table' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\TableDelete' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\TableInsert' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\TableSelect' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\TableUpdate' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\Warning' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\XSession' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysqli' => 'mysqli/mysqli.stub', 'mysqli_driver' => 'mysqli/mysqli.stub', 'mysqli_result' => 'mysqli/mysqli.stub', 'mysqli_sql_exception' => 'mysqli/mysqli.stub', 'mysqli_stmt' => 'mysqli/mysqli.stub', 'mysqli_warning' => 'mysqli/mysqli.stub', 'newrelic\\DistributedTracePayload' => 'newrelic/newrelic.stub', 'outputformatObj' => 'mapscript/mapscript.stub', 'parallel\\Channel' => 'parallel/parallel/Channel.stub', 'parallel\\Channel\\Error' => 'parallel/parallel/Channel/Error.stub', 'parallel\\Channel\\Error\\Closed' => 'parallel/parallel/Channel/Error/Closed.stub', 'parallel\\Channel\\Error\\Existence' => 'parallel/parallel/Channel/Error/Existence.stub', 'parallel\\Channel\\Error\\IllegalValue' => 'parallel/parallel/Channel/Error/IllegalValue.stub', 'parallel\\Error' => 'parallel/parallel/Error.stub', 'parallel\\Events' => 'parallel/parallel/Events.stub', 'parallel\\Events\\Error' => 'parallel/parallel/Events/Error.stub', 'parallel\\Events\\Error\\Existence' => 'parallel/parallel/Events/Error/Existence.stub', 'parallel\\Events\\Error\\Timeout' => 'parallel/parallel/Events/Error/Timeout.stub', 'parallel\\Events\\Event' => 'parallel/parallel/Events/Event.stub', 'parallel\\Events\\Event\\Error' => 'parallel/parallel/Events/Event/Error.stub', 'parallel\\Events\\Event\\Type' => 'parallel/parallel/Events/Event/Type.stub', 'parallel\\Events\\Input' => 'parallel/parallel/Events/Input.stub', 'parallel\\Events\\Input\\Error' => 'parallel/parallel/Events/Input/Error.stub', 'parallel\\Events\\Input\\Error\\Existence' => 'parallel/parallel/Events/Input/Error/Existence.stub', 'parallel\\Events\\Input\\Error\\IllegalValue' => 'parallel/parallel/Events/Input/Error/IllegalValue.stub', 'parallel\\Future' => 'parallel/parallel/Future.stub', 'parallel\\Future\\Error' => 'parallel/parallel/Future/Error.stub', 'parallel\\Future\\Error\\Cancelled' => 'parallel/parallel/Future/Error/Cancelled.stub', 'parallel\\Future\\Error\\Foreign' => 'parallel/parallel/Future/Error/Foreign.stub', 'parallel\\Future\\Error\\Killed' => 'parallel/parallel/Future/Error/Killed.stub', 'parallel\\Runtime' => 'parallel/parallel/Runtime.stub', 'parallel\\Runtime\\Error' => 'parallel/parallel/Runtime/Error.stub', 'parallel\\Runtime\\Error\\Bootstrap' => 'parallel/parallel/Runtime/Error/Bootstrap.stub', 'parallel\\Runtime\\Error\\Closed' => 'parallel/parallel/Runtime/Error/Closed.stub', 'parallel\\Runtime\\Error\\IllegalFunction' => 'parallel/parallel/Runtime/Error/IllegalFunction.stub', 'parallel\\Runtime\\Error\\IllegalInstruction' => 'parallel/parallel/Runtime/Error/IllegalInstruction.stub', 'parallel\\Runtime\\Error\\IllegalParameter' => 'parallel/parallel/Runtime/Error/IllegalParameter.stub', 'parallel\\Runtime\\Error\\IllegalReturn' => 'parallel/parallel/Runtime/Error/IllegalReturn.stub', 'parallel\\Runtime\\Error\\IllegalVariable' => 'parallel/parallel/Runtime/Error/IllegalVariable.stub', 'parallel\\Runtime\\Error\\Killed' => 'parallel/parallel/Runtime/Error/Killed.stub', 'parallel\\Runtime\\Object\\Unavailable' => 'parallel/parallel/Runtime/Object/Unavailable.stub', 'parallel\\Runtime\\Type\\Unavailable' => 'parallel/parallel/Runtime/Type/Unavailable.stub', 'parallel\\Sync' => 'parallel/parallel/Sync.stub', 'parallel\\Sync\\Error' => 'parallel/parallel/Sync/Error.stub', 'parallel\\Sync\\Error\\IllegalValue' => 'parallel/parallel/Sync/Error/IllegalValue.stub', 'php_user_filter' => 'standard/standard_0.stub', 'pointObj' => 'mapscript/mapscript.stub', 'pq\\COPY' => 'pq/pq.stub', 'pq\\Cancel' => 'pq/pq.stub', 'pq\\Connection' => 'pq/pq.stub', 'pq\\Converter' => 'pq/pq.stub', 'pq\\Cursor' => 'pq/pq.stub', 'pq\\DateTime' => 'pq/pq.stub', 'pq\\Exception' => 'pq/pq.stub', 'pq\\Exception\\BadMethodCallException' => 'pq/pq.stub', 'pq\\Exception\\DomainException' => 'pq/pq.stub', 'pq\\Exception\\InvalidArgumentException' => 'pq/pq.stub', 'pq\\Exception\\RuntimeException' => 'pq/pq.stub', 'pq\\LOB' => 'pq/pq.stub', 'pq\\Result' => 'pq/pq.stub', 'pq\\Statement' => 'pq/pq.stub', 'pq\\Transaction' => 'pq/pq.stub', 'pq\\Types' => 'pq/pq.stub', 'projectionObj' => 'mapscript/mapscript.stub', 'querymapObj' => 'mapscript/mapscript.stub', 'rectObj' => 'mapscript/mapscript.stub', 'referenceMapObj' => 'mapscript/mapscript.stub', 'resultObj' => 'mapscript/mapscript.stub', 'scalebarObj' => 'mapscript/mapscript.stub', 'shapeObj' => 'mapscript/mapscript.stub', 'shapefileObj' => 'mapscript/mapscript.stub', 'stdClass' => 'Core/Core_c.stub', 'styleObj' => 'mapscript/mapscript.stub', 'symbolObj' => 'mapscript/mapscript.stub', 'tidy' => 'tidy/tidy.stub', 'tidyNode' => 'tidy/tidy.stub', 'webObj' => 'mapscript/mapscript.stub');
    const FUNCTIONS = array('Brotli\\compress' => 'brotli/brotli.stub', 'Brotli\\compress_add' => 'brotli/brotli.stub', 'Brotli\\compress_init' => 'brotli/brotli.stub', 'Brotli\\uncompress' => 'brotli/brotli.stub', 'Brotli\\uncompress_add' => 'brotli/brotli.stub', 'Brotli\\uncompress_init' => 'brotli/brotli.stub', 'Dom\\import_simplexml' => 'dom/dom_n.stub', 'GEOSLineMerge' => 'geos/geos.stub', 'GEOSPolygonize' => 'geos/geos.stub', 'GEOSRelateMatch' => 'geos/geos.stub', 'GEOSSharedPaths' => 'geos/geos.stub', 'GEOSVersion' => 'geos/geos.stub', 'MongoDB\\BSON\\fromJSON' => 'mongodb/BSON/functions.stub', 'MongoDB\\BSON\\fromPHP' => 'mongodb/BSON/functions.stub', 'MongoDB\\BSON\\toCanonicalExtendedJSON' => 'mongodb/BSON/functions.stub', 'MongoDB\\BSON\\toJSON' => 'mongodb/BSON/functions.stub', 'MongoDB\\BSON\\toPHP' => 'mongodb/BSON/functions.stub', 'MongoDB\\BSON\\toRelaxedExtendedJSON' => 'mongodb/BSON/functions.stub', 'MongoDB\\Driver\\Monitoring\\addSubscriber' => 'mongodb/Monitoring/functions.stub', 'MongoDB\\Driver\\Monitoring\\removeSubscriber' => 'mongodb/Monitoring/functions.stub', 'OpenTelemetry\\Instrumentation\\hook' => 'opentelemetry/opentelemetry.stub', 'PDF_activate_item' => 'pdflib/PDFlib.stub', 'PDF_add_launchlink' => 'pdflib/PDFlib.stub', 'PDF_add_locallink' => 'pdflib/PDFlib.stub', 'PDF_add_nameddest' => 'pdflib/PDFlib.stub', 'PDF_add_note' => 'pdflib/PDFlib.stub', 'PDF_add_pdflink' => 'pdflib/PDFlib.stub', 'PDF_add_table_cell' => 'pdflib/PDFlib.stub', 'PDF_add_textflow' => 'pdflib/PDFlib.stub', 'PDF_add_thumbnail' => 'pdflib/PDFlib.stub', 'PDF_add_weblink' => 'pdflib/PDFlib.stub', 'PDF_arc' => 'pdflib/PDFlib.stub', 'PDF_arcn' => 'pdflib/PDFlib.stub', 'PDF_attach_file' => 'pdflib/PDFlib.stub', 'PDF_begin_document' => 'pdflib/PDFlib.stub', 'PDF_begin_font' => 'pdflib/PDFlib.stub', 'PDF_begin_glyph' => 'pdflib/PDFlib.stub', 'PDF_begin_item' => 'pdflib/PDFlib.stub', 'PDF_begin_layer' => 'pdflib/PDFlib.stub', 'PDF_begin_page' => 'pdflib/PDFlib.stub', 'PDF_begin_page_ext' => 'pdflib/PDFlib.stub', 'PDF_begin_pattern' => 'pdflib/PDFlib.stub', 'PDF_begin_template' => 'pdflib/PDFlib.stub', 'PDF_begin_template_ext' => 'pdflib/PDFlib.stub', 'PDF_circle' => 'pdflib/PDFlib.stub', 'PDF_clip' => 'pdflib/PDFlib.stub', 'PDF_close' => 'pdflib/PDFlib.stub', 'PDF_close_image' => 'pdflib/PDFlib.stub', 'PDF_close_pdi' => 'pdflib/PDFlib.stub', 'PDF_close_pdi_document' => 'pdflib/PDFlib.stub', 'PDF_close_pdi_page' => 'pdflib/PDFlib.stub', 'PDF_closepath' => 'pdflib/PDFlib.stub', 'PDF_closepath_fill_stroke' => 'pdflib/PDFlib.stub', 'PDF_closepath_stroke' => 'pdflib/PDFlib.stub', 'PDF_concat' => 'pdflib/PDFlib.stub', 'PDF_continue_text' => 'pdflib/PDFlib.stub', 'PDF_create_3dview' => 'pdflib/PDFlib.stub', 'PDF_create_action' => 'pdflib/PDFlib.stub', 'PDF_create_annotation' => 'pdflib/PDFlib.stub', 'PDF_create_bookmark' => 'pdflib/PDFlib.stub', 'PDF_create_field' => 'pdflib/PDFlib.stub', 'PDF_create_fieldgroup' => 'pdflib/PDFlib.stub', 'PDF_create_gstate' => 'pdflib/PDFlib.stub', 'PDF_create_pvf' => 'pdflib/PDFlib.stub', 'PDF_create_textflow' => 'pdflib/PDFlib.stub', 'PDF_curveto' => 'pdflib/PDFlib.stub', 'PDF_define_layer' => 'pdflib/PDFlib.stub', 'PDF_delete' => 'pdflib/PDFlib.stub', 'PDF_delete_pvf' => 'pdflib/PDFlib.stub', 'PDF_delete_table' => 'pdflib/PDFlib.stub', 'PDF_delete_textflow' => 'pdflib/PDFlib.stub', 'PDF_encoding_set_char' => 'pdflib/PDFlib.stub', 'PDF_end_document' => 'pdflib/PDFlib.stub', 'PDF_end_font' => 'pdflib/PDFlib.stub', 'PDF_end_glyph' => 'pdflib/PDFlib.stub', 'PDF_end_item' => 'pdflib/PDFlib.stub', 'PDF_end_layer' => 'pdflib/PDFlib.stub', 'PDF_end_page' => 'pdflib/PDFlib.stub', 'PDF_end_page_ext' => 'pdflib/PDFlib.stub', 'PDF_end_pattern' => 'pdflib/PDFlib.stub', 'PDF_end_template' => 'pdflib/PDFlib.stub', 'PDF_endpath' => 'pdflib/PDFlib.stub', 'PDF_fill' => 'pdflib/PDFlib.stub', 'PDF_fill_imageblock' => 'pdflib/PDFlib.stub', 'PDF_fill_pdfblock' => 'pdflib/PDFlib.stub', 'PDF_fill_stroke' => 'pdflib/PDFlib.stub', 'PDF_fill_textblock' => 'pdflib/PDFlib.stub', 'PDF_findfont' => 'pdflib/PDFlib.stub', 'PDF_fit_image' => 'pdflib/PDFlib.stub', 'PDF_fit_pdi_page' => 'pdflib/PDFlib.stub', 'PDF_fit_table' => 'pdflib/PDFlib.stub', 'PDF_fit_textflow' => 'pdflib/PDFlib.stub', 'PDF_fit_textline' => 'pdflib/PDFlib.stub', 'PDF_get_apiname' => 'pdflib/PDFlib.stub', 'PDF_get_buffer' => 'pdflib/PDFlib.stub', 'PDF_get_errmsg' => 'pdflib/PDFlib.stub', 'PDF_get_errnum' => 'pdflib/PDFlib.stub', 'PDF_get_majorversion' => 'pdflib/PDFlib.stub', 'PDF_get_minorversion' => 'pdflib/PDFlib.stub', 'PDF_get_option' => 'pdflib/PDFlib.stub', 'PDF_get_parameter' => 'pdflib/PDFlib.stub', 'PDF_get_pdi_parameter' => 'pdflib/PDFlib.stub', 'PDF_get_pdi_value' => 'pdflib/PDFlib.stub', 'PDF_get_string' => 'pdflib/PDFlib.stub', 'PDF_get_value' => 'pdflib/PDFlib.stub', 'PDF_info_font' => 'pdflib/PDFlib.stub', 'PDF_info_graphics' => 'pdflib/PDFlib.stub', 'PDF_info_image' => 'pdflib/PDFlib.stub', 'PDF_info_matchbox' => 'pdflib/PDFlib.stub', 'PDF_info_path' => 'pdflib/PDFlib.stub', 'PDF_info_pdi_page' => 'pdflib/PDFlib.stub', 'PDF_info_pvf' => 'pdflib/PDFlib.stub', 'PDF_info_table' => 'pdflib/PDFlib.stub', 'PDF_info_textflow' => 'pdflib/PDFlib.stub', 'PDF_info_textline' => 'pdflib/PDFlib.stub', 'PDF_initgraphics' => 'pdflib/PDFlib.stub', 'PDF_lineto' => 'pdflib/PDFlib.stub', 'PDF_load_3ddata' => 'pdflib/PDFlib.stub', 'PDF_load_font' => 'pdflib/PDFlib.stub', 'PDF_load_iccprofile' => 'pdflib/PDFlib.stub', 'PDF_load_image' => 'pdflib/PDFlib.stub', 'PDF_makespotcolor' => 'pdflib/PDFlib.stub', 'PDF_moveto' => 'pdflib/PDFlib.stub', 'PDF_new' => 'pdflib/PDFlib.stub', 'PDF_open_ccitt' => 'pdflib/PDFlib.stub', 'PDF_open_file' => 'pdflib/PDFlib.stub', 'PDF_open_image' => 'pdflib/PDFlib.stub', 'PDF_open_image_file' => 'pdflib/PDFlib.stub', 'PDF_open_memory_image' => 'pdflib/PDFlib.stub', 'PDF_open_pdi' => 'pdflib/PDFlib.stub', 'PDF_open_pdi_document' => 'pdflib/PDFlib.stub', 'PDF_open_pdi_page' => 'pdflib/PDFlib.stub', 'PDF_pcos_get_number' => 'pdflib/PDFlib.stub', 'PDF_pcos_get_stream' => 'pdflib/PDFlib.stub', 'PDF_pcos_get_string' => 'pdflib/PDFlib.stub', 'PDF_place_image' => 'pdflib/PDFlib.stub', 'PDF_place_pdi_page' => 'pdflib/PDFlib.stub', 'PDF_process_pdi' => 'pdflib/PDFlib.stub', 'PDF_rect' => 'pdflib/PDFlib.stub', 'PDF_restore' => 'pdflib/PDFlib.stub', 'PDF_resume_page' => 'pdflib/PDFlib.stub', 'PDF_rotate' => 'pdflib/PDFlib.stub', 'PDF_save' => 'pdflib/PDFlib.stub', 'PDF_scale' => 'pdflib/PDFlib.stub', 'PDF_set_border_color' => 'pdflib/PDFlib.stub', 'PDF_set_border_dash' => 'pdflib/PDFlib.stub', 'PDF_set_border_style' => 'pdflib/PDFlib.stub', 'PDF_set_gstate' => 'pdflib/PDFlib.stub', 'PDF_set_info' => 'pdflib/PDFlib.stub', 'PDF_set_layer_dependency' => 'pdflib/PDFlib.stub', 'PDF_set_option' => 'pdflib/PDFlib.stub', 'PDF_set_parameter' => 'pdflib/PDFlib.stub', 'PDF_set_text_option' => 'pdflib/PDFlib.stub', 'PDF_set_text_pos' => 'pdflib/PDFlib.stub', 'PDF_set_value' => 'pdflib/PDFlib.stub', 'PDF_setcolor' => 'pdflib/PDFlib.stub', 'PDF_setdash' => 'pdflib/PDFlib.stub', 'PDF_setdashpattern' => 'pdflib/PDFlib.stub', 'PDF_setflat' => 'pdflib/PDFlib.stub', 'PDF_setfont' => 'pdflib/PDFlib.stub', 'PDF_setgray' => 'pdflib/PDFlib.stub', 'PDF_setgray_fill' => 'pdflib/PDFlib.stub', 'PDF_setgray_stroke' => 'pdflib/PDFlib.stub', 'PDF_setlinecap' => 'pdflib/PDFlib.stub', 'PDF_setlinejoin' => 'pdflib/PDFlib.stub', 'PDF_setlinewidth' => 'pdflib/PDFlib.stub', 'PDF_setmatrix' => 'pdflib/PDFlib.stub', 'PDF_setmiterlimit' => 'pdflib/PDFlib.stub', 'PDF_setrgbcolor' => 'pdflib/PDFlib.stub', 'PDF_setrgbcolor_fill' => 'pdflib/PDFlib.stub', 'PDF_setrgbcolor_stroke' => 'pdflib/PDFlib.stub', 'PDF_shading' => 'pdflib/PDFlib.stub', 'PDF_shading_pattern' => 'pdflib/PDFlib.stub', 'PDF_shfill' => 'pdflib/PDFlib.stub', 'PDF_show' => 'pdflib/PDFlib.stub', 'PDF_show_boxed' => 'pdflib/PDFlib.stub', 'PDF_show_xy' => 'pdflib/PDFlib.stub', 'PDF_skew' => 'pdflib/PDFlib.stub', 'PDF_stringwidth' => 'pdflib/PDFlib.stub', 'PDF_stroke' => 'pdflib/PDFlib.stub', 'PDF_suspend_page' => 'pdflib/PDFlib.stub', 'PDF_translate' => 'pdflib/PDFlib.stub', 'PDF_utf16_to_utf8' => 'pdflib/PDFlib.stub', 'PDF_utf32_to_utf16' => 'pdflib/PDFlib.stub', 'PDF_utf8_to_utf16' => 'pdflib/PDFlib.stub', 'PS_UNRESERVE_PREFIX___halt_compiler' => 'standard/_standard_manual.stub', 'PS_UNRESERVE_PREFIX_array' => 'standard/_types.stub', 'PS_UNRESERVE_PREFIX_die' => 'standard/_types.stub', 'PS_UNRESERVE_PREFIX_empty' => 'standard/_types.stub', 'PS_UNRESERVE_PREFIX_eval' => 'standard/_types.stub', 'PS_UNRESERVE_PREFIX_exit' => 'standard/_types.stub', 'PS_UNRESERVE_PREFIX_isset' => 'standard/_types.stub', 'PS_UNRESERVE_PREFIX_list' => 'standard/_types.stub', 'PS_UNRESERVE_PREFIX_unset' => 'standard/_types.stub', 'SQLSRV_PHPTYPE_STREAM' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PHPTYPE_STRING' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_BINARY' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_CHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_DECIMAL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_NCHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_NUMERIC' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_NVARCHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_VARBINARY' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_VARCHAR' => 'sqlsrv/sqlsrv.stub', 'Sodium\\add' => 'libsodium/libsodium.stub', 'Sodium\\bin2hex' => 'libsodium/libsodium.stub', 'Sodium\\compare' => 'libsodium/libsodium.stub', 'Sodium\\crypto_aead_aes256gcm_decrypt' => 'libsodium/libsodium.stub', 'Sodium\\crypto_aead_aes256gcm_encrypt' => 'libsodium/libsodium.stub', 'Sodium\\crypto_aead_aes256gcm_is_available' => 'libsodium/libsodium.stub', 'Sodium\\crypto_aead_chacha20poly1305_decrypt' => 'libsodium/libsodium.stub', 'Sodium\\crypto_aead_chacha20poly1305_encrypt' => 'libsodium/libsodium.stub', 'Sodium\\crypto_auth' => 'libsodium/libsodium.stub', 'Sodium\\crypto_auth_verify' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_keypair' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_keypair_from_secretkey_and_publickey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_open' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_publickey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_publickey_from_secretkey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_seal' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_seal_open' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_secretkey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_box_seed_keypair' => 'libsodium/libsodium.stub', 'Sodium\\crypto_generichash' => 'libsodium/libsodium.stub', 'Sodium\\crypto_generichash_final' => 'libsodium/libsodium.stub', 'Sodium\\crypto_generichash_init' => 'libsodium/libsodium.stub', 'Sodium\\crypto_generichash_update' => 'libsodium/libsodium.stub', 'Sodium\\crypto_kx' => 'libsodium/libsodium.stub', 'Sodium\\crypto_pwhash' => 'libsodium/libsodium.stub', 'Sodium\\crypto_pwhash_scryptsalsa208sha256' => 'libsodium/libsodium.stub', 'Sodium\\crypto_pwhash_scryptsalsa208sha256_str' => 'libsodium/libsodium.stub', 'Sodium\\crypto_pwhash_scryptsalsa208sha256_str_verify' => 'libsodium/libsodium.stub', 'Sodium\\crypto_pwhash_str' => 'libsodium/libsodium.stub', 'Sodium\\crypto_pwhash_str_verify' => 'libsodium/libsodium.stub', 'Sodium\\crypto_scalarmult' => 'libsodium/libsodium.stub', 'Sodium\\crypto_scalarmult_base' => 'libsodium/libsodium.stub', 'Sodium\\crypto_secretbox' => 'libsodium/libsodium.stub', 'Sodium\\crypto_secretbox_open' => 'libsodium/libsodium.stub', 'Sodium\\crypto_shorthash' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_detached' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_ed25519_pk_to_curve25519' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_ed25519_sk_to_curve25519' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_keypair' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_keypair_from_secretkey_and_publickey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_open' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_publickey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_publickey_from_secretkey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_secretkey' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_seed_keypair' => 'libsodium/libsodium.stub', 'Sodium\\crypto_sign_verify_detached' => 'libsodium/libsodium.stub', 'Sodium\\crypto_stream' => 'libsodium/libsodium.stub', 'Sodium\\crypto_stream_xor' => 'libsodium/libsodium.stub', 'Sodium\\hex2bin' => 'libsodium/libsodium.stub', 'Sodium\\increment' => 'libsodium/libsodium.stub', 'Sodium\\library_version_major' => 'libsodium/libsodium.stub', 'Sodium\\library_version_minor' => 'libsodium/libsodium.stub', 'Sodium\\memcmp' => 'libsodium/libsodium.stub', 'Sodium\\memzero' => 'libsodium/libsodium.stub', 'Sodium\\randombytes_buf' => 'libsodium/libsodium.stub', 'Sodium\\randombytes_random16' => 'libsodium/libsodium.stub', 'Sodium\\randombytes_uniform' => 'libsodium/libsodium.stub', 'Sodium\\version_string' => 'libsodium/libsodium.stub', 'Zstd\\compress' => 'zstd/zstd.stub', 'Zstd\\compress_dict' => 'zstd/zstd.stub', 'Zstd\\uncompress' => 'zstd/zstd.stub', 'Zstd\\uncompress_dict' => 'zstd/zstd.stub', '_' => 'gettext/gettext.stub', 'abs' => 'standard/standard_3.stub', 'accelerator_set_status' => 'zend/zend.stub', 'acos' => 'standard/standard_3.stub', 'acosh' => 'standard/standard_3.stub', 'addcslashes' => 'standard/standard_1.stub', 'addslashes' => 'standard/standard_1.stub', 'apache_child_terminate' => 'apache/apache.stub', 'apache_get_modules' => 'apache/apache.stub', 'apache_get_version' => 'apache/apache.stub', 'apache_getenv' => 'apache/apache.stub', 'apache_lookup_uri' => 'apache/apache.stub', 'apache_note' => 'apache/apache.stub', 'apache_request_headers' => 'standard/standard_4.stub', 'apache_reset_timeout' => 'apache/apache.stub', 'apache_response_headers' => 'apache/apache.stub', 'apache_setenv' => 'apache/apache.stub', 'apc_add' => 'apcu/apcu.stub', 'apc_bin_dump' => 'apcu/apcu.stub', 'apc_bin_dumpfile' => 'apcu/apcu.stub', 'apc_bin_load' => 'apcu/apcu.stub', 'apc_bin_loadfile' => 'apcu/apcu.stub', 'apc_cache_info' => 'apcu/apcu.stub', 'apc_cas' => 'apcu/apcu.stub', 'apc_clear_cache' => 'apcu/apcu.stub', 'apc_compile_file' => 'apcu/apcu.stub', 'apc_dec' => 'apcu/apcu.stub', 'apc_define_constants' => 'apcu/apcu.stub', 'apc_delete' => 'apcu/apcu.stub', 'apc_delete_file' => 'apcu/apcu.stub', 'apc_exists' => 'apcu/apcu.stub', 'apc_fetch' => 'apcu/apcu.stub', 'apc_inc' => 'apcu/apcu.stub', 'apc_load_constants' => 'apcu/apcu.stub', 'apc_sma_info' => 'apcu/apcu.stub', 'apc_store' => 'apcu/apcu.stub', 'apcu_add' => 'apcu/apcu.stub', 'apcu_cache_info' => 'apcu/apcu.stub', 'apcu_cas' => 'apcu/apcu.stub', 'apcu_clear_cache' => 'apcu/apcu.stub', 'apcu_dec' => 'apcu/apcu.stub', 'apcu_delete' => 'apcu/apcu.stub', 'apcu_enabled' => 'apcu/apcu.stub', 'apcu_entry' => 'apcu/apcu.stub', 'apcu_exists' => 'apcu/apcu.stub', 'apcu_fetch' => 'apcu/apcu.stub', 'apcu_inc' => 'apcu/apcu.stub', 'apcu_key_info' => 'apcu/apcu.stub', 'apcu_sma_info' => 'apcu/apcu.stub', 'apcu_store' => 'apcu/apcu.stub', 'array_all' => 'standard/standard_10.stub', 'array_any' => 'standard/standard_10.stub', 'array_change_key_case' => 'standard/standard_9.stub', 'array_chunk' => 'standard/standard_9.stub', 'array_column' => 'standard/standard_9.stub', 'array_combine' => 'standard/standard_9.stub', 'array_count_values' => 'standard/standard_9.stub', 'array_diff' => 'standard/standard_9.stub', 'array_diff_assoc' => 'standard/standard_9.stub', 'array_diff_key' => 'standard/standard_9.stub', 'array_diff_uassoc' => 'standard/standard_9.stub', 'array_diff_ukey' => 'standard/standard_9.stub', 'array_fill' => 'standard/standard_8.stub', 'array_fill_keys' => 'standard/standard_8.stub', 'array_filter' => 'standard/standard_9.stub', 'array_find' => 'standard/standard_10.stub', 'array_find_key' => 'standard/standard_10.stub', 'array_flip' => 'standard/standard_9.stub', 'array_intersect' => 'standard/standard_9.stub', 'array_intersect_assoc' => 'standard/standard_9.stub', 'array_intersect_key' => 'standard/standard_9.stub', 'array_intersect_uassoc' => 'standard/standard_9.stub', 'array_intersect_ukey' => 'standard/standard_9.stub', 'array_is_list' => 'standard/standard_9.stub', 'array_key_exists' => 'standard/standard_9.stub', 'array_key_first' => 'standard/standard_9.stub', 'array_key_last' => 'standard/standard_9.stub', 'array_keys' => 'standard/standard_9.stub', 'array_map' => 'standard/standard_9.stub', 'array_merge' => 'standard/standard_8.stub', 'array_merge_recursive' => 'standard/standard_9.stub', 'array_multisort' => 'standard/standard_8.stub', 'array_pad' => 'standard/standard_9.stub', 'array_pop' => 'standard/standard_8.stub', 'array_product' => 'standard/standard_9.stub', 'array_push' => 'standard/standard_8.stub', 'array_rand' => 'standard/standard_9.stub', 'array_reduce' => 'standard/standard_9.stub', 'array_replace' => 'standard/standard_9.stub', 'array_replace_recursive' => 'standard/standard_9.stub', 'array_reverse' => 'standard/standard_9.stub', 'array_search' => 'standard/standard_8.stub', 'array_shift' => 'standard/standard_8.stub', 'array_slice' => 'standard/standard_8.stub', 'array_splice' => 'standard/standard_8.stub', 'array_sum' => 'standard/standard_9.stub', 'array_udiff' => 'standard/standard_9.stub', 'array_udiff_assoc' => 'standard/standard_9.stub', 'array_udiff_uassoc' => 'standard/standard_9.stub', 'array_uintersect' => 'standard/standard_9.stub', 'array_uintersect_assoc' => 'standard/standard_9.stub', 'array_uintersect_uassoc' => 'standard/standard_9.stub', 'array_unique' => 'standard/standard_9.stub', 'array_unshift' => 'standard/standard_8.stub', 'array_values' => 'standard/standard_9.stub', 'array_walk' => 'standard/standard_8.stub', 'array_walk_recursive' => 'standard/standard_8.stub', 'arsort' => 'standard/standard_8.stub', 'asin' => 'standard/standard_3.stub', 'asinh' => 'standard/standard_3.stub', 'asort' => 'standard/standard_8.stub', 'assert' => 'standard/standard_9.stub', 'assert_options' => 'standard/standard_9.stub', 'ast\\get_kind_name' => 'ast/ast.stub', 'ast\\get_metadata' => 'ast/ast.stub', 'ast\\get_supported_versions' => 'ast/ast.stub', 'ast\\kind_uses_flags' => 'ast/ast.stub', 'ast\\parse_code' => 'ast/ast.stub', 'ast\\parse_file' => 'ast/ast.stub', 'atan' => 'standard/standard_3.stub', 'atan2' => 'standard/standard_3.stub', 'atanh' => 'standard/standard_3.stub', 'base64_decode' => 'standard/standard_3.stub', 'base64_encode' => 'standard/standard_3.stub', 'base_convert' => 'standard/standard_3.stub', 'basename' => 'standard/standard_1.stub', 'bcadd' => 'bcmath/bcmath.stub', 'bcceil' => 'bcmath/bcmath.stub', 'bccomp' => 'bcmath/bcmath.stub', 'bcdiv' => 'bcmath/bcmath.stub', 'bcfloor' => 'bcmath/bcmath.stub', 'bcmod' => 'bcmath/bcmath.stub', 'bcmul' => 'bcmath/bcmath.stub', 'bcpow' => 'bcmath/bcmath.stub', 'bcpowmod' => 'bcmath/bcmath.stub', 'bcround' => 'bcmath/bcmath.stub', 'bcscale' => 'bcmath/bcmath.stub', 'bcsqrt' => 'bcmath/bcmath.stub', 'bcsub' => 'bcmath/bcmath.stub', 'bin2hex' => 'standard/standard_0.stub', 'bind_textdomain_codeset' => 'gettext/gettext.stub', 'bindec' => 'standard/standard_3.stub', 'bindtextdomain' => 'gettext/gettext.stub', 'boolval' => 'standard/standard_5.stub', 'brotli_compress' => 'brotli/brotli.stub', 'brotli_compress_add' => 'brotli/brotli.stub', 'brotli_compress_init' => 'brotli/brotli.stub', 'brotli_uncompress' => 'brotli/brotli.stub', 'brotli_uncompress_add' => 'brotli/brotli.stub', 'brotli_uncompress_init' => 'brotli/brotli.stub', 'bzclose' => 'bz2/bz2.stub', 'bzcompress' => 'bz2/bz2.stub', 'bzdecompress' => 'bz2/bz2.stub', 'bzerrno' => 'bz2/bz2.stub', 'bzerror' => 'bz2/bz2.stub', 'bzerrstr' => 'bz2/bz2.stub', 'bzflush' => 'bz2/bz2.stub', 'bzopen' => 'bz2/bz2.stub', 'bzread' => 'bz2/bz2.stub', 'bzwrite' => 'bz2/bz2.stub', 'cal_days_in_month' => 'calendar/calendar.stub', 'cal_from_jd' => 'calendar/calendar.stub', 'cal_info' => 'calendar/calendar.stub', 'cal_to_jd' => 'calendar/calendar.stub', 'call_user_func' => 'standard/standard_4.stub', 'call_user_func_array' => 'standard/standard_4.stub', 'call_user_method' => 'standard/standard_4.stub', 'call_user_method_array' => 'standard/standard_4.stub', 'ceil' => 'standard/standard_3.stub', 'chdir' => 'standard/standard_7.stub', 'checkdate' => 'date/date.stub', 'checkdnsrr' => 'standard/standard_4.stub', 'chgrp' => 'standard/standard_7.stub', 'chmod' => 'standard/standard_7.stub', 'chop' => 'standard/standard_2.stub', 'chown' => 'standard/standard_7.stub', 'chr' => 'standard/standard_2.stub', 'chroot' => 'standard/standard_7.stub', 'chunk_split' => 'standard/standard_1.stub', 'class_alias' => 'Core/Core.stub', 'class_exists' => 'Core/Core.stub', 'class_implements' => 'SPL/SPL_f.stub', 'class_parents' => 'SPL/SPL_f.stub', 'class_uses' => 'SPL/SPL_f.stub', 'clearstatcache' => 'standard/standard_7.stub', 'cli_get_process_title' => 'standard/basic.stub', 'cli_set_process_title' => 'standard/basic.stub', 'closedir' => 'standard/standard_7.stub', 'closelog' => 'standard/standard_8.stub', 'collator_asort' => 'intl/intl.stub', 'collator_compare' => 'intl/intl.stub', 'collator_create' => 'intl/intl.stub', 'collator_get_attribute' => 'intl/intl.stub', 'collator_get_error_code' => 'intl/intl.stub', 'collator_get_error_message' => 'intl/intl.stub', 'collator_get_locale' => 'intl/intl.stub', 'collator_get_sort_key' => 'intl/intl.stub', 'collator_get_strength' => 'intl/intl.stub', 'collator_set_attribute' => 'intl/intl.stub', 'collator_set_strength' => 'intl/intl.stub', 'collator_sort' => 'intl/intl.stub', 'collator_sort_with_sort_keys' => 'intl/intl.stub', 'com_create_guid' => 'com_dotnet/com_dotnet.stub', 'com_event_sink' => 'com_dotnet/com_dotnet.stub', 'com_get_active_object' => 'com_dotnet/com_dotnet.stub', 'com_load_typelib' => 'com_dotnet/com_dotnet.stub', 'com_message_pump' => 'com_dotnet/com_dotnet.stub', 'com_print_typeinfo' => 'com_dotnet/com_dotnet.stub', 'compact' => 'standard/standard_8.stub', 'config_get_hash' => 'xdebug/xdebug.stub', 'confirm_pdo_ibm_compiled' => 'PDO/PDO.stub', 'connection_aborted' => 'standard/standard_4.stub', 'connection_status' => 'standard/standard_4.stub', 'constant' => 'standard/standard_0.stub', 'convert_cyr_string' => 'standard/standard_3.stub', 'convert_uudecode' => 'standard/standard_3.stub', 'convert_uuencode' => 'standard/standard_3.stub', 'copy' => 'standard/standard_5.stub', 'cos' => 'standard/standard_3.stub', 'cosh' => 'standard/standard_3.stub', 'count' => 'standard/standard_8.stub', 'count_chars' => 'standard/standard_1.stub', 'crc32' => 'standard/standard_0.stub', 'create_function' => 'Core/Core.stub', 'crypt' => 'standard/standard_7.stub', 'ctype_alnum' => 'ctype/ctype.stub', 'ctype_alpha' => 'ctype/ctype.stub', 'ctype_cntrl' => 'ctype/ctype.stub', 'ctype_digit' => 'ctype/ctype.stub', 'ctype_graph' => 'ctype/ctype.stub', 'ctype_lower' => 'ctype/ctype.stub', 'ctype_print' => 'ctype/ctype.stub', 'ctype_punct' => 'ctype/ctype.stub', 'ctype_space' => 'ctype/ctype.stub', 'ctype_upper' => 'ctype/ctype.stub', 'ctype_xdigit' => 'ctype/ctype.stub', 'cubrid_affected_rows' => 'cubrid/cubrid.stub', 'cubrid_bind' => 'cubrid/cubrid.stub', 'cubrid_client_encoding' => 'cubrid/cubrid.stub', 'cubrid_close' => 'cubrid/cubrid.stub', 'cubrid_close_prepare' => 'cubrid/cubrid.stub', 'cubrid_close_request' => 'cubrid/cubrid.stub', 'cubrid_col_get' => 'cubrid/cubrid.stub', 'cubrid_col_size' => 'cubrid/cubrid.stub', 'cubrid_column_names' => 'cubrid/cubrid.stub', 'cubrid_column_types' => 'cubrid/cubrid.stub', 'cubrid_commit' => 'cubrid/cubrid.stub', 'cubrid_connect' => 'cubrid/cubrid.stub', 'cubrid_connect_with_url' => 'cubrid/cubrid.stub', 'cubrid_current_oid' => 'cubrid/cubrid.stub', 'cubrid_data_seek' => 'cubrid/cubrid.stub', 'cubrid_db_name' => 'cubrid/cubrid.stub', 'cubrid_db_parameter' => 'cubrid/cubrid.stub', 'cubrid_disconnect' => 'cubrid/cubrid.stub', 'cubrid_drop' => 'cubrid/cubrid.stub', 'cubrid_errno' => 'cubrid/cubrid.stub', 'cubrid_error' => 'cubrid/cubrid.stub', 'cubrid_error_code' => 'cubrid/cubrid.stub', 'cubrid_error_code_facility' => 'cubrid/cubrid.stub', 'cubrid_error_msg' => 'cubrid/cubrid.stub', 'cubrid_execute' => 'cubrid/cubrid.stub', 'cubrid_fetch' => 'cubrid/cubrid.stub', 'cubrid_fetch_array' => 'cubrid/cubrid.stub', 'cubrid_fetch_assoc' => 'cubrid/cubrid.stub', 'cubrid_fetch_field' => 'cubrid/cubrid.stub', 'cubrid_fetch_lengths' => 'cubrid/cubrid.stub', 'cubrid_fetch_object' => 'cubrid/cubrid.stub', 'cubrid_fetch_row' => 'cubrid/cubrid.stub', 'cubrid_field_flags' => 'cubrid/cubrid.stub', 'cubrid_field_len' => 'cubrid/cubrid.stub', 'cubrid_field_name' => 'cubrid/cubrid.stub', 'cubrid_field_seek' => 'cubrid/cubrid.stub', 'cubrid_field_table' => 'cubrid/cubrid.stub', 'cubrid_field_type' => 'cubrid/cubrid.stub', 'cubrid_free_result' => 'cubrid/cubrid.stub', 'cubrid_get' => 'cubrid/cubrid.stub', 'cubrid_get_autocommit' => 'cubrid/cubrid.stub', 'cubrid_get_charset' => 'cubrid/cubrid.stub', 'cubrid_get_class_name' => 'cubrid/cubrid.stub', 'cubrid_get_client_info' => 'cubrid/cubrid.stub', 'cubrid_get_db_parameter' => 'cubrid/cubrid.stub', 'cubrid_get_query_timeout' => 'cubrid/cubrid.stub', 'cubrid_get_server_info' => 'cubrid/cubrid.stub', 'cubrid_insert_id' => 'cubrid/cubrid.stub', 'cubrid_is_instance' => 'cubrid/cubrid.stub', 'cubrid_list_dbs' => 'cubrid/cubrid.stub', 'cubrid_lob2_bind' => 'cubrid/cubrid.stub', 'cubrid_lob2_close' => 'cubrid/cubrid.stub', 'cubrid_lob2_export' => 'cubrid/cubrid.stub', 'cubrid_lob2_import' => 'cubrid/cubrid.stub', 'cubrid_lob2_new' => 'cubrid/cubrid.stub', 'cubrid_lob2_read' => 'cubrid/cubrid.stub', 'cubrid_lob2_seek' => 'cubrid/cubrid.stub', 'cubrid_lob2_seek64' => 'cubrid/cubrid.stub', 'cubrid_lob2_size' => 'cubrid/cubrid.stub', 'cubrid_lob2_size64' => 'cubrid/cubrid.stub', 'cubrid_lob2_tell' => 'cubrid/cubrid.stub', 'cubrid_lob2_tell64' => 'cubrid/cubrid.stub', 'cubrid_lob2_write' => 'cubrid/cubrid.stub', 'cubrid_lob_close' => 'cubrid/cubrid.stub', 'cubrid_lob_export' => 'cubrid/cubrid.stub', 'cubrid_lob_get' => 'cubrid/cubrid.stub', 'cubrid_lob_send' => 'cubrid/cubrid.stub', 'cubrid_lob_size' => 'cubrid/cubrid.stub', 'cubrid_lock_read' => 'cubrid/cubrid.stub', 'cubrid_lock_write' => 'cubrid/cubrid.stub', 'cubrid_move_cursor' => 'cubrid/cubrid.stub', 'cubrid_next_result' => 'cubrid/cubrid.stub', 'cubrid_num_cols' => 'cubrid/cubrid.stub', 'cubrid_num_fields' => 'cubrid/cubrid.stub', 'cubrid_num_rows' => 'cubrid/cubrid.stub', 'cubrid_pconnect' => 'cubrid/cubrid.stub', 'cubrid_pconnect_with_url' => 'cubrid/cubrid.stub', 'cubrid_ping' => 'cubrid/cubrid.stub', 'cubrid_prepare' => 'cubrid/cubrid.stub', 'cubrid_put' => 'cubrid/cubrid.stub', 'cubrid_query' => 'cubrid/cubrid.stub', 'cubrid_real_escape_string' => 'cubrid/cubrid.stub', 'cubrid_result' => 'cubrid/cubrid.stub', 'cubrid_rollback' => 'cubrid/cubrid.stub', 'cubrid_schema' => 'cubrid/cubrid.stub', 'cubrid_seq_add' => 'cubrid/cubrid.stub', 'cubrid_seq_drop' => 'cubrid/cubrid.stub', 'cubrid_seq_insert' => 'cubrid/cubrid.stub', 'cubrid_seq_put' => 'cubrid/cubrid.stub', 'cubrid_set_add' => 'cubrid/cubrid.stub', 'cubrid_set_autocommit' => 'cubrid/cubrid.stub', 'cubrid_set_db_parameter' => 'cubrid/cubrid.stub', 'cubrid_set_drop' => 'cubrid/cubrid.stub', 'cubrid_set_query_timeout' => 'cubrid/cubrid.stub', 'cubrid_unbuffered_query' => 'cubrid/cubrid.stub', 'cubrid_version' => 'cubrid/cubrid.stub', 'curl_close' => 'curl/curl.stub', 'curl_copy_handle' => 'curl/curl.stub', 'curl_errno' => 'curl/curl.stub', 'curl_error' => 'curl/curl.stub', 'curl_escape' => 'curl/curl.stub', 'curl_exec' => 'curl/curl.stub', 'curl_file_create' => 'curl/curl.stub', 'curl_getinfo' => 'curl/curl.stub', 'curl_init' => 'curl/curl.stub', 'curl_multi_add_handle' => 'curl/curl.stub', 'curl_multi_close' => 'curl/curl.stub', 'curl_multi_errno' => 'curl/curl.stub', 'curl_multi_exec' => 'curl/curl.stub', 'curl_multi_getcontent' => 'curl/curl.stub', 'curl_multi_info_read' => 'curl/curl.stub', 'curl_multi_init' => 'curl/curl.stub', 'curl_multi_remove_handle' => 'curl/curl.stub', 'curl_multi_select' => 'curl/curl.stub', 'curl_multi_setopt' => 'curl/curl.stub', 'curl_multi_strerror' => 'curl/curl.stub', 'curl_pause' => 'curl/curl.stub', 'curl_reset' => 'curl/curl.stub', 'curl_setopt' => 'curl/curl.stub', 'curl_setopt_array' => 'curl/curl.stub', 'curl_share_close' => 'curl/curl.stub', 'curl_share_errno' => 'curl/curl.stub', 'curl_share_init' => 'curl/curl.stub', 'curl_share_setopt' => 'curl/curl.stub', 'curl_share_strerror' => 'curl/curl.stub', 'curl_strerror' => 'curl/curl.stub', 'curl_unescape' => 'curl/curl.stub', 'curl_upkeep' => 'curl/curl.stub', 'curl_version' => 'curl/curl.stub', 'current' => 'standard/standard_8.stub', 'date' => 'date/date.stub', 'date_add' => 'date/date.stub', 'date_create' => 'date/date.stub', 'date_create_from_format' => 'date/date.stub', 'date_create_immutable' => 'date/date.stub', 'date_create_immutable_from_format' => 'date/date.stub', 'date_date_set' => 'date/date.stub', 'date_default_timezone_get' => 'date/date.stub', 'date_default_timezone_set' => 'date/date.stub', 'date_diff' => 'date/date.stub', 'date_format' => 'date/date.stub', 'date_get_last_errors' => 'date/date.stub', 'date_interval_create_from_date_string' => 'date/date.stub', 'date_interval_format' => 'date/date.stub', 'date_isodate_set' => 'date/date.stub', 'date_modify' => 'date/date.stub', 'date_offset_get' => 'date/date.stub', 'date_parse' => 'date/date.stub', 'date_parse_from_format' => 'date/date.stub', 'date_sub' => 'date/date.stub', 'date_sun_info' => 'date/date.stub', 'date_sunrise' => 'date/date.stub', 'date_sunset' => 'date/date.stub', 'date_time_set' => 'date/date.stub', 'date_timestamp_get' => 'date/date.stub', 'date_timestamp_set' => 'date/date.stub', 'date_timezone_get' => 'date/date.stub', 'date_timezone_set' => 'date/date.stub', 'datefmt_create' => 'intl/intl.stub', 'datefmt_format' => 'intl/intl.stub', 'datefmt_format_object' => 'intl/intl.stub', 'datefmt_get_calendar' => 'intl/intl.stub', 'datefmt_get_calendar_object' => 'intl/intl.stub', 'datefmt_get_datetype' => 'intl/intl.stub', 'datefmt_get_error_code' => 'intl/intl.stub', 'datefmt_get_error_message' => 'intl/intl.stub', 'datefmt_get_locale' => 'intl/intl.stub', 'datefmt_get_pattern' => 'intl/intl.stub', 'datefmt_get_timetype' => 'intl/intl.stub', 'datefmt_get_timezone' => 'intl/intl.stub', 'datefmt_get_timezone_id' => 'intl/intl.stub', 'datefmt_is_lenient' => 'intl/intl.stub', 'datefmt_localtime' => 'intl/intl.stub', 'datefmt_parse' => 'intl/intl.stub', 'datefmt_set_calendar' => 'intl/intl.stub', 'datefmt_set_lenient' => 'intl/intl.stub', 'datefmt_set_pattern' => 'intl/intl.stub', 'datefmt_set_timezone' => 'intl/intl.stub', 'datefmt_set_timezone_id' => 'intl/intl.stub', 'db2_autocommit' => 'ibm_db2/ibm_db2.stub', 'db2_bind_param' => 'ibm_db2/ibm_db2.stub', 'db2_client_info' => 'ibm_db2/ibm_db2.stub', 'db2_close' => 'ibm_db2/ibm_db2.stub', 'db2_column_privileges' => 'ibm_db2/ibm_db2.stub', 'db2_columnprivileges' => 'ibm_db2/ibm_db2.stub', 'db2_columns' => 'ibm_db2/ibm_db2.stub', 'db2_commit' => 'ibm_db2/ibm_db2.stub', 'db2_conn_error' => 'ibm_db2/ibm_db2.stub', 'db2_conn_errormsg' => 'ibm_db2/ibm_db2.stub', 'db2_connect' => 'ibm_db2/ibm_db2.stub', 'db2_cursor_type' => 'ibm_db2/ibm_db2.stub', 'db2_escape_string' => 'ibm_db2/ibm_db2.stub', 'db2_exec' => 'ibm_db2/ibm_db2.stub', 'db2_execute' => 'ibm_db2/ibm_db2.stub', 'db2_fetch_array' => 'ibm_db2/ibm_db2.stub', 'db2_fetch_assoc' => 'ibm_db2/ibm_db2.stub', 'db2_fetch_both' => 'ibm_db2/ibm_db2.stub', 'db2_fetch_object' => 'ibm_db2/ibm_db2.stub', 'db2_fetch_row' => 'ibm_db2/ibm_db2.stub', 'db2_field_display_size' => 'ibm_db2/ibm_db2.stub', 'db2_field_name' => 'ibm_db2/ibm_db2.stub', 'db2_field_num' => 'ibm_db2/ibm_db2.stub', 'db2_field_precision' => 'ibm_db2/ibm_db2.stub', 'db2_field_scale' => 'ibm_db2/ibm_db2.stub', 'db2_field_type' => 'ibm_db2/ibm_db2.stub', 'db2_field_width' => 'ibm_db2/ibm_db2.stub', 'db2_foreign_keys' => 'ibm_db2/ibm_db2.stub', 'db2_foreignkeys' => 'ibm_db2/ibm_db2.stub', 'db2_free_result' => 'ibm_db2/ibm_db2.stub', 'db2_free_stmt' => 'ibm_db2/ibm_db2.stub', 'db2_get_option' => 'ibm_db2/ibm_db2.stub', 'db2_last_insert_id' => 'ibm_db2/ibm_db2.stub', 'db2_lob_read' => 'ibm_db2/ibm_db2.stub', 'db2_next_result' => 'ibm_db2/ibm_db2.stub', 'db2_num_fields' => 'ibm_db2/ibm_db2.stub', 'db2_num_rows' => 'ibm_db2/ibm_db2.stub', 'db2_pclose' => 'ibm_db2/ibm_db2.stub', 'db2_pconnect' => 'ibm_db2/ibm_db2.stub', 'db2_prepare' => 'ibm_db2/ibm_db2.stub', 'db2_primary_keys' => 'ibm_db2/ibm_db2.stub', 'db2_primarykeys' => 'ibm_db2/ibm_db2.stub', 'db2_procedure_columns' => 'ibm_db2/ibm_db2.stub', 'db2_procedurecolumns' => 'ibm_db2/ibm_db2.stub', 'db2_procedures' => 'ibm_db2/ibm_db2.stub', 'db2_result' => 'ibm_db2/ibm_db2.stub', 'db2_rollback' => 'ibm_db2/ibm_db2.stub', 'db2_server_info' => 'ibm_db2/ibm_db2.stub', 'db2_set_option' => 'ibm_db2/ibm_db2.stub', 'db2_setoption' => 'ibm_db2/ibm_db2.stub', 'db2_special_columns' => 'ibm_db2/ibm_db2.stub', 'db2_specialcolumns' => 'ibm_db2/ibm_db2.stub', 'db2_statistics' => 'ibm_db2/ibm_db2.stub', 'db2_stmt_error' => 'ibm_db2/ibm_db2.stub', 'db2_stmt_errormsg' => 'ibm_db2/ibm_db2.stub', 'db2_table_privileges' => 'ibm_db2/ibm_db2.stub', 'db2_tableprivileges' => 'ibm_db2/ibm_db2.stub', 'db2_tables' => 'ibm_db2/ibm_db2.stub', 'dba_close' => 'dba/dba.stub', 'dba_delete' => 'dba/dba.stub', 'dba_exists' => 'dba/dba.stub', 'dba_fetch' => 'dba/dba.stub', 'dba_firstkey' => 'dba/dba.stub', 'dba_handlers' => 'dba/dba.stub', 'dba_insert' => 'dba/dba.stub', 'dba_key_split' => 'dba/dba.stub', 'dba_list' => 'dba/dba.stub', 'dba_nextkey' => 'dba/dba.stub', 'dba_open' => 'dba/dba.stub', 'dba_optimize' => 'dba/dba.stub', 'dba_popen' => 'dba/dba.stub', 'dba_replace' => 'dba/dba.stub', 'dba_sync' => 'dba/dba.stub', 'dcgettext' => 'gettext/gettext.stub', 'dcngettext' => 'gettext/gettext.stub', 'debug_backtrace' => 'Core/Core.stub', 'debug_print_backtrace' => 'Core/Core.stub', 'debug_zval_dump' => 'standard/standard_4.stub', 'debugger_connect' => 'ZendDebugger/ZendDebugger.stub', 'debugger_connector_pid' => 'ZendDebugger/ZendDebugger.stub', 'debugger_get_server_start_time' => 'ZendDebugger/ZendDebugger.stub', 'debugger_print' => 'ZendDebugger/ZendDebugger.stub', 'debugger_start_debug' => 'ZendDebugger/ZendDebugger.stub', 'decbin' => 'standard/standard_3.stub', 'dechex' => 'standard/standard_3.stub', 'decoct' => 'standard/standard_3.stub', 'defer' => 'swoole/functions.stub', 'define' => 'Core/Core.stub', 'define_syslog_variables' => 'standard/standard_8.stub', 'defined' => 'Core/Core.stub', 'deflate_add' => 'zlib/zlib.stub', 'deflate_init' => 'zlib/zlib.stub', 'deg2rad' => 'standard/standard_3.stub', 'dgettext' => 'gettext/gettext.stub', 'dio_close' => 'dio/dio.stub', 'dio_fcntl' => 'dio/dio.stub', 'dio_open' => 'dio/dio.stub', 'dio_raw' => 'dio/dio.stub', 'dio_read' => 'dio/dio.stub', 'dio_seek' => 'dio/dio.stub', 'dio_serial' => 'dio/dio.stub', 'dio_stat' => 'dio/dio.stub', 'dio_tcsetattr' => 'dio/dio.stub', 'dio_truncate' => 'dio/dio.stub', 'dio_write' => 'dio/dio.stub', 'dir' => 'standard/standard_7.stub', 'dirname' => 'standard/standard_1.stub', 'disk_free_space' => 'standard/standard_7.stub', 'disk_total_space' => 'standard/standard_7.stub', 'diskfreespace' => 'standard/standard_7.stub', 'dl' => 'standard/basic.stub', 'dngettext' => 'gettext/gettext.stub', 'dns_check_record' => 'standard/standard_4.stub', 'dns_get_mx' => 'standard/standard_4.stub', 'dns_get_record' => 'standard/standard_4.stub', 'dom_import_simplexml' => 'dom/dom.stub', 'doubleval' => 'standard/standard_5.stub', 'each' => 'Core/Core.stub', 'easter_date' => 'calendar/calendar.stub', 'easter_days' => 'calendar/calendar.stub', 'eio_busy' => 'eio/eio.stub', 'eio_cancel' => 'eio/eio.stub', 'eio_chmod' => 'eio/eio.stub', 'eio_chown' => 'eio/eio.stub', 'eio_close' => 'eio/eio.stub', 'eio_custom' => 'eio/eio.stub', 'eio_dup2' => 'eio/eio.stub', 'eio_event_loop' => 'eio/eio.stub', 'eio_fallocate' => 'eio/eio.stub', 'eio_fchmod' => 'eio/eio.stub', 'eio_fchown' => 'eio/eio.stub', 'eio_fdatasync' => 'eio/eio.stub', 'eio_fstat' => 'eio/eio.stub', 'eio_fstatvfs' => 'eio/eio.stub', 'eio_fsync' => 'eio/eio.stub', 'eio_ftruncate' => 'eio/eio.stub', 'eio_futime' => 'eio/eio.stub', 'eio_get_event_stream' => 'eio/eio.stub', 'eio_get_last_error' => 'eio/eio.stub', 'eio_grp' => 'eio/eio.stub', 'eio_grp_add' => 'eio/eio.stub', 'eio_grp_cancel' => 'eio/eio.stub', 'eio_grp_limit' => 'eio/eio.stub', 'eio_link' => 'eio/eio.stub', 'eio_lstat' => 'eio/eio.stub', 'eio_mkdir' => 'eio/eio.stub', 'eio_mknod' => 'eio/eio.stub', 'eio_nop' => 'eio/eio.stub', 'eio_npending' => 'eio/eio.stub', 'eio_nready' => 'eio/eio.stub', 'eio_nreqs' => 'eio/eio.stub', 'eio_nthreads' => 'eio/eio.stub', 'eio_open' => 'eio/eio.stub', 'eio_poll' => 'eio/eio.stub', 'eio_read' => 'eio/eio.stub', 'eio_readahead' => 'eio/eio.stub', 'eio_readdir' => 'eio/eio.stub', 'eio_readlink' => 'eio/eio.stub', 'eio_realpath' => 'eio/eio.stub', 'eio_rename' => 'eio/eio.stub', 'eio_rmdir' => 'eio/eio.stub', 'eio_seek' => 'eio/eio.stub', 'eio_sendfile' => 'eio/eio.stub', 'eio_set_max_idle' => 'eio/eio.stub', 'eio_set_max_parallel' => 'eio/eio.stub', 'eio_set_max_poll_reqs' => 'eio/eio.stub', 'eio_set_max_poll_time' => 'eio/eio.stub', 'eio_set_min_parallel' => 'eio/eio.stub', 'eio_stat' => 'eio/eio.stub', 'eio_statvfs' => 'eio/eio.stub', 'eio_symlink' => 'eio/eio.stub', 'eio_sync' => 'eio/eio.stub', 'eio_sync_file_range' => 'eio/eio.stub', 'eio_syncfs' => 'eio/eio.stub', 'eio_truncate' => 'eio/eio.stub', 'eio_unlink' => 'eio/eio.stub', 'eio_utime' => 'eio/eio.stub', 'eio_write' => 'eio/eio.stub', 'enchant_broker_describe' => 'enchant/enchant.stub', 'enchant_broker_dict_exists' => 'enchant/enchant.stub', 'enchant_broker_free' => 'enchant/enchant.stub', 'enchant_broker_free_dict' => 'enchant/enchant.stub', 'enchant_broker_get_dict_path' => 'enchant/enchant.stub', 'enchant_broker_get_error' => 'enchant/enchant.stub', 'enchant_broker_init' => 'enchant/enchant.stub', 'enchant_broker_list_dicts' => 'enchant/enchant.stub', 'enchant_broker_request_dict' => 'enchant/enchant.stub', 'enchant_broker_request_pwl_dict' => 'enchant/enchant.stub', 'enchant_broker_set_dict_path' => 'enchant/enchant.stub', 'enchant_broker_set_ordering' => 'enchant/enchant.stub', 'enchant_dict_add' => 'enchant/enchant.stub', 'enchant_dict_add_to_personal' => 'enchant/enchant.stub', 'enchant_dict_add_to_session' => 'enchant/enchant.stub', 'enchant_dict_check' => 'enchant/enchant.stub', 'enchant_dict_describe' => 'enchant/enchant.stub', 'enchant_dict_get_error' => 'enchant/enchant.stub', 'enchant_dict_is_added' => 'enchant/enchant.stub', 'enchant_dict_is_in_session' => 'enchant/enchant.stub', 'enchant_dict_quick_check' => 'enchant/enchant.stub', 'enchant_dict_store_replacement' => 'enchant/enchant.stub', 'enchant_dict_suggest' => 'enchant/enchant.stub', 'end' => 'standard/standard_8.stub', 'enum_exists' => 'Core/Core.stub', 'ereg' => 'regex/ereg.stub', 'ereg_replace' => 'regex/ereg.stub', 'eregi' => 'regex/ereg.stub', 'eregi_replace' => 'regex/ereg.stub', 'error_clear_last' => 'standard/basic.stub', 'error_get_last' => 'standard/standard_4.stub', 'error_log' => 'standard/standard_3.stub', 'error_reporting' => 'Core/Core.stub', 'escapeshellarg' => 'standard/standard_2.stub', 'escapeshellcmd' => 'standard/standard_2.stub', 'event_add' => 'libevent/libevent.stub', 'event_base_free' => 'libevent/libevent.stub', 'event_base_loop' => 'libevent/libevent.stub', 'event_base_loopbreak' => 'libevent/libevent.stub', 'event_base_loopexit' => 'libevent/libevent.stub', 'event_base_new' => 'libevent/libevent.stub', 'event_base_priority_init' => 'libevent/libevent.stub', 'event_base_set' => 'libevent/libevent.stub', 'event_buffer_base_set' => 'libevent/libevent.stub', 'event_buffer_disable' => 'libevent/libevent.stub', 'event_buffer_enable' => 'libevent/libevent.stub', 'event_buffer_fd_set' => 'libevent/libevent.stub', 'event_buffer_free' => 'libevent/libevent.stub', 'event_buffer_new' => 'libevent/libevent.stub', 'event_buffer_priority_set' => 'libevent/libevent.stub', 'event_buffer_read' => 'libevent/libevent.stub', 'event_buffer_set_callback' => 'libevent/libevent.stub', 'event_buffer_timeout_set' => 'libevent/libevent.stub', 'event_buffer_watermark_set' => 'libevent/libevent.stub', 'event_buffer_write' => 'libevent/libevent.stub', 'event_del' => 'libevent/libevent.stub', 'event_free' => 'libevent/libevent.stub', 'event_new' => 'libevent/libevent.stub', 'event_set' => 'libevent/libevent.stub', 'event_timer_add' => 'libevent/libevent.stub', 'event_timer_del' => 'libevent/libevent.stub', 'event_timer_new' => 'libevent/libevent.stub', 'event_timer_pending' => 'libevent/libevent.stub', 'event_timer_set' => 'libevent/libevent.stub', 'exec' => 'standard/standard_2.stub', 'exif_imagetype' => 'exif/exif.stub', 'exif_read_data' => 'exif/exif.stub', 'exif_tagname' => 'exif/exif.stub', 'exif_thumbnail' => 'exif/exif.stub', 'exp' => 'standard/standard_3.stub', 'expect_expectl' => 'expect/expect.stub', 'expect_popen' => 'expect/expect.stub', 'explode' => 'standard/standard_1.stub', 'expm1' => 'standard/standard_3.stub', 'extension_loaded' => 'Core/Core.stub', 'extract' => 'standard/standard_8.stub', 'ezmlm_hash' => 'standard/standard_7.stub', 'fann_cascadetrain_on_data' => 'fann/fann.stub', 'fann_cascadetrain_on_file' => 'fann/fann.stub', 'fann_clear_scaling_params' => 'fann/fann.stub', 'fann_copy' => 'fann/fann.stub', 'fann_create_from_file' => 'fann/fann.stub', 'fann_create_shortcut' => 'fann/fann.stub', 'fann_create_shortcut_array' => 'fann/fann.stub', 'fann_create_sparse' => 'fann/fann.stub', 'fann_create_sparse_array' => 'fann/fann.stub', 'fann_create_standard' => 'fann/fann.stub', 'fann_create_standard_array' => 'fann/fann.stub', 'fann_create_train' => 'fann/fann.stub', 'fann_create_train_from_callback' => 'fann/fann.stub', 'fann_descale_input' => 'fann/fann.stub', 'fann_descale_output' => 'fann/fann.stub', 'fann_descale_train' => 'fann/fann.stub', 'fann_destroy' => 'fann/fann.stub', 'fann_destroy_train' => 'fann/fann.stub', 'fann_duplicate_train_data' => 'fann/fann.stub', 'fann_get_MSE' => 'fann/fann.stub', 'fann_get_activation_function' => 'fann/fann.stub', 'fann_get_activation_steepness' => 'fann/fann.stub', 'fann_get_bias_array' => 'fann/fann.stub', 'fann_get_bit_fail' => 'fann/fann.stub', 'fann_get_bit_fail_limit' => 'fann/fann.stub', 'fann_get_cascade_activation_functions' => 'fann/fann.stub', 'fann_get_cascade_activation_functions_count' => 'fann/fann.stub', 'fann_get_cascade_activation_steepnesses' => 'fann/fann.stub', 'fann_get_cascade_activation_steepnesses_count' => 'fann/fann.stub', 'fann_get_cascade_candidate_change_fraction' => 'fann/fann.stub', 'fann_get_cascade_candidate_limit' => 'fann/fann.stub', 'fann_get_cascade_candidate_stagnation_epochs' => 'fann/fann.stub', 'fann_get_cascade_max_cand_epochs' => 'fann/fann.stub', 'fann_get_cascade_max_out_epochs' => 'fann/fann.stub', 'fann_get_cascade_min_cand_epochs' => 'fann/fann.stub', 'fann_get_cascade_min_out_epochs' => 'fann/fann.stub', 'fann_get_cascade_num_candidate_groups' => 'fann/fann.stub', 'fann_get_cascade_num_candidates' => 'fann/fann.stub', 'fann_get_cascade_output_change_fraction' => 'fann/fann.stub', 'fann_get_cascade_output_stagnation_epochs' => 'fann/fann.stub', 'fann_get_cascade_weight_multiplier' => 'fann/fann.stub', 'fann_get_connection_array' => 'fann/fann.stub', 'fann_get_connection_rate' => 'fann/fann.stub', 'fann_get_errno' => 'fann/fann.stub', 'fann_get_errstr' => 'fann/fann.stub', 'fann_get_layer_array' => 'fann/fann.stub', 'fann_get_learning_momentum' => 'fann/fann.stub', 'fann_get_learning_rate' => 'fann/fann.stub', 'fann_get_network_type' => 'fann/fann.stub', 'fann_get_num_input' => 'fann/fann.stub', 'fann_get_num_layers' => 'fann/fann.stub', 'fann_get_num_output' => 'fann/fann.stub', 'fann_get_quickprop_decay' => 'fann/fann.stub', 'fann_get_quickprop_mu' => 'fann/fann.stub', 'fann_get_rprop_decrease_factor' => 'fann/fann.stub', 'fann_get_rprop_delta_max' => 'fann/fann.stub', 'fann_get_rprop_delta_min' => 'fann/fann.stub', 'fann_get_rprop_delta_zero' => 'fann/fann.stub', 'fann_get_rprop_increase_factor' => 'fann/fann.stub', 'fann_get_sarprop_step_error_shift' => 'fann/fann.stub', 'fann_get_sarprop_step_error_threshold_factor' => 'fann/fann.stub', 'fann_get_sarprop_temperature' => 'fann/fann.stub', 'fann_get_sarprop_weight_decay_shift' => 'fann/fann.stub', 'fann_get_total_connections' => 'fann/fann.stub', 'fann_get_total_neurons' => 'fann/fann.stub', 'fann_get_train_error_function' => 'fann/fann.stub', 'fann_get_train_stop_function' => 'fann/fann.stub', 'fann_get_training_algorithm' => 'fann/fann.stub', 'fann_init_weights' => 'fann/fann.stub', 'fann_length_train_data' => 'fann/fann.stub', 'fann_merge_train_data' => 'fann/fann.stub', 'fann_num_input_train_data' => 'fann/fann.stub', 'fann_num_output_train_data' => 'fann/fann.stub', 'fann_print_error' => 'fann/fann.stub', 'fann_randomize_weights' => 'fann/fann.stub', 'fann_read_train_from_file' => 'fann/fann.stub', 'fann_reset_MSE' => 'fann/fann.stub', 'fann_reset_errno' => 'fann/fann.stub', 'fann_reset_errstr' => 'fann/fann.stub', 'fann_run' => 'fann/fann.stub', 'fann_save' => 'fann/fann.stub', 'fann_save_train' => 'fann/fann.stub', 'fann_scale_input' => 'fann/fann.stub', 'fann_scale_input_train_data' => 'fann/fann.stub', 'fann_scale_output' => 'fann/fann.stub', 'fann_scale_output_train_data' => 'fann/fann.stub', 'fann_scale_train' => 'fann/fann.stub', 'fann_scale_train_data' => 'fann/fann.stub', 'fann_set_activation_function' => 'fann/fann.stub', 'fann_set_activation_function_hidden' => 'fann/fann.stub', 'fann_set_activation_function_layer' => 'fann/fann.stub', 'fann_set_activation_function_output' => 'fann/fann.stub', 'fann_set_activation_steepness' => 'fann/fann.stub', 'fann_set_activation_steepness_hidden' => 'fann/fann.stub', 'fann_set_activation_steepness_layer' => 'fann/fann.stub', 'fann_set_activation_steepness_output' => 'fann/fann.stub', 'fann_set_bit_fail_limit' => 'fann/fann.stub', 'fann_set_callback' => 'fann/fann.stub', 'fann_set_cascade_activation_functions' => 'fann/fann.stub', 'fann_set_cascade_activation_steepnesses' => 'fann/fann.stub', 'fann_set_cascade_candidate_change_fraction' => 'fann/fann.stub', 'fann_set_cascade_candidate_limit' => 'fann/fann.stub', 'fann_set_cascade_candidate_stagnation_epochs' => 'fann/fann.stub', 'fann_set_cascade_max_cand_epochs' => 'fann/fann.stub', 'fann_set_cascade_max_out_epochs' => 'fann/fann.stub', 'fann_set_cascade_min_cand_epochs' => 'fann/fann.stub', 'fann_set_cascade_min_out_epochs' => 'fann/fann.stub', 'fann_set_cascade_num_candidate_groups' => 'fann/fann.stub', 'fann_set_cascade_output_change_fraction' => 'fann/fann.stub', 'fann_set_cascade_output_stagnation_epochs' => 'fann/fann.stub', 'fann_set_cascade_weight_multiplier' => 'fann/fann.stub', 'fann_set_error_log' => 'fann/fann.stub', 'fann_set_input_scaling_params' => 'fann/fann.stub', 'fann_set_learning_momentum' => 'fann/fann.stub', 'fann_set_learning_rate' => 'fann/fann.stub', 'fann_set_output_scaling_params' => 'fann/fann.stub', 'fann_set_quickprop_decay' => 'fann/fann.stub', 'fann_set_quickprop_mu' => 'fann/fann.stub', 'fann_set_rprop_decrease_factor' => 'fann/fann.stub', 'fann_set_rprop_delta_max' => 'fann/fann.stub', 'fann_set_rprop_delta_min' => 'fann/fann.stub', 'fann_set_rprop_delta_zero' => 'fann/fann.stub', 'fann_set_rprop_increase_factor' => 'fann/fann.stub', 'fann_set_sarprop_step_error_shift' => 'fann/fann.stub', 'fann_set_sarprop_step_error_threshold_factor' => 'fann/fann.stub', 'fann_set_sarprop_temperature' => 'fann/fann.stub', 'fann_set_sarprop_weight_decay_shift' => 'fann/fann.stub', 'fann_set_scaling_params' => 'fann/fann.stub', 'fann_set_train_error_function' => 'fann/fann.stub', 'fann_set_train_stop_function' => 'fann/fann.stub', 'fann_set_training_algorithm' => 'fann/fann.stub', 'fann_set_weight' => 'fann/fann.stub', 'fann_set_weight_array' => 'fann/fann.stub', 'fann_shuffle_train_data' => 'fann/fann.stub', 'fann_subset_train_data' => 'fann/fann.stub', 'fann_test' => 'fann/fann.stub', 'fann_test_data' => 'fann/fann.stub', 'fann_train' => 'fann/fann.stub', 'fann_train_epoch' => 'fann/fann.stub', 'fann_train_on_data' => 'fann/fann.stub', 'fann_train_on_file' => 'fann/fann.stub', 'fastcgi_finish_request' => 'fpm/fpm.stub', 'fbird_add_user' => 'interbase/interbase.stub', 'fbird_affected_rows' => 'interbase/interbase.stub', 'fbird_backup' => 'interbase/interbase.stub', 'fbird_blob_add' => 'interbase/interbase.stub', 'fbird_blob_cancel' => 'interbase/interbase.stub', 'fbird_blob_close' => 'interbase/interbase.stub', 'fbird_blob_create' => 'interbase/interbase.stub', 'fbird_blob_echo' => 'interbase/interbase.stub', 'fbird_blob_get' => 'interbase/interbase.stub', 'fbird_blob_import' => 'interbase/interbase.stub', 'fbird_blob_info' => 'interbase/interbase.stub', 'fbird_blob_open' => 'interbase/interbase.stub', 'fbird_close' => 'interbase/interbase.stub', 'fbird_commit' => 'interbase/interbase.stub', 'fbird_commit_ret' => 'interbase/interbase.stub', 'fbird_connect' => 'interbase/interbase.stub', 'fbird_db_info' => 'interbase/interbase.stub', 'fbird_delete_user' => 'interbase/interbase.stub', 'fbird_drop_db' => 'interbase/interbase.stub', 'fbird_errcode' => 'interbase/interbase.stub', 'fbird_errmsg' => 'interbase/interbase.stub', 'fbird_execute' => 'interbase/interbase.stub', 'fbird_fetch_assoc' => 'interbase/interbase.stub', 'fbird_fetch_object' => 'interbase/interbase.stub', 'fbird_fetch_row' => 'interbase/interbase.stub', 'fbird_field_info' => 'interbase/interbase.stub', 'fbird_free_event_handler' => 'interbase/interbase.stub', 'fbird_free_query' => 'interbase/interbase.stub', 'fbird_free_result' => 'interbase/interbase.stub', 'fbird_gen_id' => 'interbase/interbase.stub', 'fbird_maintain_db' => 'interbase/interbase.stub', 'fbird_modify_user' => 'interbase/interbase.stub', 'fbird_name_result' => 'interbase/interbase.stub', 'fbird_num_fields' => 'interbase/interbase.stub', 'fbird_num_params' => 'interbase/interbase.stub', 'fbird_param_info' => 'interbase/interbase.stub', 'fbird_pconnect' => 'interbase/interbase.stub', 'fbird_prepare' => 'interbase/interbase.stub', 'fbird_query' => 'interbase/interbase.stub', 'fbird_restore' => 'interbase/interbase.stub', 'fbird_rollback' => 'interbase/interbase.stub', 'fbird_rollback_ret' => 'interbase/interbase.stub', 'fbird_server_info' => 'interbase/interbase.stub', 'fbird_service_attach' => 'interbase/interbase.stub', 'fbird_service_detach' => 'interbase/interbase.stub', 'fbird_set_event_handler' => 'interbase/interbase.stub', 'fbird_trans' => 'interbase/interbase.stub', 'fbird_wait_event' => 'interbase/interbase.stub', 'fclose' => 'standard/standard_5.stub', 'fdatasync' => 'standard/standard_5.stub', 'fdiv' => 'standard/standard_3.stub', 'feof' => 'standard/standard_5.stub', 'fflush' => 'standard/standard_5.stub', 'fgetc' => 'standard/standard_5.stub', 'fgetcsv' => 'standard/standard_6.stub', 'fgets' => 'standard/standard_5.stub', 'fgetss' => 'standard/standard_5.stub', 'file' => 'standard/standard_5.stub', 'file_exists' => 'standard/standard_7.stub', 'file_get_contents' => 'standard/standard_5.stub', 'file_put_contents' => 'standard/standard_5.stub', 'fileatime' => 'standard/standard_7.stub', 'filectime' => 'standard/standard_7.stub', 'filegroup' => 'standard/standard_7.stub', 'fileinode' => 'standard/standard_7.stub', 'filemtime' => 'standard/standard_7.stub', 'fileowner' => 'standard/standard_7.stub', 'fileperms' => 'standard/standard_7.stub', 'filesize' => 'standard/standard_7.stub', 'filetype' => 'standard/standard_7.stub', 'filter_has_var' => 'filter/filter.stub', 'filter_id' => 'filter/filter.stub', 'filter_input' => 'filter/filter.stub', 'filter_input_array' => 'filter/filter.stub', 'filter_list' => 'filter/filter.stub', 'filter_var' => 'filter/filter.stub', 'filter_var_array' => 'filter/filter.stub', 'finfo_buffer' => 'fileinfo/fileinfo.stub', 'finfo_close' => 'fileinfo/fileinfo.stub', 'finfo_file' => 'fileinfo/fileinfo.stub', 'finfo_open' => 'fileinfo/fileinfo.stub', 'finfo_set_flags' => 'fileinfo/fileinfo.stub', 'floatval' => 'standard/standard_5.stub', 'flock' => 'standard/standard_6.stub', 'floor' => 'standard/standard_3.stub', 'flush' => 'standard/standard_0.stub', 'fmod' => 'standard/standard_3.stub', 'fnmatch' => 'standard/standard_6.stub', 'fopen' => 'standard/standard_5.stub', 'forward_static_call' => 'standard/standard_4.stub', 'forward_static_call_array' => 'standard/standard_4.stub', 'fpassthru' => 'standard/standard_5.stub', 'fpm_get_status' => 'fpm/fpm.stub', 'fpow' => 'standard/standard_10.stub', 'fprintf' => 'standard/standard_2.stub', 'fputcsv' => 'standard/standard_6.stub', 'fputs' => 'standard/standard_5.stub', 'frankenphp_finish_request' => 'frankenphp/frankenphp.stub', 'frankenphp_handle_request' => 'frankenphp/frankenphp.stub', 'frankenphp_request_headers' => 'frankenphp/frankenphp.stub', 'frankenphp_response_headers' => 'frankenphp/frankenphp.stub', 'fread' => 'standard/standard_5.stub', 'frenchtojd' => 'calendar/calendar.stub', 'fscanf' => 'standard/standard_2.stub', 'fseek' => 'standard/standard_5.stub', 'fsockopen' => 'standard/standard_7.stub', 'fstat' => 'standard/standard_5.stub', 'fsync' => 'standard/standard_5.stub', 'ftell' => 'standard/standard_5.stub', 'ftok' => 'standard/standard_9.stub', 'ftp_alloc' => 'ftp/ftp.stub', 'ftp_append' => 'ftp/ftp.stub', 'ftp_cdup' => 'ftp/ftp.stub', 'ftp_chdir' => 'ftp/ftp.stub', 'ftp_chmod' => 'ftp/ftp.stub', 'ftp_close' => 'ftp/ftp.stub', 'ftp_connect' => 'ftp/ftp.stub', 'ftp_delete' => 'ftp/ftp.stub', 'ftp_exec' => 'ftp/ftp.stub', 'ftp_fget' => 'ftp/ftp.stub', 'ftp_fput' => 'ftp/ftp.stub', 'ftp_get' => 'ftp/ftp.stub', 'ftp_get_option' => 'ftp/ftp.stub', 'ftp_login' => 'ftp/ftp.stub', 'ftp_mdtm' => 'ftp/ftp.stub', 'ftp_mkdir' => 'ftp/ftp.stub', 'ftp_mlsd' => 'ftp/ftp.stub', 'ftp_nb_continue' => 'ftp/ftp.stub', 'ftp_nb_fget' => 'ftp/ftp.stub', 'ftp_nb_fput' => 'ftp/ftp.stub', 'ftp_nb_get' => 'ftp/ftp.stub', 'ftp_nb_put' => 'ftp/ftp.stub', 'ftp_nlist' => 'ftp/ftp.stub', 'ftp_pasv' => 'ftp/ftp.stub', 'ftp_put' => 'ftp/ftp.stub', 'ftp_pwd' => 'ftp/ftp.stub', 'ftp_quit' => 'ftp/ftp.stub', 'ftp_raw' => 'ftp/ftp.stub', 'ftp_rawlist' => 'ftp/ftp.stub', 'ftp_rename' => 'ftp/ftp.stub', 'ftp_rmdir' => 'ftp/ftp.stub', 'ftp_set_option' => 'ftp/ftp.stub', 'ftp_site' => 'ftp/ftp.stub', 'ftp_size' => 'ftp/ftp.stub', 'ftp_ssl_connect' => 'ftp/ftp.stub', 'ftp_systype' => 'ftp/ftp.stub', 'ftruncate' => 'standard/standard_5.stub', 'func_get_arg' => 'Core/Core.stub', 'func_get_args' => 'Core/Core.stub', 'func_num_args' => 'Core/Core.stub', 'function_exists' => 'Core/Core.stub', 'fwrite' => 'standard/standard_5.stub', 'gc_collect_cycles' => 'Core/Core.stub', 'gc_disable' => 'Core/Core.stub', 'gc_enable' => 'Core/Core.stub', 'gc_enabled' => 'Core/Core.stub', 'gc_mem_caches' => 'Core/Core.stub', 'gc_status' => 'Core/Core.stub', 'gd_info' => 'gd/gd.stub', 'gearman_bugreport' => 'gearman/gearman.stub', 'gearman_client_add_options' => 'gearman/gearman.stub', 'gearman_client_add_server' => 'gearman/gearman.stub', 'gearman_client_add_servers' => 'gearman/gearman.stub', 'gearman_client_add_task' => 'gearman/gearman.stub', 'gearman_client_add_task_background' => 'gearman/gearman.stub', 'gearman_client_add_task_high' => 'gearman/gearman.stub', 'gearman_client_add_task_high_background' => 'gearman/gearman.stub', 'gearman_client_add_task_low' => 'gearman/gearman.stub', 'gearman_client_add_task_low_background' => 'gearman/gearman.stub', 'gearman_client_add_task_status' => 'gearman/gearman.stub', 'gearman_client_clear_fn' => 'gearman/gearman.stub', 'gearman_client_clone' => 'gearman/gearman.stub', 'gearman_client_context' => 'gearman/gearman.stub', 'gearman_client_create' => 'gearman/gearman.stub', 'gearman_client_do' => 'gearman/gearman.stub', 'gearman_client_do_background' => 'gearman/gearman.stub', 'gearman_client_do_high' => 'gearman/gearman.stub', 'gearman_client_do_high_background' => 'gearman/gearman.stub', 'gearman_client_do_job_handle' => 'gearman/gearman.stub', 'gearman_client_do_low' => 'gearman/gearman.stub', 'gearman_client_do_low_background' => 'gearman/gearman.stub', 'gearman_client_do_normal' => 'gearman/gearman.stub', 'gearman_client_do_status' => 'gearman/gearman.stub', 'gearman_client_echo' => 'gearman/gearman.stub', 'gearman_client_errno' => 'gearman/gearman.stub', 'gearman_client_error' => 'gearman/gearman.stub', 'gearman_client_job_status' => 'gearman/gearman.stub', 'gearman_client_options' => 'gearman/gearman.stub', 'gearman_client_remove_options' => 'gearman/gearman.stub', 'gearman_client_return_code' => 'gearman/gearman.stub', 'gearman_client_run_tasks' => 'gearman/gearman.stub', 'gearman_client_set_complete_fn' => 'gearman/gearman.stub', 'gearman_client_set_context' => 'gearman/gearman.stub', 'gearman_client_set_created_fn' => 'gearman/gearman.stub', 'gearman_client_set_data_fn' => 'gearman/gearman.stub', 'gearman_client_set_exception_fn' => 'gearman/gearman.stub', 'gearman_client_set_fail_fn' => 'gearman/gearman.stub', 'gearman_client_set_options' => 'gearman/gearman.stub', 'gearman_client_set_status_fn' => 'gearman/gearman.stub', 'gearman_client_set_timeout' => 'gearman/gearman.stub', 'gearman_client_set_warning_fn' => 'gearman/gearman.stub', 'gearman_client_set_workload_fn' => 'gearman/gearman.stub', 'gearman_client_timeout' => 'gearman/gearman.stub', 'gearman_client_wait' => 'gearman/gearman.stub', 'gearman_job_function_name' => 'gearman/gearman.stub', 'gearman_job_handle' => 'gearman/gearman.stub', 'gearman_job_return_code' => 'gearman/gearman.stub', 'gearman_job_send_complete' => 'gearman/gearman.stub', 'gearman_job_send_data' => 'gearman/gearman.stub', 'gearman_job_send_exception' => 'gearman/gearman.stub', 'gearman_job_send_fail' => 'gearman/gearman.stub', 'gearman_job_send_status' => 'gearman/gearman.stub', 'gearman_job_send_warning' => 'gearman/gearman.stub', 'gearman_job_unique' => 'gearman/gearman.stub', 'gearman_job_workload' => 'gearman/gearman.stub', 'gearman_job_workload_size' => 'gearman/gearman.stub', 'gearman_task_data' => 'gearman/gearman.stub', 'gearman_task_data_size' => 'gearman/gearman.stub', 'gearman_task_denominator' => 'gearman/gearman.stub', 'gearman_task_function_name' => 'gearman/gearman.stub', 'gearman_task_is_known' => 'gearman/gearman.stub', 'gearman_task_is_running' => 'gearman/gearman.stub', 'gearman_task_job_handle' => 'gearman/gearman.stub', 'gearman_task_numerator' => 'gearman/gearman.stub', 'gearman_task_recv_data' => 'gearman/gearman.stub', 'gearman_task_return_code' => 'gearman/gearman.stub', 'gearman_task_send_workload' => 'gearman/gearman.stub', 'gearman_task_unique' => 'gearman/gearman.stub', 'gearman_verbose_name' => 'gearman/gearman.stub', 'gearman_version' => 'gearman/gearman.stub', 'gearman_worker_add_function' => 'gearman/gearman.stub', 'gearman_worker_add_options' => 'gearman/gearman.stub', 'gearman_worker_add_server' => 'gearman/gearman.stub', 'gearman_worker_add_servers' => 'gearman/gearman.stub', 'gearman_worker_clone' => 'gearman/gearman.stub', 'gearman_worker_create' => 'gearman/gearman.stub', 'gearman_worker_echo' => 'gearman/gearman.stub', 'gearman_worker_errno' => 'gearman/gearman.stub', 'gearman_worker_error' => 'gearman/gearman.stub', 'gearman_worker_grab_job' => 'gearman/gearman.stub', 'gearman_worker_options' => 'gearman/gearman.stub', 'gearman_worker_register' => 'gearman/gearman.stub', 'gearman_worker_remove_options' => 'gearman/gearman.stub', 'gearman_worker_return_code' => 'gearman/gearman.stub', 'gearman_worker_set_options' => 'gearman/gearman.stub', 'gearman_worker_set_timeout' => 'gearman/gearman.stub', 'gearman_worker_timeout' => 'gearman/gearman.stub', 'gearman_worker_unregister' => 'gearman/gearman.stub', 'gearman_worker_unregister_all' => 'gearman/gearman.stub', 'gearman_worker_wait' => 'gearman/gearman.stub', 'gearman_worker_work' => 'gearman/gearman.stub', 'geoip_asnum_by_name' => 'geoip/geoip.stub', 'geoip_continent_code_by_name' => 'geoip/geoip.stub', 'geoip_country_code3_by_name' => 'geoip/geoip.stub', 'geoip_country_code_by_name' => 'geoip/geoip.stub', 'geoip_country_name_by_name' => 'geoip/geoip.stub', 'geoip_database_info' => 'geoip/geoip.stub', 'geoip_db_avail' => 'geoip/geoip.stub', 'geoip_db_filename' => 'geoip/geoip.stub', 'geoip_db_get_all_info' => 'geoip/geoip.stub', 'geoip_id_by_name' => 'geoip/geoip.stub', 'geoip_isp_by_name' => 'geoip/geoip.stub', 'geoip_netspeedcell_by_name' => 'geoip/geoip.stub', 'geoip_org_by_name' => 'geoip/geoip.stub', 'geoip_record_by_name' => 'geoip/geoip.stub', 'geoip_region_by_name' => 'geoip/geoip.stub', 'geoip_region_name_by_code' => 'geoip/geoip.stub', 'geoip_setup_custom_directory' => 'geoip/geoip.stub', 'geoip_time_zone_by_country_and_region' => 'geoip/geoip.stub', 'get_browser' => 'standard/standard_7.stub', 'get_call_stack' => 'ZendDebugger/ZendDebugger.stub', 'get_called_class' => 'Core/Core.stub', 'get_cfg_var' => 'standard/standard_3.stub', 'get_class' => 'Core/Core.stub', 'get_class_methods' => 'Core/Core.stub', 'get_class_vars' => 'Core/Core.stub', 'get_current_user' => 'standard/standard_3.stub', 'get_debug_type' => 'standard/standard_9.stub', 'get_declared_classes' => 'Core/Core.stub', 'get_declared_interfaces' => 'Core/Core.stub', 'get_declared_traits' => 'Core/Core.stub', 'get_defined_constants' => 'Core/Core.stub', 'get_defined_functions' => 'Core/Core.stub', 'get_defined_vars' => 'Core/Core.stub', 'get_extension_funcs' => 'Core/Core.stub', 'get_headers' => 'standard/standard_6.stub', 'get_html_translation_table' => 'standard/standard_0.stub', 'get_include_path' => 'standard/standard_4.stub', 'get_included_files' => 'Core/Core.stub', 'get_loaded_extensions' => 'Core/Core.stub', 'get_magic_quotes_gpc' => 'standard/standard_3.stub', 'get_magic_quotes_runtime' => 'standard/standard_3.stub', 'get_mangled_object_vars' => 'standard/standard_9.stub', 'get_meta_tags' => 'standard/standard_6.stub', 'get_object_vars' => 'Core/Core.stub', 'get_parent_class' => 'Core/Core.stub', 'get_required_files' => 'Core/Core.stub', 'get_resource_id' => 'standard/standard_9.stub', 'get_resource_type' => 'Core/Core.stub', 'get_resources' => 'Core/Core.stub', 'getallheaders' => 'standard/standard_4.stub', 'getcwd' => 'standard/standard_7.stub', 'getdate' => 'date/date.stub', 'getdir' => 'standard/standard_7.stub', 'getenv' => 'standard/standard_3.stub', 'gethostbyaddr' => 'standard/standard_4.stub', 'gethostbyname' => 'standard/standard_4.stub', 'gethostbynamel' => 'standard/standard_4.stub', 'gethostname' => 'standard/standard_4.stub', 'getimagesize' => 'standard/standard_0.stub', 'getimagesizefromstring' => 'standard/standard_8.stub', 'getlastmod' => 'standard/standard_3.stub', 'getmxrr' => 'standard/standard_4.stub', 'getmygid' => 'standard/standard_2.stub', 'getmyinode' => 'standard/standard_2.stub', 'getmypid' => 'standard/standard_2.stub', 'getmyuid' => 'standard/standard_2.stub', 'getopt' => 'standard/standard_3.stub', 'getprotobyname' => 'standard/standard_2.stub', 'getprotobynumber' => 'standard/standard_2.stub', 'getrandmax' => 'random/random.stub', 'getrusage' => 'standard/standard_3.stub', 'getservbyname' => 'standard/standard_2.stub', 'getservbyport' => 'standard/standard_2.stub', 'gettext' => 'gettext/gettext.stub', 'gettimeofday' => 'standard/standard_3.stub', 'gettype' => 'standard/standard_5.stub', 'glob' => 'standard/standard_7.stub', 'gmdate' => 'date/date.stub', 'gmmktime' => 'date/date.stub', 'gmp_abs' => 'gmp/gmp.stub', 'gmp_add' => 'gmp/gmp.stub', 'gmp_and' => 'gmp/gmp.stub', 'gmp_binomial' => 'gmp/gmp.stub', 'gmp_clrbit' => 'gmp/gmp.stub', 'gmp_cmp' => 'gmp/gmp.stub', 'gmp_com' => 'gmp/gmp.stub', 'gmp_div' => 'gmp/gmp.stub', 'gmp_div_q' => 'gmp/gmp.stub', 'gmp_div_qr' => 'gmp/gmp.stub', 'gmp_div_r' => 'gmp/gmp.stub', 'gmp_divexact' => 'gmp/gmp.stub', 'gmp_export' => 'gmp/gmp.stub', 'gmp_fact' => 'gmp/gmp.stub', 'gmp_gcd' => 'gmp/gmp.stub', 'gmp_gcdext' => 'gmp/gmp.stub', 'gmp_hamdist' => 'gmp/gmp.stub', 'gmp_import' => 'gmp/gmp.stub', 'gmp_init' => 'gmp/gmp.stub', 'gmp_intval' => 'gmp/gmp.stub', 'gmp_invert' => 'gmp/gmp.stub', 'gmp_jacobi' => 'gmp/gmp.stub', 'gmp_kronecker' => 'gmp/gmp.stub', 'gmp_lcm' => 'gmp/gmp.stub', 'gmp_legendre' => 'gmp/gmp.stub', 'gmp_mod' => 'gmp/gmp.stub', 'gmp_mul' => 'gmp/gmp.stub', 'gmp_neg' => 'gmp/gmp.stub', 'gmp_nextprime' => 'gmp/gmp.stub', 'gmp_or' => 'gmp/gmp.stub', 'gmp_perfect_power' => 'gmp/gmp.stub', 'gmp_perfect_square' => 'gmp/gmp.stub', 'gmp_popcount' => 'gmp/gmp.stub', 'gmp_pow' => 'gmp/gmp.stub', 'gmp_powm' => 'gmp/gmp.stub', 'gmp_prob_prime' => 'gmp/gmp.stub', 'gmp_random' => 'gmp/gmp.stub', 'gmp_random_bits' => 'gmp/gmp.stub', 'gmp_random_range' => 'gmp/gmp.stub', 'gmp_random_seed' => 'gmp/gmp.stub', 'gmp_root' => 'gmp/gmp.stub', 'gmp_rootrem' => 'gmp/gmp.stub', 'gmp_scan0' => 'gmp/gmp.stub', 'gmp_scan1' => 'gmp/gmp.stub', 'gmp_setbit' => 'gmp/gmp.stub', 'gmp_sign' => 'gmp/gmp.stub', 'gmp_sqrt' => 'gmp/gmp.stub', 'gmp_sqrtrem' => 'gmp/gmp.stub', 'gmp_strval' => 'gmp/gmp.stub', 'gmp_sub' => 'gmp/gmp.stub', 'gmp_testbit' => 'gmp/gmp.stub', 'gmp_xor' => 'gmp/gmp.stub', 'gmstrftime' => 'date/date.stub', 'gnupg_adddecryptkey' => 'gnupg/gnupg.stub', 'gnupg_addencryptkey' => 'gnupg/gnupg.stub', 'gnupg_addsignkey' => 'gnupg/gnupg.stub', 'gnupg_cleardecryptkeys' => 'gnupg/gnupg.stub', 'gnupg_clearencryptkeys' => 'gnupg/gnupg.stub', 'gnupg_clearsignkeys' => 'gnupg/gnupg.stub', 'gnupg_decrypt' => 'gnupg/gnupg.stub', 'gnupg_decryptverify' => 'gnupg/gnupg.stub', 'gnupg_deletekey' => 'gnupg/gnupg.stub', 'gnupg_encrypt' => 'gnupg/gnupg.stub', 'gnupg_encryptsign' => 'gnupg/gnupg.stub', 'gnupg_export' => 'gnupg/gnupg.stub', 'gnupg_getengineinfo' => 'gnupg/gnupg.stub', 'gnupg_geterror' => 'gnupg/gnupg.stub', 'gnupg_geterrorinfo' => 'gnupg/gnupg.stub', 'gnupg_getprotocol' => 'gnupg/gnupg.stub', 'gnupg_gettrustlist' => 'gnupg/gnupg.stub', 'gnupg_import' => 'gnupg/gnupg.stub', 'gnupg_init' => 'gnupg/gnupg.stub', 'gnupg_keyinfo' => 'gnupg/gnupg.stub', 'gnupg_listsignatures' => 'gnupg/gnupg.stub', 'gnupg_setarmor' => 'gnupg/gnupg.stub', 'gnupg_seterrormode' => 'gnupg/gnupg.stub', 'gnupg_setsignmode' => 'gnupg/gnupg.stub', 'gnupg_sign' => 'gnupg/gnupg.stub', 'gnupg_verify' => 'gnupg/gnupg.stub', 'go' => 'swoole/functions.stub', 'grapheme_extract' => 'intl/intl.stub', 'grapheme_str_split' => 'intl/intl.stub', 'grapheme_stripos' => 'intl/intl.stub', 'grapheme_stristr' => 'intl/intl.stub', 'grapheme_strlen' => 'intl/intl.stub', 'grapheme_strpos' => 'intl/intl.stub', 'grapheme_strripos' => 'intl/intl.stub', 'grapheme_strrpos' => 'intl/intl.stub', 'grapheme_strstr' => 'intl/intl.stub', 'grapheme_substr' => 'intl/intl.stub', 'gregoriantojd' => 'calendar/calendar.stub', 'gzclose' => 'zlib/zlib.stub', 'gzcompress' => 'zlib/zlib.stub', 'gzdecode' => 'zlib/zlib.stub', 'gzdeflate' => 'zlib/zlib.stub', 'gzencode' => 'zlib/zlib.stub', 'gzeof' => 'zlib/zlib.stub', 'gzfile' => 'zlib/zlib.stub', 'gzgetc' => 'zlib/zlib.stub', 'gzgets' => 'zlib/zlib.stub', 'gzgetss' => 'zlib/zlib.stub', 'gzinflate' => 'zlib/zlib.stub', 'gzopen' => 'zlib/zlib.stub', 'gzpassthru' => 'zlib/zlib.stub', 'gzputs' => 'zlib/zlib.stub', 'gzread' => 'zlib/zlib.stub', 'gzrewind' => 'zlib/zlib.stub', 'gzseek' => 'zlib/zlib.stub', 'gztell' => 'zlib/zlib.stub', 'gzuncompress' => 'zlib/zlib.stub', 'gzwrite' => 'zlib/zlib.stub', 'hash' => 'hash/hash.stub', 'hash_algos' => 'hash/hash.stub', 'hash_copy' => 'hash/hash.stub', 'hash_equals' => 'hash/hash.stub', 'hash_file' => 'hash/hash.stub', 'hash_final' => 'hash/hash.stub', 'hash_hkdf' => 'hash/hash.stub', 'hash_hmac' => 'hash/hash.stub', 'hash_hmac_algos' => 'hash/hash.stub', 'hash_hmac_file' => 'hash/hash.stub', 'hash_init' => 'hash/hash.stub', 'hash_pbkdf2' => 'hash/hash.stub', 'hash_update' => 'hash/hash.stub', 'hash_update_file' => 'hash/hash.stub', 'hash_update_stream' => 'hash/hash.stub', 'header' => 'standard/standard_4.stub', 'header_register_callback' => 'standard/standard_8.stub', 'header_remove' => 'standard/standard_4.stub', 'headers_list' => 'standard/standard_4.stub', 'headers_send' => 'frankenphp/frankenphp.stub', 'headers_sent' => 'standard/standard_4.stub', 'hebrev' => 'standard/standard_1.stub', 'hebrevc' => 'standard/standard_1.stub', 'hex2bin' => 'standard/_standard_manual.stub', 'hexdec' => 'standard/standard_3.stub', 'highlight_file' => 'standard/standard_4.stub', 'highlight_string' => 'standard/standard_4.stub', 'hrtime' => 'standard/standard_4.stub', 'html_entity_decode' => 'standard/standard_0.stub', 'htmlentities' => 'standard/standard_0.stub', 'htmlspecialchars' => 'standard/standard_0.stub', 'htmlspecialchars_decode' => 'standard/standard_0.stub', 'http_build_cookie' => 'http/http.stub', 'http_build_query' => 'standard/standard_2.stub', 'http_build_str' => 'http/http.stub', 'http_build_url' => 'http/http.stub', 'http_cache_etag' => 'http/http.stub', 'http_cache_last_modified' => 'http/http.stub', 'http_chunked_decode' => 'http/http.stub', 'http_clear_last_response_headers' => 'standard/standard_10.stub', 'http_date' => 'http/http.stub', 'http_deflate' => 'http/http.stub', 'http_get' => 'http/http.stub', 'http_get_last_response_headers' => 'standard/standard_10.stub', 'http_get_request_body' => 'http/http.stub', 'http_get_request_body_stream' => 'http/http.stub', 'http_get_request_headers' => 'http/http.stub', 'http_head' => 'http/http.stub', 'http_inflate' => 'http/http.stub', 'http_match_etag' => 'http/http.stub', 'http_match_modified' => 'http/http.stub', 'http_match_request_header' => 'http/http.stub', 'http_negotiate_charset' => 'http/http.stub', 'http_negotiate_content_type' => 'http/http.stub', 'http_negotiate_language' => 'http/http.stub', 'http_parse_cookie' => 'http/http.stub', 'http_parse_headers' => 'http/http.stub', 'http_parse_message' => 'http/http.stub', 'http_parse_params' => 'http/http.stub', 'http_persistent_handles_clean' => 'http/http.stub', 'http_persistent_handles_count' => 'http/http.stub', 'http_persistent_handles_ident' => 'http/http.stub', 'http_post_data' => 'http/http.stub', 'http_post_fields' => 'http/http.stub', 'http_put_data' => 'http/http.stub', 'http_put_file' => 'http/http.stub', 'http_put_stream' => 'http/http.stub', 'http_redirect' => 'http/http.stub', 'http_request' => 'http/http.stub', 'http_request_body_encode' => 'http/http.stub', 'http_request_method_exists' => 'http/http.stub', 'http_request_method_name' => 'http/http.stub', 'http_request_method_register' => 'http/http.stub', 'http_request_method_unregister' => 'http/http.stub', 'http_response_code' => 'standard/_standard_manual.stub', 'http_send_content_disposition' => 'http/http.stub', 'http_send_content_type' => 'http/http.stub', 'http_send_data' => 'http/http.stub', 'http_send_file' => 'http/http.stub', 'http_send_last_modified' => 'http/http.stub', 'http_send_status' => 'http/http.stub', 'http_send_stream' => 'http/http.stub', 'http_support' => 'http/http.stub', 'http_throttle' => 'http/http.stub', 'hypot' => 'standard/standard_3.stub', 'ibase_add_user' => 'interbase/interbase.stub', 'ibase_affected_rows' => 'interbase/interbase.stub', 'ibase_backup' => 'interbase/interbase.stub', 'ibase_blob_add' => 'interbase/interbase.stub', 'ibase_blob_cancel' => 'interbase/interbase.stub', 'ibase_blob_close' => 'interbase/interbase.stub', 'ibase_blob_create' => 'interbase/interbase.stub', 'ibase_blob_echo' => 'interbase/interbase.stub', 'ibase_blob_get' => 'interbase/interbase.stub', 'ibase_blob_import' => 'interbase/interbase.stub', 'ibase_blob_info' => 'interbase/interbase.stub', 'ibase_blob_open' => 'interbase/interbase.stub', 'ibase_close' => 'interbase/interbase.stub', 'ibase_commit' => 'interbase/interbase.stub', 'ibase_commit_ret' => 'interbase/interbase.stub', 'ibase_connect' => 'interbase/interbase.stub', 'ibase_db_info' => 'interbase/interbase.stub', 'ibase_delete_user' => 'interbase/interbase.stub', 'ibase_drop_db' => 'interbase/interbase.stub', 'ibase_errcode' => 'interbase/interbase.stub', 'ibase_errmsg' => 'interbase/interbase.stub', 'ibase_execute' => 'interbase/interbase.stub', 'ibase_fetch_assoc' => 'interbase/interbase.stub', 'ibase_fetch_object' => 'interbase/interbase.stub', 'ibase_fetch_row' => 'interbase/interbase.stub', 'ibase_field_info' => 'interbase/interbase.stub', 'ibase_free_event_handler' => 'interbase/interbase.stub', 'ibase_free_query' => 'interbase/interbase.stub', 'ibase_free_result' => 'interbase/interbase.stub', 'ibase_gen_id' => 'interbase/interbase.stub', 'ibase_maintain_db' => 'interbase/interbase.stub', 'ibase_modify_user' => 'interbase/interbase.stub', 'ibase_name_result' => 'interbase/interbase.stub', 'ibase_num_fields' => 'interbase/interbase.stub', 'ibase_num_params' => 'interbase/interbase.stub', 'ibase_param_info' => 'interbase/interbase.stub', 'ibase_pconnect' => 'interbase/interbase.stub', 'ibase_prepare' => 'interbase/interbase.stub', 'ibase_query' => 'interbase/interbase.stub', 'ibase_restore' => 'interbase/interbase.stub', 'ibase_rollback' => 'interbase/interbase.stub', 'ibase_rollback_ret' => 'interbase/interbase.stub', 'ibase_server_info' => 'interbase/interbase.stub', 'ibase_service_attach' => 'interbase/interbase.stub', 'ibase_service_detach' => 'interbase/interbase.stub', 'ibase_set_event_handler' => 'interbase/interbase.stub', 'ibase_trans' => 'interbase/interbase.stub', 'ibase_wait_event' => 'interbase/interbase.stub', 'iconv' => 'iconv/iconv.stub', 'iconv_get_encoding' => 'iconv/iconv.stub', 'iconv_mime_decode' => 'iconv/iconv.stub', 'iconv_mime_decode_headers' => 'iconv/iconv.stub', 'iconv_mime_encode' => 'iconv/iconv.stub', 'iconv_set_encoding' => 'iconv/iconv.stub', 'iconv_strlen' => 'iconv/iconv.stub', 'iconv_strpos' => 'iconv/iconv.stub', 'iconv_strrpos' => 'iconv/iconv.stub', 'iconv_substr' => 'iconv/iconv.stub', 'idate' => 'date/date.stub', 'idn_to_ascii' => 'intl/intl.stub', 'idn_to_utf8' => 'intl/intl.stub', 'igbinary_serialize' => 'igbinary/igbinary.stub', 'igbinary_unserialize' => 'igbinary/igbinary.stub', 'ignore_user_abort' => 'standard/standard_4.stub', 'image2wbmp' => 'gd/gd.stub', 'image_type_to_extension' => 'standard/standard_0.stub', 'image_type_to_mime_type' => 'standard/standard_0.stub', 'imageaffine' => 'gd/gd.stub', 'imageaffinematrixconcat' => 'gd/gd.stub', 'imageaffinematrixget' => 'gd/gd.stub', 'imagealphablending' => 'gd/gd.stub', 'imageantialias' => 'gd/gd.stub', 'imagearc' => 'gd/gd.stub', 'imageavif' => 'gd/gd.stub', 'imagebmp' => 'gd/gd.stub', 'imagechar' => 'gd/gd.stub', 'imagecharup' => 'gd/gd.stub', 'imagecolorallocate' => 'gd/gd.stub', 'imagecolorallocatealpha' => 'gd/gd.stub', 'imagecolorat' => 'gd/gd.stub', 'imagecolorclosest' => 'gd/gd.stub', 'imagecolorclosestalpha' => 'gd/gd.stub', 'imagecolorclosesthwb' => 'gd/gd.stub', 'imagecolordeallocate' => 'gd/gd.stub', 'imagecolorexact' => 'gd/gd.stub', 'imagecolorexactalpha' => 'gd/gd.stub', 'imagecolormatch' => 'gd/gd.stub', 'imagecolorresolve' => 'gd/gd.stub', 'imagecolorresolvealpha' => 'gd/gd.stub', 'imagecolorset' => 'gd/gd.stub', 'imagecolorsforindex' => 'gd/gd.stub', 'imagecolorstotal' => 'gd/gd.stub', 'imagecolortransparent' => 'gd/gd.stub', 'imageconvolution' => 'gd/gd.stub', 'imagecopy' => 'gd/gd.stub', 'imagecopymerge' => 'gd/gd.stub', 'imagecopymergegray' => 'gd/gd.stub', 'imagecopyresampled' => 'gd/gd.stub', 'imagecopyresized' => 'gd/gd.stub', 'imagecreate' => 'gd/gd.stub', 'imagecreatefromavif' => 'gd/gd.stub', 'imagecreatefrombmp' => 'gd/gd.stub', 'imagecreatefromgd' => 'gd/gd.stub', 'imagecreatefromgd2' => 'gd/gd.stub', 'imagecreatefromgd2part' => 'gd/gd.stub', 'imagecreatefromgif' => 'gd/gd.stub', 'imagecreatefromjpeg' => 'gd/gd.stub', 'imagecreatefrompng' => 'gd/gd.stub', 'imagecreatefromstring' => 'gd/gd.stub', 'imagecreatefromtga' => 'gd/gd.stub', 'imagecreatefromwbmp' => 'gd/gd.stub', 'imagecreatefromwebp' => 'gd/gd.stub', 'imagecreatefromxbm' => 'gd/gd.stub', 'imagecreatefromxpm' => 'gd/gd.stub', 'imagecreatetruecolor' => 'gd/gd.stub', 'imagecrop' => 'gd/gd.stub', 'imagecropauto' => 'gd/gd.stub', 'imagedashedline' => 'gd/gd.stub', 'imagedestroy' => 'gd/gd.stub', 'imageellipse' => 'gd/gd.stub', 'imagefill' => 'gd/gd.stub', 'imagefilledarc' => 'gd/gd.stub', 'imagefilledellipse' => 'gd/gd.stub', 'imagefilledpolygon' => 'gd/gd.stub', 'imagefilledrectangle' => 'gd/gd.stub', 'imagefilltoborder' => 'gd/gd.stub', 'imagefilter' => 'gd/gd.stub', 'imageflip' => 'gd/gd.stub', 'imagefontheight' => 'gd/gd.stub', 'imagefontwidth' => 'gd/gd.stub', 'imageftbbox' => 'gd/gd.stub', 'imagefttext' => 'gd/gd.stub', 'imagegammacorrect' => 'gd/gd.stub', 'imagegd' => 'gd/gd.stub', 'imagegd2' => 'gd/gd.stub', 'imagegetclip' => 'gd/gd.stub', 'imagegetinterpolation' => 'gd/gd.stub', 'imagegif' => 'gd/gd.stub', 'imagegrabscreen' => 'gd/gd.stub', 'imagegrabwindow' => 'gd/gd.stub', 'imageinterlace' => 'gd/gd.stub', 'imageistruecolor' => 'gd/gd.stub', 'imagejpeg' => 'gd/gd.stub', 'imagelayereffect' => 'gd/gd.stub', 'imageline' => 'gd/gd.stub', 'imageloadfont' => 'gd/gd.stub', 'imageopenpolygon' => 'gd/gd.stub', 'imagepalettecopy' => 'gd/gd.stub', 'imagepalettetotruecolor' => 'gd/gd.stub', 'imagepng' => 'gd/gd.stub', 'imagepolygon' => 'gd/gd.stub', 'imagepsbbox' => 'gd/gd.stub', 'imagepsencodefont' => 'gd/gd.stub', 'imagepsextendfont' => 'gd/gd.stub', 'imagepsfreefont' => 'gd/gd.stub', 'imagepsloadfont' => 'gd/gd.stub', 'imagepsslantfont' => 'gd/gd.stub', 'imagepstext' => 'gd/gd.stub', 'imagerectangle' => 'gd/gd.stub', 'imageresolution' => 'gd/gd.stub', 'imagerotate' => 'gd/gd.stub', 'imagesavealpha' => 'gd/gd.stub', 'imagescale' => 'gd/gd.stub', 'imagesetbrush' => 'gd/gd.stub', 'imagesetclip' => 'gd/gd.stub', 'imagesetinterpolation' => 'gd/gd.stub', 'imagesetpixel' => 'gd/gd.stub', 'imagesetstyle' => 'gd/gd.stub', 'imagesetthickness' => 'gd/gd.stub', 'imagesettile' => 'gd/gd.stub', 'imagestring' => 'gd/gd.stub', 'imagestringup' => 'gd/gd.stub', 'imagesx' => 'gd/gd.stub', 'imagesy' => 'gd/gd.stub', 'imagetruecolortopalette' => 'gd/gd.stub', 'imagettfbbox' => 'gd/gd.stub', 'imagettftext' => 'gd/gd.stub', 'imagetypes' => 'gd/gd.stub', 'imagewbmp' => 'gd/gd.stub', 'imagewebp' => 'gd/gd.stub', 'imagexbm' => 'gd/gd.stub', 'imap_8bit' => 'imap/imap.stub', 'imap_alerts' => 'imap/imap.stub', 'imap_append' => 'imap/imap.stub', 'imap_base64' => 'imap/imap.stub', 'imap_binary' => 'imap/imap.stub', 'imap_body' => 'imap/imap.stub', 'imap_bodystruct' => 'imap/imap.stub', 'imap_check' => 'imap/imap.stub', 'imap_clearflag_full' => 'imap/imap.stub', 'imap_close' => 'imap/imap.stub', 'imap_create' => 'imap/imap.stub', 'imap_createmailbox' => 'imap/imap.stub', 'imap_delete' => 'imap/imap.stub', 'imap_deletemailbox' => 'imap/imap.stub', 'imap_errors' => 'imap/imap.stub', 'imap_expunge' => 'imap/imap.stub', 'imap_fetch_overview' => 'imap/imap.stub', 'imap_fetchbody' => 'imap/imap.stub', 'imap_fetchheader' => 'imap/imap.stub', 'imap_fetchmime' => 'imap/imap.stub', 'imap_fetchstructure' => 'imap/imap.stub', 'imap_fetchtext' => 'imap/imap.stub', 'imap_gc' => 'imap/imap.stub', 'imap_get_quota' => 'imap/imap.stub', 'imap_get_quotaroot' => 'imap/imap.stub', 'imap_getacl' => 'imap/imap.stub', 'imap_getannotation' => 'imap/imap.stub', 'imap_getmailboxes' => 'imap/imap.stub', 'imap_getsubscribed' => 'imap/imap.stub', 'imap_header' => 'imap/imap.stub', 'imap_headerinfo' => 'imap/imap.stub', 'imap_headers' => 'imap/imap.stub', 'imap_is_open' => 'imap/imap.stub', 'imap_last_error' => 'imap/imap.stub', 'imap_list' => 'imap/imap.stub', 'imap_listmailbox' => 'imap/imap.stub', 'imap_listscan' => 'imap/imap.stub', 'imap_listsubscribed' => 'imap/imap.stub', 'imap_lsub' => 'imap/imap.stub', 'imap_mail' => 'imap/imap.stub', 'imap_mail_compose' => 'imap/imap.stub', 'imap_mail_copy' => 'imap/imap.stub', 'imap_mail_move' => 'imap/imap.stub', 'imap_mailboxmsginfo' => 'imap/imap.stub', 'imap_mime_header_decode' => 'imap/imap.stub', 'imap_msgno' => 'imap/imap.stub', 'imap_mutf7_to_utf8' => 'imap/imap.stub', 'imap_myrights' => 'imap/imap.stub', 'imap_num_msg' => 'imap/imap.stub', 'imap_num_recent' => 'imap/imap.stub', 'imap_open' => 'imap/imap.stub', 'imap_ping' => 'imap/imap.stub', 'imap_qprint' => 'imap/imap.stub', 'imap_rename' => 'imap/imap.stub', 'imap_renamemailbox' => 'imap/imap.stub', 'imap_reopen' => 'imap/imap.stub', 'imap_rfc822_parse_adrlist' => 'imap/imap.stub', 'imap_rfc822_parse_headers' => 'imap/imap.stub', 'imap_rfc822_write_address' => 'imap/imap.stub', 'imap_savebody' => 'imap/imap.stub', 'imap_scan' => 'imap/imap.stub', 'imap_scanmailbox' => 'imap/imap.stub', 'imap_search' => 'imap/imap.stub', 'imap_set_quota' => 'imap/imap.stub', 'imap_setacl' => 'imap/imap.stub', 'imap_setannotation' => 'imap/imap.stub', 'imap_setflag_full' => 'imap/imap.stub', 'imap_sort' => 'imap/imap.stub', 'imap_status' => 'imap/imap.stub', 'imap_status_current' => 'imap/imap.stub', 'imap_subscribe' => 'imap/imap.stub', 'imap_thread' => 'imap/imap.stub', 'imap_timeout' => 'imap/imap.stub', 'imap_uid' => 'imap/imap.stub', 'imap_undelete' => 'imap/imap.stub', 'imap_unsubscribe' => 'imap/imap.stub', 'imap_utf7_decode' => 'imap/imap.stub', 'imap_utf7_encode' => 'imap/imap.stub', 'imap_utf8' => 'imap/imap.stub', 'imap_utf8_to_mutf7' => 'imap/imap.stub', 'implode' => 'standard/standard_1.stub', 'import_request_variables' => 'standard/standard_3.stub', 'in_array' => 'standard/standard_8.stub', 'inet_ntop' => 'standard/standard_3.stub', 'inet_pton' => 'standard/standard_3.stub', 'inflate_add' => 'zlib/zlib.stub', 'inflate_get_read_len' => 'zlib/zlib.stub', 'inflate_get_status' => 'zlib/zlib.stub', 'inflate_init' => 'zlib/zlib.stub', 'ini_alter' => 'standard/standard_4.stub', 'ini_get' => 'standard/standard_4.stub', 'ini_get_all' => 'standard/standard_4.stub', 'ini_parse_quantity' => 'standard/standard_4.stub', 'ini_restore' => 'standard/standard_4.stub', 'ini_set' => 'standard/standard_4.stub', 'inotify_add_watch' => 'inotify/inotify.stub', 'inotify_init' => 'inotify/inotify.stub', 'inotify_queue_len' => 'inotify/inotify.stub', 'inotify_read' => 'inotify/inotify.stub', 'inotify_rm_watch' => 'inotify/inotify.stub', 'intcal_get_maximum' => 'intl/intl.stub', 'intdiv' => 'standard/standard_3.stub', 'interface_exists' => 'Core/Core.stub', 'intl_error_name' => 'intl/intl.stub', 'intl_get' => 'intl/intl.stub', 'intl_get_error_code' => 'intl/intl.stub', 'intl_get_error_message' => 'intl/intl.stub', 'intl_is_failure' => 'intl/intl.stub', 'intlcal_add' => 'intl/intl.stub', 'intlcal_after' => 'intl/intl.stub', 'intlcal_before' => 'intl/intl.stub', 'intlcal_clear' => 'intl/intl.stub', 'intlcal_create_instance' => 'intl/intl.stub', 'intlcal_equals' => 'intl/intl.stub', 'intlcal_field_difference' => 'intl/intl.stub', 'intlcal_from_date_time' => 'intl/intl.stub', 'intlcal_get' => 'intl/intl.stub', 'intlcal_get_actual_maximum' => 'intl/intl.stub', 'intlcal_get_actual_minimum' => 'intl/intl.stub', 'intlcal_get_available_locales' => 'intl/intl.stub', 'intlcal_get_day_of_week_type' => 'intl/intl.stub', 'intlcal_get_error_code' => 'intl/intl.stub', 'intlcal_get_error_message' => 'intl/intl.stub', 'intlcal_get_first_day_of_week' => 'intl/intl.stub', 'intlcal_get_greatest_minimum' => 'intl/intl.stub', 'intlcal_get_keyword_values_for_locale' => 'intl/intl.stub', 'intlcal_get_least_maximum' => 'intl/intl.stub', 'intlcal_get_locale' => 'intl/intl.stub', 'intlcal_get_maximum' => 'intl/intl.stub', 'intlcal_get_minimal_days_in_first_week' => 'intl/intl.stub', 'intlcal_get_minimum' => 'intl/intl.stub', 'intlcal_get_now' => 'intl/intl.stub', 'intlcal_get_repeated_wall_time_option' => 'intl/intl.stub', 'intlcal_get_skipped_wall_time_option' => 'intl/intl.stub', 'intlcal_get_time' => 'intl/intl.stub', 'intlcal_get_time_zone' => 'intl/intl.stub', 'intlcal_get_type' => 'intl/intl.stub', 'intlcal_get_weekend_transition' => 'intl/intl.stub', 'intlcal_greates_minimum' => 'intl/intl.stub', 'intlcal_in_daylight_time' => 'intl/intl.stub', 'intlcal_is_equivalent_to' => 'intl/intl.stub', 'intlcal_is_lenient' => 'intl/intl.stub', 'intlcal_is_set' => 'intl/intl.stub', 'intlcal_is_weekend' => 'intl/intl.stub', 'intlcal_roll' => 'intl/intl.stub', 'intlcal_set' => 'intl/intl.stub', 'intlcal_set_first_day_of_week' => 'intl/intl.stub', 'intlcal_set_lenient' => 'intl/intl.stub', 'intlcal_set_minimal_days_in_first_week' => 'intl/intl.stub', 'intlcal_set_repeated_wall_time_option' => 'intl/intl.stub', 'intlcal_set_skipped_wall_time_option' => 'intl/intl.stub', 'intlcal_set_time' => 'intl/intl.stub', 'intlcal_set_time_zone' => 'intl/intl.stub', 'intlcal_to_date_time' => 'intl/intl.stub', 'intlgregcal_create_instance' => 'intl/intl.stub', 'intlgregcal_get_gregorian_change' => 'intl/intl.stub', 'intlgregcal_is_leap_year' => 'intl/intl.stub', 'intlgregcal_set_gregorian_change' => 'intl/intl.stub', 'intltz_count_equivalent_ids' => 'intl/intl.stub', 'intltz_create_default' => 'intl/intl.stub', 'intltz_create_enumeration' => 'intl/intl.stub', 'intltz_create_time_zone' => 'intl/intl.stub', 'intltz_create_time_zone_id_enumeration' => 'intl/intl.stub', 'intltz_from_date_time_zone' => 'intl/intl.stub', 'intltz_getGMT' => 'intl/intl.stub', 'intltz_get_canonical_id' => 'intl/intl.stub', 'intltz_get_display_name' => 'intl/intl.stub', 'intltz_get_dst_savings' => 'intl/intl.stub', 'intltz_get_equivalent_id' => 'intl/intl.stub', 'intltz_get_error_code' => 'intl/intl.stub', 'intltz_get_error_message' => 'intl/intl.stub', 'intltz_get_gmt' => 'intl/intl.stub', 'intltz_get_iana_id' => 'intl/intl.stub', 'intltz_get_id' => 'intl/intl.stub', 'intltz_get_id_for_windows_id' => 'intl/intl.stub', 'intltz_get_offset' => 'intl/intl.stub', 'intltz_get_raw_offset' => 'intl/intl.stub', 'intltz_get_region' => 'intl/intl.stub', 'intltz_get_tz_data_version' => 'intl/intl.stub', 'intltz_get_unknown' => 'intl/intl.stub', 'intltz_get_windows_id' => 'intl/intl.stub', 'intltz_has_same_rules' => 'intl/intl.stub', 'intltz_to_date_time_zone' => 'intl/intl.stub', 'intltz_use_daylight_time' => 'intl/intl.stub', 'intlz_create_default' => 'intl/intl.stub', 'intval' => 'standard/standard_5.stub', 'ip2long' => 'standard/standard_3.stub', 'iptcembed' => 'standard/standard_0.stub', 'iptcparse' => 'standard/standard_0.stub', 'is_a' => 'Core/Core.stub', 'is_array' => 'standard/standard_5.stub', 'is_bool' => 'standard/standard_5.stub', 'is_callable' => 'standard/standard_5.stub', 'is_countable' => 'standard/standard_5.stub', 'is_dir' => 'standard/standard_7.stub', 'is_double' => 'standard/standard_5.stub', 'is_executable' => 'standard/standard_7.stub', 'is_file' => 'standard/standard_7.stub', 'is_finite' => 'standard/standard_3.stub', 'is_float' => 'standard/standard_5.stub', 'is_infinite' => 'standard/standard_3.stub', 'is_int' => 'standard/standard_5.stub', 'is_integer' => 'standard/standard_5.stub', 'is_iterable' => 'standard/basic.stub', 'is_link' => 'standard/standard_7.stub', 'is_long' => 'standard/standard_5.stub', 'is_nan' => 'standard/standard_3.stub', 'is_null' => 'standard/standard_5.stub', 'is_numeric' => 'standard/standard_5.stub', 'is_object' => 'standard/standard_5.stub', 'is_readable' => 'standard/standard_7.stub', 'is_real' => 'standard/standard_5.stub', 'is_resource' => 'standard/standard_5.stub', 'is_scalar' => 'standard/standard_5.stub', 'is_soap_fault' => 'soap/soap.stub', 'is_string' => 'standard/standard_5.stub', 'is_subclass_of' => 'Core/Core.stub', 'is_uploaded_file' => 'standard/standard_4.stub', 'is_writable' => 'standard/standard_7.stub', 'is_writeable' => 'standard/standard_7.stub', 'iterator_apply' => 'SPL/SPL_f.stub', 'iterator_count' => 'SPL/SPL_f.stub', 'iterator_to_array' => 'SPL/SPL_f.stub', 'java' => 'zend/zend_f.stub', 'java_last_exception_clear' => 'zend/zend_f.stub', 'java_last_exception_get' => 'zend/zend_f.stub', 'java_reload' => 'zend/zend_f.stub', 'java_require' => 'zend/zend_f.stub', 'java_set_encoding' => 'zend/zend_f.stub', 'java_set_ignore_case' => 'zend/zend_f.stub', 'java_throw_exceptions' => 'zend/zend_f.stub', 'jddayofweek' => 'calendar/calendar.stub', 'jdmonthname' => 'calendar/calendar.stub', 'jdtofrench' => 'calendar/calendar.stub', 'jdtogregorian' => 'calendar/calendar.stub', 'jdtojewish' => 'calendar/calendar.stub', 'jdtojulian' => 'calendar/calendar.stub', 'jdtounix' => 'calendar/calendar.stub', 'jewishtojd' => 'calendar/calendar.stub', 'jobqueue_license_info' => 'zend/zend_f.stub', 'join' => 'standard/standard_1.stub', 'jpeg2wbmp' => 'gd/gd.stub', 'json_decode' => 'json/json.stub', 'json_encode' => 'json/json.stub', 'json_last_error' => 'json/json.stub', 'json_last_error_msg' => 'json/json.stub', 'json_validate' => 'json/json.stub', 'juliantojd' => 'calendar/calendar.stub', 'kafka_err2name' => 'simple_kafka_client/functions.stub', 'kafka_err2str' => 'simple_kafka_client/functions.stub', 'kafka_get_err_descs' => 'simple_kafka_client/functions.stub', 'kafka_offset_tail' => 'simple_kafka_client/functions.stub', 'kafka_thread_cnt' => 'simple_kafka_client/functions.stub', 'key' => 'standard/standard_8.stub', 'key_exists' => 'standard/standard_9.stub', 'krsort' => 'standard/standard_8.stub', 'ksort' => 'standard/standard_8.stub', 'lcfirst' => 'standard/standard_1.stub', 'lcg_value' => 'random/random.stub', 'lchgrp' => 'standard/standard_7.stub', 'lchown' => 'standard/standard_7.stub', 'ldap_8859_to_t61' => 'ldap/ldap.stub', 'ldap_add' => 'ldap/ldap.stub', 'ldap_add_ext' => 'ldap/ldap.stub', 'ldap_bind' => 'ldap/ldap.stub', 'ldap_bind_ext' => 'ldap/ldap.stub', 'ldap_close' => 'ldap/ldap.stub', 'ldap_compare' => 'ldap/ldap.stub', 'ldap_connect' => 'ldap/ldap.stub', 'ldap_control_paged_result' => 'ldap/ldap.stub', 'ldap_control_paged_result_response' => 'ldap/ldap.stub', 'ldap_count_entries' => 'ldap/ldap.stub', 'ldap_count_references' => 'ldap/ldap.stub', 'ldap_delete' => 'ldap/ldap.stub', 'ldap_delete_ext' => 'ldap/ldap.stub', 'ldap_dn2ufn' => 'ldap/ldap.stub', 'ldap_err2str' => 'ldap/ldap.stub', 'ldap_errno' => 'ldap/ldap.stub', 'ldap_error' => 'ldap/ldap.stub', 'ldap_escape' => 'ldap/ldap.stub', 'ldap_exop' => 'ldap/ldap.stub', 'ldap_exop_passwd' => 'ldap/ldap.stub', 'ldap_exop_refresh' => 'ldap/ldap.stub', 'ldap_exop_sync' => 'ldap/ldap.stub', 'ldap_exop_whoami' => 'ldap/ldap.stub', 'ldap_explode_dn' => 'ldap/ldap.stub', 'ldap_first_attribute' => 'ldap/ldap.stub', 'ldap_first_entry' => 'ldap/ldap.stub', 'ldap_first_reference' => 'ldap/ldap.stub', 'ldap_free_result' => 'ldap/ldap.stub', 'ldap_get_attributes' => 'ldap/ldap.stub', 'ldap_get_dn' => 'ldap/ldap.stub', 'ldap_get_entries' => 'ldap/ldap.stub', 'ldap_get_option' => 'ldap/ldap.stub', 'ldap_get_values' => 'ldap/ldap.stub', 'ldap_get_values_len' => 'ldap/ldap.stub', 'ldap_list' => 'ldap/ldap.stub', 'ldap_mod_add' => 'ldap/ldap.stub', 'ldap_mod_add_ext' => 'ldap/ldap.stub', 'ldap_mod_del' => 'ldap/ldap.stub', 'ldap_mod_del_ext' => 'ldap/ldap.stub', 'ldap_mod_replace' => 'ldap/ldap.stub', 'ldap_mod_replace_ext' => 'ldap/ldap.stub', 'ldap_modify' => 'ldap/ldap.stub', 'ldap_modify_batch' => 'ldap/ldap.stub', 'ldap_next_attribute' => 'ldap/ldap.stub', 'ldap_next_entry' => 'ldap/ldap.stub', 'ldap_next_reference' => 'ldap/ldap.stub', 'ldap_parse_exop' => 'ldap/ldap.stub', 'ldap_parse_reference' => 'ldap/ldap.stub', 'ldap_parse_result' => 'ldap/ldap.stub', 'ldap_read' => 'ldap/ldap.stub', 'ldap_rename' => 'ldap/ldap.stub', 'ldap_rename_ext' => 'ldap/ldap.stub', 'ldap_sasl_bind' => 'ldap/ldap.stub', 'ldap_search' => 'ldap/ldap.stub', 'ldap_set_option' => 'ldap/ldap.stub', 'ldap_set_rebind_proc' => 'ldap/ldap.stub', 'ldap_sort' => 'ldap/ldap.stub', 'ldap_start_tls' => 'ldap/ldap.stub', 'ldap_t61_to_8859' => 'ldap/ldap.stub', 'ldap_unbind' => 'ldap/ldap.stub', 'levenshtein' => 'standard/standard_2.stub', 'libvirt_check_version' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_all_domain_stats' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_capabilities' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_emulator' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_encrypted' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_hostname' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_hypervisor' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_information' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_machine_types' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_maxvcpus' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_nic_models' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_secure' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_soundhw_models' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_sysinfo' => 'libvirt-php/libvirt-php.stub', 'libvirt_connect_get_uri' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_attach_device' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_block_commit' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_block_job_abort' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_block_job_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_block_job_set_speed' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_block_resize' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_block_stats' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_change_boot_devices' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_change_memory' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_change_vcpus' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_core_dump' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_create' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_create_xml' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_define_xml' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_destroy' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_detach_device' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_disk_add' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_disk_remove' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_autostart' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_block_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_connect' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_counts' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_disk_devices' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_id' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_interface_devices' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_job_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_metadata' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_network_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_next_dev_ids' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_screen_dimensions' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_screenshot' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_screenshot_api' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_uuid' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_uuid_string' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_get_xml_desc' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_has_current_snapshot' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_interface_addresses' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_interface_stats' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_is_active' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_is_persistent' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_lookup_by_id' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_lookup_by_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_lookup_by_uuid' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_lookup_by_uuid_string' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_managedsave' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_memory_peek' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_memory_stats' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_migrate' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_migrate_to_uri' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_migrate_to_uri2' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_new' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_new_get_vnc' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_nic_add' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_nic_remove' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_qemu_agent_command' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_reboot' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_reset' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_resume' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_send_key_api' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_send_keys' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_send_pointer_event' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_set_autostart' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_set_max_memory' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_set_memory' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_set_memory_flags' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_set_metadata' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_shutdown' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_snapshot_create' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_snapshot_current' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_snapshot_delete' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_snapshot_get_xml' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_snapshot_lookup_by_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_snapshot_revert' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_suspend' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_undefine' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_undefine_flags' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_update_device' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_xml_from_native' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_xml_to_native' => 'libvirt-php/libvirt-php.stub', 'libvirt_domain_xml_xpath' => 'libvirt-php/libvirt-php.stub', 'libvirt_get_iso_images' => 'libvirt-php/libvirt-php.stub', 'libvirt_get_last_error' => 'libvirt-php/libvirt-php.stub', 'libvirt_get_last_error_code' => 'libvirt-php/libvirt-php.stub', 'libvirt_get_last_error_domain' => 'libvirt-php/libvirt-php.stub', 'libvirt_has_feature' => 'libvirt-php/libvirt-php.stub', 'libvirt_image_create' => 'libvirt-php/libvirt-php.stub', 'libvirt_image_remove' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_active_domain_ids' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_active_domains' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_active_storagepools' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_all_networks' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_all_nwfilters' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_domain_resources' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_domain_snapshots' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_domains' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_inactive_domains' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_inactive_storagepools' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_networks' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_nodedevs' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_nwfilters' => 'libvirt-php/libvirt-php.stub', 'libvirt_list_storagepools' => 'libvirt-php/libvirt-php.stub', 'libvirt_logfile_set' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_define_xml' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_active' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_autostart' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_bridge' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_information' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_uuid' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_uuid_string' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_get_xml_desc' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_set_active' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_set_autostart' => 'libvirt-php/libvirt-php.stub', 'libvirt_network_undefine' => 'libvirt-php/libvirt-php.stub', 'libvirt_node_get_cpu_stats' => 'libvirt-php/libvirt-php.stub', 'libvirt_node_get_cpu_stats_for_each_cpu' => 'libvirt-php/libvirt-php.stub', 'libvirt_node_get_free_memory' => 'libvirt-php/libvirt-php.stub', 'libvirt_node_get_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_node_get_mem_stats' => 'libvirt-php/libvirt-php.stub', 'libvirt_nodedev_capabilities' => 'libvirt-php/libvirt-php.stub', 'libvirt_nodedev_get' => 'libvirt-php/libvirt-php.stub', 'libvirt_nodedev_get_information' => 'libvirt-php/libvirt-php.stub', 'libvirt_nodedev_get_xml_desc' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_define_xml' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_get_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_get_uuid' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_get_uuid_string' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_get_xml_desc' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_lookup_by_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_lookup_by_uuid_string' => 'libvirt-php/libvirt-php.stub', 'libvirt_nwfilter_undefine' => 'libvirt-php/libvirt-php.stub', 'libvirt_print_binding_resources' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_build' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_create' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_define_xml' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_delete' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_destroy' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_get_autostart' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_get_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_get_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_get_uuid_string' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_get_volume_count' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_get_xml_desc' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_is_active' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_list_volumes' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_lookup_by_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_lookup_by_uuid_string' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_lookup_by_volume' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_refresh' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_set_autostart' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagepool_undefine' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_create_xml' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_create_xml_from' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_delete' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_download' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_get_info' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_get_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_get_path' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_get_xml_desc' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_lookup_by_name' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_lookup_by_path' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_resize' => 'libvirt-php/libvirt-php.stub', 'libvirt_storagevolume_upload' => 'libvirt-php/libvirt-php.stub', 'libvirt_stream_abort' => 'libvirt-php/libvirt-php.stub', 'libvirt_stream_close' => 'libvirt-php/libvirt-php.stub', 'libvirt_stream_create' => 'libvirt-php/libvirt-php.stub', 'libvirt_stream_finish' => 'libvirt-php/libvirt-php.stub', 'libvirt_stream_recv' => 'libvirt-php/libvirt-php.stub', 'libvirt_stream_send' => 'libvirt-php/libvirt-php.stub', 'libvirt_version' => 'libvirt-php/libvirt-php.stub', 'libxml_clear_errors' => 'libxml/libxml.stub', 'libxml_disable_entity_loader' => 'libxml/libxml.stub', 'libxml_get_errors' => 'libxml/libxml.stub', 'libxml_get_external_entity_loader' => 'libxml/libxml.stub', 'libxml_get_last_error' => 'libxml/libxml.stub', 'libxml_set_external_entity_loader' => 'libxml/libxml.stub', 'libxml_set_streams_context' => 'libxml/libxml.stub', 'libxml_use_internal_errors' => 'libxml/libxml.stub', 'link' => 'standard/standard_2.stub', 'linkinfo' => 'standard/standard_2.stub', 'locale_accept_from_http' => 'intl/intl.stub', 'locale_canonicalize' => 'intl/intl.stub', 'locale_compose' => 'intl/intl.stub', 'locale_filter_matches' => 'intl/intl.stub', 'locale_get_all_variants' => 'intl/intl.stub', 'locale_get_default' => 'intl/intl.stub', 'locale_get_display_language' => 'intl/intl.stub', 'locale_get_display_name' => 'intl/intl.stub', 'locale_get_display_region' => 'intl/intl.stub', 'locale_get_display_script' => 'intl/intl.stub', 'locale_get_display_variant' => 'intl/intl.stub', 'locale_get_keywords' => 'intl/intl.stub', 'locale_get_primary_language' => 'intl/intl.stub', 'locale_get_region' => 'intl/intl.stub', 'locale_get_script' => 'intl/intl.stub', 'locale_lookup' => 'intl/intl.stub', 'locale_parse' => 'intl/intl.stub', 'locale_set_default' => 'intl/intl.stub', 'localeconv' => 'standard/standard_1.stub', 'localtime' => 'date/date.stub', 'log' => 'standard/standard_3.stub', 'log10' => 'standard/standard_3.stub', 'log1p' => 'standard/standard_3.stub', 'long2ip' => 'standard/standard_3.stub', 'lstat' => 'standard/standard_7.stub', 'ltrim' => 'standard/standard_1.stub', 'lzf_compress' => 'lzf/lzf.stub', 'lzf_decompress' => 'lzf/lzf.stub', 'lzf_optimized_for' => 'lzf/lzf.stub', 'magic_quotes_runtime' => 'standard/standard_3.stub', 'mail' => 'standard/standard_7.stub', 'mailparse_determine_best_xfer_encoding' => 'mailparse/mailparse.stub', 'mailparse_msg_create' => 'mailparse/mailparse.stub', 'mailparse_msg_extract_part' => 'mailparse/mailparse.stub', 'mailparse_msg_extract_part_file' => 'mailparse/mailparse.stub', 'mailparse_msg_extract_whole_part_file' => 'mailparse/mailparse.stub', 'mailparse_msg_free' => 'mailparse/mailparse.stub', 'mailparse_msg_get_part' => 'mailparse/mailparse.stub', 'mailparse_msg_get_part_data' => 'mailparse/mailparse.stub', 'mailparse_msg_get_structure' => 'mailparse/mailparse.stub', 'mailparse_msg_parse' => 'mailparse/mailparse.stub', 'mailparse_msg_parse_file' => 'mailparse/mailparse.stub', 'mailparse_rfc822_parse_addresses' => 'mailparse/mailparse.stub', 'mailparse_stream_encode' => 'mailparse/mailparse.stub', 'mailparse_uudecode_all' => 'mailparse/mailparse.stub', 'max' => 'standard/standard_8.stub', 'mb_check_encoding' => 'mbstring/mbstring.stub', 'mb_chr' => 'mbstring/mbstring.stub', 'mb_convert_case' => 'mbstring/mbstring.stub', 'mb_convert_encoding' => 'mbstring/mbstring.stub', 'mb_convert_kana' => 'mbstring/mbstring.stub', 'mb_convert_variables' => 'mbstring/mbstring.stub', 'mb_decode_mimeheader' => 'mbstring/mbstring.stub', 'mb_decode_numericentity' => 'mbstring/mbstring.stub', 'mb_detect_encoding' => 'mbstring/mbstring.stub', 'mb_detect_order' => 'mbstring/mbstring.stub', 'mb_encode_mimeheader' => 'mbstring/mbstring.stub', 'mb_encode_numericentity' => 'mbstring/mbstring.stub', 'mb_encoding_aliases' => 'mbstring/mbstring.stub', 'mb_ereg' => 'mbstring/mbstring.stub', 'mb_ereg_match' => 'mbstring/mbstring.stub', 'mb_ereg_replace' => 'mbstring/mbstring.stub', 'mb_ereg_replace_callback' => 'mbstring/mbstring.stub', 'mb_ereg_search' => 'mbstring/mbstring.stub', 'mb_ereg_search_getpos' => 'mbstring/mbstring.stub', 'mb_ereg_search_getregs' => 'mbstring/mbstring.stub', 'mb_ereg_search_init' => 'mbstring/mbstring.stub', 'mb_ereg_search_pos' => 'mbstring/mbstring.stub', 'mb_ereg_search_regs' => 'mbstring/mbstring.stub', 'mb_ereg_search_setpos' => 'mbstring/mbstring.stub', 'mb_eregi' => 'mbstring/mbstring.stub', 'mb_eregi_replace' => 'mbstring/mbstring.stub', 'mb_get_info' => 'mbstring/mbstring.stub', 'mb_http_input' => 'mbstring/mbstring.stub', 'mb_http_output' => 'mbstring/mbstring.stub', 'mb_internal_encoding' => 'mbstring/mbstring.stub', 'mb_language' => 'mbstring/mbstring.stub', 'mb_lcfirst' => 'mbstring/mbstring.stub', 'mb_list_encodings' => 'mbstring/mbstring.stub', 'mb_ltrim' => 'mbstring/mbstring.stub', 'mb_ord' => 'mbstring/mbstring.stub', 'mb_output_handler' => 'mbstring/mbstring.stub', 'mb_parse_str' => 'mbstring/mbstring.stub', 'mb_preferred_mime_name' => 'mbstring/mbstring.stub', 'mb_regex_encoding' => 'mbstring/mbstring.stub', 'mb_regex_set_options' => 'mbstring/mbstring.stub', 'mb_rtrim' => 'mbstring/mbstring.stub', 'mb_scrub' => 'mbstring/mbstring.stub', 'mb_send_mail' => 'mbstring/mbstring.stub', 'mb_split' => 'mbstring/mbstring.stub', 'mb_str_pad' => 'mbstring/mbstring.stub', 'mb_str_split' => 'mbstring/mbstring.stub', 'mb_strcut' => 'mbstring/mbstring.stub', 'mb_strimwidth' => 'mbstring/mbstring.stub', 'mb_stripos' => 'mbstring/mbstring.stub', 'mb_stristr' => 'mbstring/mbstring.stub', 'mb_strlen' => 'mbstring/mbstring.stub', 'mb_strpos' => 'mbstring/mbstring.stub', 'mb_strrchr' => 'mbstring/mbstring.stub', 'mb_strrichr' => 'mbstring/mbstring.stub', 'mb_strripos' => 'mbstring/mbstring.stub', 'mb_strrpos' => 'mbstring/mbstring.stub', 'mb_strstr' => 'mbstring/mbstring.stub', 'mb_strtolower' => 'mbstring/mbstring.stub', 'mb_strtoupper' => 'mbstring/mbstring.stub', 'mb_strwidth' => 'mbstring/mbstring.stub', 'mb_substitute_character' => 'mbstring/mbstring.stub', 'mb_substr' => 'mbstring/mbstring.stub', 'mb_substr_count' => 'mbstring/mbstring.stub', 'mb_trim' => 'mbstring/mbstring.stub', 'mb_ucfirst' => 'mbstring/mbstring.stub', 'mbereg' => 'mbstring/mbstring.stub', 'mbereg_match' => 'mbstring/mbstring.stub', 'mbereg_replace' => 'mbstring/mbstring.stub', 'mbereg_search' => 'mbstring/mbstring.stub', 'mbereg_search_getpos' => 'mbstring/mbstring.stub', 'mbereg_search_getregs' => 'mbstring/mbstring.stub', 'mbereg_search_init' => 'mbstring/mbstring.stub', 'mbereg_search_pos' => 'mbstring/mbstring.stub', 'mbereg_search_regs' => 'mbstring/mbstring.stub', 'mbereg_search_setpos' => 'mbstring/mbstring.stub', 'mberegi' => 'mbstring/mbstring.stub', 'mberegi_replace' => 'mbstring/mbstring.stub', 'mbregex_encoding' => 'mbstring/mbstring.stub', 'mbsplit' => 'mbstring/mbstring.stub', 'mcrypt_cbc' => 'mcrypt/mcrypt.stub', 'mcrypt_cfb' => 'mcrypt/mcrypt.stub', 'mcrypt_create_iv' => 'mcrypt/mcrypt.stub', 'mcrypt_decrypt' => 'mcrypt/mcrypt.stub', 'mcrypt_ecb' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_get_algorithms_name' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_get_block_size' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_get_iv_size' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_get_key_size' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_get_modes_name' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_get_supported_key_sizes' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_is_block_algorithm' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_is_block_algorithm_mode' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_is_block_mode' => 'mcrypt/mcrypt.stub', 'mcrypt_enc_self_test' => 'mcrypt/mcrypt.stub', 'mcrypt_encrypt' => 'mcrypt/mcrypt.stub', 'mcrypt_generic' => 'mcrypt/mcrypt.stub', 'mcrypt_generic_deinit' => 'mcrypt/mcrypt.stub', 'mcrypt_generic_end' => 'mcrypt/mcrypt.stub', 'mcrypt_generic_init' => 'mcrypt/mcrypt.stub', 'mcrypt_get_block_size' => 'mcrypt/mcrypt.stub', 'mcrypt_get_cipher_name' => 'mcrypt/mcrypt.stub', 'mcrypt_get_iv_size' => 'mcrypt/mcrypt.stub', 'mcrypt_get_key_size' => 'mcrypt/mcrypt.stub', 'mcrypt_list_algorithms' => 'mcrypt/mcrypt.stub', 'mcrypt_list_modes' => 'mcrypt/mcrypt.stub', 'mcrypt_module_close' => 'mcrypt/mcrypt.stub', 'mcrypt_module_get_algo_block_size' => 'mcrypt/mcrypt.stub', 'mcrypt_module_get_algo_key_size' => 'mcrypt/mcrypt.stub', 'mcrypt_module_get_supported_key_sizes' => 'mcrypt/mcrypt.stub', 'mcrypt_module_is_block_algorithm' => 'mcrypt/mcrypt.stub', 'mcrypt_module_is_block_algorithm_mode' => 'mcrypt/mcrypt.stub', 'mcrypt_module_is_block_mode' => 'mcrypt/mcrypt.stub', 'mcrypt_module_open' => 'mcrypt/mcrypt.stub', 'mcrypt_module_self_test' => 'mcrypt/mcrypt.stub', 'mcrypt_ofb' => 'mcrypt/mcrypt.stub', 'md5' => 'standard/standard_0.stub', 'md5_file' => 'standard/standard_0.stub', 'mdecrypt_generic' => 'mcrypt/mcrypt.stub', 'memcache_add' => 'memcache/memcache.stub', 'memcache_add_server' => 'memcache/memcache.stub', 'memcache_append' => 'memcache/memcache.stub', 'memcache_cas' => 'memcache/memcache.stub', 'memcache_close' => 'memcache/memcache.stub', 'memcache_connect' => 'memcache/memcache.stub', 'memcache_debug' => 'memcache/memcache.stub', 'memcache_decrement' => 'memcache/memcache.stub', 'memcache_delete' => 'memcache/memcache.stub', 'memcache_flush' => 'memcache/memcache.stub', 'memcache_get' => 'memcache/memcache.stub', 'memcache_get_extended_stats' => 'memcache/memcache.stub', 'memcache_get_server_status' => 'memcache/memcache.stub', 'memcache_get_stats' => 'memcache/memcache.stub', 'memcache_get_version' => 'memcache/memcache.stub', 'memcache_increment' => 'memcache/memcache.stub', 'memcache_pconnect' => 'memcache/memcache.stub', 'memcache_prepend' => 'memcache/memcache.stub', 'memcache_replace' => 'memcache/memcache.stub', 'memcache_set' => 'memcache/memcache.stub', 'memcache_set_compress_threshold' => 'memcache/memcache.stub', 'memcache_set_failure_callback' => 'memcache/memcache.stub', 'memcache_set_server_params' => 'memcache/memcache.stub', 'meminfo_dump' => 'meminfo/meminfo.stub', 'memory_get_peak_usage' => 'standard/standard_4.stub', 'memory_get_usage' => 'standard/standard_4.stub', 'memory_reset_peak_usage' => 'standard/standard_4.stub', 'metaphone' => 'standard/standard_8.stub', 'method_exists' => 'Core/Core.stub', 'mhash' => 'hash/hash.stub', 'mhash_count' => 'hash/hash.stub', 'mhash_get_block_size' => 'hash/hash.stub', 'mhash_get_hash_name' => 'hash/hash.stub', 'mhash_keygen_s2k' => 'hash/hash.stub', 'microtime' => 'standard/standard_3.stub', 'mime_content_type' => 'fileinfo/fileinfo.stub', 'min' => 'standard/standard_8.stub', 'ming_keypress' => 'ming/ming.stub', 'ming_setcubicthreshold' => 'ming/ming.stub', 'ming_setscale' => 'ming/ming.stub', 'ming_setswfcompression' => 'ming/ming.stub', 'ming_useconstants' => 'ming/ming.stub', 'ming_useswfversion' => 'ming/ming.stub', 'mkdir' => 'standard/standard_5.stub', 'mktime' => 'date/date.stub', 'money_format' => 'standard/standard_1.stub', 'monitor_custom_event' => 'zend/zend.stub', 'monitor_httperror_event' => 'zend/zend.stub', 'monitor_license_info' => 'zend/zend.stub', 'monitor_pass_error' => 'zend/zend.stub', 'monitor_set_aggregation_hint' => 'zend/zend.stub', 'move_uploaded_file' => 'standard/standard_4.stub', 'mqseries_back' => 'mqseries/mqseries.stub', 'mqseries_begin' => 'mqseries/mqseries.stub', 'mqseries_close' => 'mqseries/mqseries.stub', 'mqseries_cmit' => 'mqseries/mqseries.stub', 'mqseries_conn' => 'mqseries/mqseries.stub', 'mqseries_connx' => 'mqseries/mqseries.stub', 'mqseries_disc' => 'mqseries/mqseries.stub', 'mqseries_get' => 'mqseries/mqseries.stub', 'mqseries_inq' => 'mqseries/mqseries.stub', 'mqseries_open' => 'mqseries/mqseries.stub', 'mqseries_put' => 'mqseries/mqseries.stub', 'mqseries_put1' => 'mqseries/mqseries.stub', 'mqseries_set' => 'mqseries/mqseries.stub', 'mqseries_strerror' => 'mqseries/mqseries.stub', 'ms_GetErrorObj' => 'mapscript/mapscript.stub', 'ms_GetVersion' => 'mapscript/mapscript.stub', 'ms_GetVersionInt' => 'mapscript/mapscript.stub', 'ms_ResetErrorList' => 'mapscript/mapscript.stub', 'ms_TokenizeMap' => 'mapscript/mapscript.stub', 'ms_iogetStdoutBufferBytes' => 'mapscript/mapscript.stub', 'ms_iogetstdoutbufferstring' => 'mapscript/mapscript.stub', 'ms_ioinstallstdinfrombuffer' => 'mapscript/mapscript.stub', 'ms_ioinstallstdouttobuffer' => 'mapscript/mapscript.stub', 'ms_ioresethandlers' => 'mapscript/mapscript.stub', 'ms_iostripstdoutbuffercontentheaders' => 'mapscript/mapscript.stub', 'ms_iostripstdoutbuffercontenttype' => 'mapscript/mapscript.stub', 'msg_get_queue' => 'sysvmsg/sysvmsg.stub', 'msg_queue_exists' => 'sysvmsg/sysvmsg.stub', 'msg_receive' => 'sysvmsg/sysvmsg.stub', 'msg_remove_queue' => 'sysvmsg/sysvmsg.stub', 'msg_send' => 'sysvmsg/sysvmsg.stub', 'msg_set_queue' => 'sysvmsg/sysvmsg.stub', 'msg_stat_queue' => 'sysvmsg/sysvmsg.stub', 'msgfmt_create' => 'intl/intl.stub', 'msgfmt_format' => 'intl/intl.stub', 'msgfmt_format_message' => 'intl/intl.stub', 'msgfmt_get_error_code' => 'intl/intl.stub', 'msgfmt_get_error_message' => 'intl/intl.stub', 'msgfmt_get_locale' => 'intl/intl.stub', 'msgfmt_get_pattern' => 'intl/intl.stub', 'msgfmt_parse' => 'intl/intl.stub', 'msgfmt_parse_message' => 'intl/intl.stub', 'msgfmt_set_pattern' => 'intl/intl.stub', 'msgpack_pack' => 'msgpack/msgpack.stub', 'msgpack_serialize' => 'msgpack/msgpack.stub', 'msgpack_unpack' => 'msgpack/msgpack.stub', 'msgpack_unserialize' => 'msgpack/msgpack.stub', 'mssql_bind' => 'mssql/mssql.stub', 'mssql_close' => 'mssql/mssql.stub', 'mssql_connect' => 'mssql/mssql.stub', 'mssql_data_seek' => 'mssql/mssql.stub', 'mssql_execute' => 'mssql/mssql.stub', 'mssql_fetch_array' => 'mssql/mssql.stub', 'mssql_fetch_assoc' => 'mssql/mssql.stub', 'mssql_fetch_batch' => 'mssql/mssql.stub', 'mssql_fetch_field' => 'mssql/mssql.stub', 'mssql_fetch_object' => 'mssql/mssql.stub', 'mssql_fetch_row' => 'mssql/mssql.stub', 'mssql_field_length' => 'mssql/mssql.stub', 'mssql_field_name' => 'mssql/mssql.stub', 'mssql_field_seek' => 'mssql/mssql.stub', 'mssql_field_type' => 'mssql/mssql.stub', 'mssql_free_result' => 'mssql/mssql.stub', 'mssql_free_statement' => 'mssql/mssql.stub', 'mssql_get_last_message' => 'mssql/mssql.stub', 'mssql_guid_string' => 'mssql/mssql.stub', 'mssql_init' => 'mssql/mssql.stub', 'mssql_min_error_severity' => 'mssql/mssql.stub', 'mssql_min_message_severity' => 'mssql/mssql.stub', 'mssql_next_result' => 'mssql/mssql.stub', 'mssql_num_fields' => 'mssql/mssql.stub', 'mssql_num_rows' => 'mssql/mssql.stub', 'mssql_pconnect' => 'mssql/mssql.stub', 'mssql_query' => 'mssql/mssql.stub', 'mssql_result' => 'mssql/mssql.stub', 'mssql_rows_affected' => 'mssql/mssql.stub', 'mssql_select_db' => 'mssql/mssql.stub', 'mt_getrandmax' => 'random/random.stub', 'mt_rand' => 'random/random.stub', 'mt_srand' => 'random/random.stub', 'mysql' => 'mysql/mysql.stub', 'mysql_affected_rows' => 'mysql/mysql.stub', 'mysql_client_encoding' => 'mysql/mysql.stub', 'mysql_close' => 'mysql/mysql.stub', 'mysql_connect' => 'mysql/mysql.stub', 'mysql_data_seek' => 'mysql/mysql.stub', 'mysql_db_name' => 'mysql/mysql.stub', 'mysql_db_query' => 'mysql/mysql.stub', 'mysql_dbname' => 'mysql/mysql.stub', 'mysql_errno' => 'mysql/mysql.stub', 'mysql_error' => 'mysql/mysql.stub', 'mysql_escape_string' => 'mysql/mysql.stub', 'mysql_fetch_array' => 'mysql/mysql.stub', 'mysql_fetch_assoc' => 'mysql/mysql.stub', 'mysql_fetch_field' => 'mysql/mysql.stub', 'mysql_fetch_lengths' => 'mysql/mysql.stub', 'mysql_fetch_object' => 'mysql/mysql.stub', 'mysql_fetch_row' => 'mysql/mysql.stub', 'mysql_field_flags' => 'mysql/mysql.stub', 'mysql_field_len' => 'mysql/mysql.stub', 'mysql_field_name' => 'mysql/mysql.stub', 'mysql_field_seek' => 'mysql/mysql.stub', 'mysql_field_table' => 'mysql/mysql.stub', 'mysql_field_type' => 'mysql/mysql.stub', 'mysql_fieldflags' => 'mysql/mysql.stub', 'mysql_fieldlen' => 'mysql/mysql.stub', 'mysql_fieldname' => 'mysql/mysql.stub', 'mysql_fieldtable' => 'mysql/mysql.stub', 'mysql_fieldtype' => 'mysql/mysql.stub', 'mysql_free_result' => 'mysql/mysql.stub', 'mysql_freeresult' => 'mysql/mysql.stub', 'mysql_get_client_info' => 'mysql/mysql.stub', 'mysql_get_host_info' => 'mysql/mysql.stub', 'mysql_get_proto_info' => 'mysql/mysql.stub', 'mysql_get_server_info' => 'mysql/mysql.stub', 'mysql_info' => 'mysql/mysql.stub', 'mysql_insert_id' => 'mysql/mysql.stub', 'mysql_list_dbs' => 'mysql/mysql.stub', 'mysql_list_fields' => 'mysql/mysql.stub', 'mysql_list_processes' => 'mysql/mysql.stub', 'mysql_list_tables' => 'mysql/mysql.stub', 'mysql_listdbs' => 'mysql/mysql.stub', 'mysql_listfields' => 'mysql/mysql.stub', 'mysql_listtables' => 'mysql/mysql.stub', 'mysql_num_fields' => 'mysql/mysql.stub', 'mysql_num_rows' => 'mysql/mysql.stub', 'mysql_numfields' => 'mysql/mysql.stub', 'mysql_numrows' => 'mysql/mysql.stub', 'mysql_pconnect' => 'mysql/mysql.stub', 'mysql_ping' => 'mysql/mysql.stub', 'mysql_query' => 'mysql/mysql.stub', 'mysql_real_escape_string' => 'mysql/mysql.stub', 'mysql_result' => 'mysql/mysql.stub', 'mysql_select_db' => 'mysql/mysql.stub', 'mysql_selectdb' => 'mysql/mysql.stub', 'mysql_set_charset' => 'mysql/mysql.stub', 'mysql_stat' => 'mysql/mysql.stub', 'mysql_table_name' => 'mysql/mysql.stub', 'mysql_tablename' => 'mysql/mysql.stub', 'mysql_thread_id' => 'mysql/mysql.stub', 'mysql_unbuffered_query' => 'mysql/mysql.stub', 'mysql_xdevapi\\expression' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysql_xdevapi\\getSession' => 'mysql_xdevapi/mysql_xdevapi.stub', 'mysqli_affected_rows' => 'mysqli/mysqli.stub', 'mysqli_autocommit' => 'mysqli/mysqli.stub', 'mysqli_begin_transaction' => 'mysqli/mysqli.stub', 'mysqli_bind_param' => 'mysqli/mysqli.stub', 'mysqli_bind_result' => 'mysqli/mysqli.stub', 'mysqli_change_user' => 'mysqli/mysqli.stub', 'mysqli_character_set_name' => 'mysqli/mysqli.stub', 'mysqli_client_encoding' => 'mysqli/mysqli.stub', 'mysqli_close' => 'mysqli/mysqli.stub', 'mysqli_commit' => 'mysqli/mysqli.stub', 'mysqli_connect' => 'mysqli/mysqli.stub', 'mysqli_connect_errno' => 'mysqli/mysqli.stub', 'mysqli_connect_error' => 'mysqli/mysqli.stub', 'mysqli_data_seek' => 'mysqli/mysqli.stub', 'mysqli_debug' => 'mysqli/mysqli.stub', 'mysqli_dump_debug_info' => 'mysqli/mysqli.stub', 'mysqli_errno' => 'mysqli/mysqli.stub', 'mysqli_error' => 'mysqli/mysqli.stub', 'mysqli_error_list' => 'mysqli/mysqli.stub', 'mysqli_escape_string' => 'mysqli/mysqli.stub', 'mysqli_execute' => 'mysqli/mysqli.stub', 'mysqli_execute_query' => 'mysqli/mysqli.stub', 'mysqli_fetch' => 'mysqli/mysqli.stub', 'mysqli_fetch_all' => 'mysqli/mysqli.stub', 'mysqli_fetch_array' => 'mysqli/mysqli.stub', 'mysqli_fetch_assoc' => 'mysqli/mysqli.stub', 'mysqli_fetch_column' => 'mysqli/mysqli.stub', 'mysqli_fetch_field' => 'mysqli/mysqli.stub', 'mysqli_fetch_field_direct' => 'mysqli/mysqli.stub', 'mysqli_fetch_fields' => 'mysqli/mysqli.stub', 'mysqli_fetch_lengths' => 'mysqli/mysqli.stub', 'mysqli_fetch_object' => 'mysqli/mysqli.stub', 'mysqli_fetch_row' => 'mysqli/mysqli.stub', 'mysqli_field_count' => 'mysqli/mysqli.stub', 'mysqli_field_seek' => 'mysqli/mysqli.stub', 'mysqli_field_tell' => 'mysqli/mysqli.stub', 'mysqli_free_result' => 'mysqli/mysqli.stub', 'mysqli_get_cache_stats' => 'mysqli/mysqli.stub', 'mysqli_get_charset' => 'mysqli/mysqli.stub', 'mysqli_get_client_info' => 'mysqli/mysqli.stub', 'mysqli_get_client_stats' => 'mysqli/mysqli.stub', 'mysqli_get_client_version' => 'mysqli/mysqli.stub', 'mysqli_get_connection_stats' => 'mysqli/mysqli.stub', 'mysqli_get_host_info' => 'mysqli/mysqli.stub', 'mysqli_get_links_stats' => 'mysqli/mysqli.stub', 'mysqli_get_metadata' => 'mysqli/mysqli.stub', 'mysqli_get_proto_info' => 'mysqli/mysqli.stub', 'mysqli_get_server_info' => 'mysqli/mysqli.stub', 'mysqli_get_server_version' => 'mysqli/mysqli.stub', 'mysqli_get_warnings' => 'mysqli/mysqli.stub', 'mysqli_info' => 'mysqli/mysqli.stub', 'mysqli_init' => 'mysqli/mysqli.stub', 'mysqli_insert_id' => 'mysqli/mysqli.stub', 'mysqli_kill' => 'mysqli/mysqli.stub', 'mysqli_more_results' => 'mysqli/mysqli.stub', 'mysqli_multi_query' => 'mysqli/mysqli.stub', 'mysqli_next_result' => 'mysqli/mysqli.stub', 'mysqli_num_fields' => 'mysqli/mysqli.stub', 'mysqli_num_rows' => 'mysqli/mysqli.stub', 'mysqli_options' => 'mysqli/mysqli.stub', 'mysqli_param_count' => 'mysqli/mysqli.stub', 'mysqli_ping' => 'mysqli/mysqli.stub', 'mysqli_poll' => 'mysqli/mysqli.stub', 'mysqli_prepare' => 'mysqli/mysqli.stub', 'mysqli_query' => 'mysqli/mysqli.stub', 'mysqli_real_connect' => 'mysqli/mysqli.stub', 'mysqli_real_escape_string' => 'mysqli/mysqli.stub', 'mysqli_real_query' => 'mysqli/mysqli.stub', 'mysqli_reap_async_query' => 'mysqli/mysqli.stub', 'mysqli_refresh' => 'mysqli/mysqli.stub', 'mysqli_release_savepoint' => 'mysqli/mysqli.stub', 'mysqli_report' => 'mysqli/mysqli.stub', 'mysqli_rollback' => 'mysqli/mysqli.stub', 'mysqli_savepoint' => 'mysqli/mysqli.stub', 'mysqli_select_db' => 'mysqli/mysqli.stub', 'mysqli_send_long_data' => 'mysqli/mysqli.stub', 'mysqli_set_charset' => 'mysqli/mysqli.stub', 'mysqli_set_local_infile_default' => 'mysqli/mysqli.stub', 'mysqli_set_local_infile_handler' => 'mysqli/mysqli.stub', 'mysqli_set_opt' => 'mysqli/mysqli.stub', 'mysqli_sqlstate' => 'mysqli/mysqli.stub', 'mysqli_ssl_set' => 'mysqli/mysqli.stub', 'mysqli_stat' => 'mysqli/mysqli.stub', 'mysqli_stmt_affected_rows' => 'mysqli/mysqli.stub', 'mysqli_stmt_attr_get' => 'mysqli/mysqli.stub', 'mysqli_stmt_attr_set' => 'mysqli/mysqli.stub', 'mysqli_stmt_bind_param' => 'mysqli/mysqli.stub', 'mysqli_stmt_bind_result' => 'mysqli/mysqli.stub', 'mysqli_stmt_close' => 'mysqli/mysqli.stub', 'mysqli_stmt_data_seek' => 'mysqli/mysqli.stub', 'mysqli_stmt_errno' => 'mysqli/mysqli.stub', 'mysqli_stmt_error' => 'mysqli/mysqli.stub', 'mysqli_stmt_error_list' => 'mysqli/mysqli.stub', 'mysqli_stmt_execute' => 'mysqli/mysqli.stub', 'mysqli_stmt_fetch' => 'mysqli/mysqli.stub', 'mysqli_stmt_field_count' => 'mysqli/mysqli.stub', 'mysqli_stmt_free_result' => 'mysqli/mysqli.stub', 'mysqli_stmt_get_result' => 'mysqli/mysqli.stub', 'mysqli_stmt_get_warnings' => 'mysqli/mysqli.stub', 'mysqli_stmt_init' => 'mysqli/mysqli.stub', 'mysqli_stmt_insert_id' => 'mysqli/mysqli.stub', 'mysqli_stmt_more_results' => 'mysqli/mysqli.stub', 'mysqli_stmt_next_result' => 'mysqli/mysqli.stub', 'mysqli_stmt_num_rows' => 'mysqli/mysqli.stub', 'mysqli_stmt_param_count' => 'mysqli/mysqli.stub', 'mysqli_stmt_prepare' => 'mysqli/mysqli.stub', 'mysqli_stmt_reset' => 'mysqli/mysqli.stub', 'mysqli_stmt_result_metadata' => 'mysqli/mysqli.stub', 'mysqli_stmt_send_long_data' => 'mysqli/mysqli.stub', 'mysqli_stmt_sqlstate' => 'mysqli/mysqli.stub', 'mysqli_stmt_store_result' => 'mysqli/mysqli.stub', 'mysqli_store_result' => 'mysqli/mysqli.stub', 'mysqli_thread_id' => 'mysqli/mysqli.stub', 'mysqli_thread_safe' => 'mysqli/mysqli.stub', 'mysqli_use_result' => 'mysqli/mysqli.stub', 'mysqli_warning_count' => 'mysqli/mysqli.stub', 'natcasesort' => 'standard/standard_8.stub', 'natsort' => 'standard/standard_8.stub', 'ncurses_addch' => 'ncurses/ncurses.stub', 'ncurses_addchnstr' => 'ncurses/ncurses.stub', 'ncurses_addchstr' => 'ncurses/ncurses.stub', 'ncurses_addnstr' => 'ncurses/ncurses.stub', 'ncurses_addstr' => 'ncurses/ncurses.stub', 'ncurses_assume_default_colors' => 'ncurses/ncurses.stub', 'ncurses_attroff' => 'ncurses/ncurses.stub', 'ncurses_attron' => 'ncurses/ncurses.stub', 'ncurses_attrset' => 'ncurses/ncurses.stub', 'ncurses_baudrate' => 'ncurses/ncurses.stub', 'ncurses_beep' => 'ncurses/ncurses.stub', 'ncurses_bkgd' => 'ncurses/ncurses.stub', 'ncurses_bkgdset' => 'ncurses/ncurses.stub', 'ncurses_border' => 'ncurses/ncurses.stub', 'ncurses_bottom_panel' => 'ncurses/ncurses.stub', 'ncurses_can_change_color' => 'ncurses/ncurses.stub', 'ncurses_cbreak' => 'ncurses/ncurses.stub', 'ncurses_clear' => 'ncurses/ncurses.stub', 'ncurses_clrtobot' => 'ncurses/ncurses.stub', 'ncurses_clrtoeol' => 'ncurses/ncurses.stub', 'ncurses_color_content' => 'ncurses/ncurses.stub', 'ncurses_color_set' => 'ncurses/ncurses.stub', 'ncurses_curs_set' => 'ncurses/ncurses.stub', 'ncurses_def_prog_mode' => 'ncurses/ncurses.stub', 'ncurses_def_shell_mode' => 'ncurses/ncurses.stub', 'ncurses_define_key' => 'ncurses/ncurses.stub', 'ncurses_del_panel' => 'ncurses/ncurses.stub', 'ncurses_delay_output' => 'ncurses/ncurses.stub', 'ncurses_delch' => 'ncurses/ncurses.stub', 'ncurses_deleteln' => 'ncurses/ncurses.stub', 'ncurses_delwin' => 'ncurses/ncurses.stub', 'ncurses_doupdate' => 'ncurses/ncurses.stub', 'ncurses_echo' => 'ncurses/ncurses.stub', 'ncurses_echochar' => 'ncurses/ncurses.stub', 'ncurses_end' => 'ncurses/ncurses.stub', 'ncurses_erase' => 'ncurses/ncurses.stub', 'ncurses_erasechar' => 'ncurses/ncurses.stub', 'ncurses_filter' => 'ncurses/ncurses.stub', 'ncurses_flash' => 'ncurses/ncurses.stub', 'ncurses_flushinp' => 'ncurses/ncurses.stub', 'ncurses_getch' => 'ncurses/ncurses.stub', 'ncurses_getmaxyx' => 'ncurses/ncurses.stub', 'ncurses_getmouse' => 'ncurses/ncurses.stub', 'ncurses_getyx' => 'ncurses/ncurses.stub', 'ncurses_halfdelay' => 'ncurses/ncurses.stub', 'ncurses_has_colors' => 'ncurses/ncurses.stub', 'ncurses_has_ic' => 'ncurses/ncurses.stub', 'ncurses_has_il' => 'ncurses/ncurses.stub', 'ncurses_has_key' => 'ncurses/ncurses.stub', 'ncurses_hide_panel' => 'ncurses/ncurses.stub', 'ncurses_hline' => 'ncurses/ncurses.stub', 'ncurses_inch' => 'ncurses/ncurses.stub', 'ncurses_init' => 'ncurses/ncurses.stub', 'ncurses_init_color' => 'ncurses/ncurses.stub', 'ncurses_init_pair' => 'ncurses/ncurses.stub', 'ncurses_insch' => 'ncurses/ncurses.stub', 'ncurses_insdelln' => 'ncurses/ncurses.stub', 'ncurses_insertln' => 'ncurses/ncurses.stub', 'ncurses_insstr' => 'ncurses/ncurses.stub', 'ncurses_instr' => 'ncurses/ncurses.stub', 'ncurses_isendwin' => 'ncurses/ncurses.stub', 'ncurses_keyok' => 'ncurses/ncurses.stub', 'ncurses_keypad' => 'ncurses/ncurses.stub', 'ncurses_killchar' => 'ncurses/ncurses.stub', 'ncurses_longname' => 'ncurses/ncurses.stub', 'ncurses_meta' => 'ncurses/ncurses.stub', 'ncurses_mouse_trafo' => 'ncurses/ncurses.stub', 'ncurses_mouseinterval' => 'ncurses/ncurses.stub', 'ncurses_mousemask' => 'ncurses/ncurses.stub', 'ncurses_move' => 'ncurses/ncurses.stub', 'ncurses_move_panel' => 'ncurses/ncurses.stub', 'ncurses_mvaddch' => 'ncurses/ncurses.stub', 'ncurses_mvaddchnstr' => 'ncurses/ncurses.stub', 'ncurses_mvaddchstr' => 'ncurses/ncurses.stub', 'ncurses_mvaddnstr' => 'ncurses/ncurses.stub', 'ncurses_mvaddstr' => 'ncurses/ncurses.stub', 'ncurses_mvcur' => 'ncurses/ncurses.stub', 'ncurses_mvdelch' => 'ncurses/ncurses.stub', 'ncurses_mvgetch' => 'ncurses/ncurses.stub', 'ncurses_mvhline' => 'ncurses/ncurses.stub', 'ncurses_mvinch' => 'ncurses/ncurses.stub', 'ncurses_mvwaddstr' => 'ncurses/ncurses.stub', 'ncurses_napms' => 'ncurses/ncurses.stub', 'ncurses_new_panel' => 'ncurses/ncurses.stub', 'ncurses_newpad' => 'ncurses/ncurses.stub', 'ncurses_newwin' => 'ncurses/ncurses.stub', 'ncurses_nl' => 'ncurses/ncurses.stub', 'ncurses_nocbreak' => 'ncurses/ncurses.stub', 'ncurses_noecho' => 'ncurses/ncurses.stub', 'ncurses_nonl' => 'ncurses/ncurses.stub', 'ncurses_noqiflush' => 'ncurses/ncurses.stub', 'ncurses_noraw' => 'ncurses/ncurses.stub', 'ncurses_pair_content' => 'ncurses/ncurses.stub', 'ncurses_panel_above' => 'ncurses/ncurses.stub', 'ncurses_panel_below' => 'ncurses/ncurses.stub', 'ncurses_panel_window' => 'ncurses/ncurses.stub', 'ncurses_pnoutrefresh' => 'ncurses/ncurses.stub', 'ncurses_prefresh' => 'ncurses/ncurses.stub', 'ncurses_putp' => 'ncurses/ncurses.stub', 'ncurses_qiflush' => 'ncurses/ncurses.stub', 'ncurses_raw' => 'ncurses/ncurses.stub', 'ncurses_refresh' => 'ncurses/ncurses.stub', 'ncurses_replace_panel' => 'ncurses/ncurses.stub', 'ncurses_reset_prog_mode' => 'ncurses/ncurses.stub', 'ncurses_reset_shell_mode' => 'ncurses/ncurses.stub', 'ncurses_resetty' => 'ncurses/ncurses.stub', 'ncurses_savetty' => 'ncurses/ncurses.stub', 'ncurses_scr_dump' => 'ncurses/ncurses.stub', 'ncurses_scr_init' => 'ncurses/ncurses.stub', 'ncurses_scr_restore' => 'ncurses/ncurses.stub', 'ncurses_scr_set' => 'ncurses/ncurses.stub', 'ncurses_scrl' => 'ncurses/ncurses.stub', 'ncurses_show_panel' => 'ncurses/ncurses.stub', 'ncurses_slk_attr' => 'ncurses/ncurses.stub', 'ncurses_slk_attroff' => 'ncurses/ncurses.stub', 'ncurses_slk_attron' => 'ncurses/ncurses.stub', 'ncurses_slk_attrset' => 'ncurses/ncurses.stub', 'ncurses_slk_clear' => 'ncurses/ncurses.stub', 'ncurses_slk_color' => 'ncurses/ncurses.stub', 'ncurses_slk_init' => 'ncurses/ncurses.stub', 'ncurses_slk_noutrefresh' => 'ncurses/ncurses.stub', 'ncurses_slk_refresh' => 'ncurses/ncurses.stub', 'ncurses_slk_restore' => 'ncurses/ncurses.stub', 'ncurses_slk_set' => 'ncurses/ncurses.stub', 'ncurses_slk_touch' => 'ncurses/ncurses.stub', 'ncurses_standend' => 'ncurses/ncurses.stub', 'ncurses_standout' => 'ncurses/ncurses.stub', 'ncurses_start_color' => 'ncurses/ncurses.stub', 'ncurses_termattrs' => 'ncurses/ncurses.stub', 'ncurses_termname' => 'ncurses/ncurses.stub', 'ncurses_timeout' => 'ncurses/ncurses.stub', 'ncurses_top_panel' => 'ncurses/ncurses.stub', 'ncurses_typeahead' => 'ncurses/ncurses.stub', 'ncurses_ungetch' => 'ncurses/ncurses.stub', 'ncurses_ungetmouse' => 'ncurses/ncurses.stub', 'ncurses_update_panels' => 'ncurses/ncurses.stub', 'ncurses_use_default_colors' => 'ncurses/ncurses.stub', 'ncurses_use_env' => 'ncurses/ncurses.stub', 'ncurses_use_extended_names' => 'ncurses/ncurses.stub', 'ncurses_vidattr' => 'ncurses/ncurses.stub', 'ncurses_vline' => 'ncurses/ncurses.stub', 'ncurses_waddch' => 'ncurses/ncurses.stub', 'ncurses_waddstr' => 'ncurses/ncurses.stub', 'ncurses_wattroff' => 'ncurses/ncurses.stub', 'ncurses_wattron' => 'ncurses/ncurses.stub', 'ncurses_wattrset' => 'ncurses/ncurses.stub', 'ncurses_wborder' => 'ncurses/ncurses.stub', 'ncurses_wclear' => 'ncurses/ncurses.stub', 'ncurses_wcolor_set' => 'ncurses/ncurses.stub', 'ncurses_werase' => 'ncurses/ncurses.stub', 'ncurses_wgetch' => 'ncurses/ncurses.stub', 'ncurses_whline' => 'ncurses/ncurses.stub', 'ncurses_wmouse_trafo' => 'ncurses/ncurses.stub', 'ncurses_wmove' => 'ncurses/ncurses.stub', 'ncurses_wnoutrefresh' => 'ncurses/ncurses.stub', 'ncurses_wrefresh' => 'ncurses/ncurses.stub', 'ncurses_wstandend' => 'ncurses/ncurses.stub', 'ncurses_wstandout' => 'ncurses/ncurses.stub', 'ncurses_wvline' => 'ncurses/ncurses.stub', 'net_get_interfaces' => 'standard/standard_4.stub', 'newrelic_accept_distributed_trace_headers' => 'newrelic/newrelic.stub', 'newrelic_accept_distributed_trace_payload' => 'newrelic/newrelic.stub', 'newrelic_accept_distributed_trace_payload_httpsafe' => 'newrelic/newrelic.stub', 'newrelic_add_custom_parameter' => 'newrelic/newrelic.stub', 'newrelic_add_custom_span_parameter' => 'newrelic/newrelic.stub', 'newrelic_add_custom_tracer' => 'newrelic/newrelic.stub', 'newrelic_background_job' => 'newrelic/newrelic.stub', 'newrelic_capture_params' => 'newrelic/newrelic.stub', 'newrelic_create_distributed_trace_payload' => 'newrelic/newrelic.stub', 'newrelic_custom_metric' => 'newrelic/newrelic.stub', 'newrelic_disable_autorum' => 'newrelic/newrelic.stub', 'newrelic_enable_params' => 'newrelic/newrelic.stub', 'newrelic_end_of_transaction' => 'newrelic/newrelic.stub', 'newrelic_end_transaction' => 'newrelic/newrelic.stub', 'newrelic_get_browser_timing_footer' => 'newrelic/newrelic.stub', 'newrelic_get_browser_timing_header' => 'newrelic/newrelic.stub', 'newrelic_get_linking_metadata' => 'newrelic/newrelic.stub', 'newrelic_get_trace_metadata' => 'newrelic/newrelic.stub', 'newrelic_ignore_apdex' => 'newrelic/newrelic.stub', 'newrelic_ignore_transaction' => 'newrelic/newrelic.stub', 'newrelic_insert_distributed_trace_headers' => 'newrelic/newrelic.stub', 'newrelic_is_sampled' => 'newrelic/newrelic.stub', 'newrelic_name_transaction' => 'newrelic/newrelic.stub', 'newrelic_notice_error' => 'newrelic/newrelic.stub', 'newrelic_record_custom_event' => 'newrelic/newrelic.stub', 'newrelic_record_datastore_segment' => 'newrelic/newrelic.stub', 'newrelic_set_appname' => 'newrelic/newrelic.stub', 'newrelic_set_user_attributes' => 'newrelic/newrelic.stub', 'newrelic_set_user_id' => 'newrelic/newrelic.stub', 'newrelic_start_transaction' => 'newrelic/newrelic.stub', 'next' => 'standard/standard_8.stub', 'ngettext' => 'gettext/gettext.stub', 'nl2br' => 'standard/standard_1.stub', 'nl_langinfo' => 'standard/standard_2.stub', 'normalizer_get_raw_decomposition' => 'intl/intl.stub', 'normalizer_is_normalized' => 'intl/intl.stub', 'normalizer_normalize' => 'intl/intl.stub', 'number_format' => 'standard/standard_3.stub', 'numfmt_create' => 'intl/intl.stub', 'numfmt_format' => 'intl/intl.stub', 'numfmt_format_currency' => 'intl/intl.stub', 'numfmt_get_attribute' => 'intl/intl.stub', 'numfmt_get_error_code' => 'intl/intl.stub', 'numfmt_get_error_message' => 'intl/intl.stub', 'numfmt_get_locale' => 'intl/intl.stub', 'numfmt_get_pattern' => 'intl/intl.stub', 'numfmt_get_symbol' => 'intl/intl.stub', 'numfmt_get_text_attribute' => 'intl/intl.stub', 'numfmt_parse' => 'intl/intl.stub', 'numfmt_parse_currency' => 'intl/intl.stub', 'numfmt_set_attribute' => 'intl/intl.stub', 'numfmt_set_pattern' => 'intl/intl.stub', 'numfmt_set_symbol' => 'intl/intl.stub', 'numfmt_set_text_attribute' => 'intl/intl.stub', 'oauth_get_sbs' => 'oauth/oauth.stub', 'oauth_urlencode' => 'oauth/oauth.stub', 'ob_clean' => 'standard/standard_8.stub', 'ob_deflatehandler' => 'http/http.stub', 'ob_end_clean' => 'standard/standard_8.stub', 'ob_end_flush' => 'standard/standard_8.stub', 'ob_etaghandler' => 'http/http.stub', 'ob_flush' => 'standard/standard_8.stub', 'ob_get_clean' => 'standard/standard_8.stub', 'ob_get_contents' => 'standard/standard_8.stub', 'ob_get_flush' => 'standard/standard_8.stub', 'ob_get_length' => 'standard/standard_8.stub', 'ob_get_level' => 'standard/standard_8.stub', 'ob_get_status' => 'standard/standard_8.stub', 'ob_gzhandler' => 'zlib/zlib.stub', 'ob_iconv_handler' => 'iconv/iconv.stub', 'ob_implicit_flush' => 'standard/standard_8.stub', 'ob_inflatehandler' => 'http/http.stub', 'ob_list_handlers' => 'standard/standard_8.stub', 'ob_start' => 'standard/standard_8.stub', 'ob_tidyhandler' => 'tidy/tidy.stub', 'oci_bind_array_by_name' => 'oci8/oci8.stub', 'oci_bind_by_name' => 'oci8/oci8.stub', 'oci_cancel' => 'oci8/oci8.stub', 'oci_client_version' => 'oci8/oci8.stub', 'oci_close' => 'oci8/oci8.stub', 'oci_commit' => 'oci8/oci8.stub', 'oci_connect' => 'oci8/oci8.stub', 'oci_define_by_name' => 'oci8/oci8.stub', 'oci_error' => 'oci8/oci8.stub', 'oci_execute' => 'oci8/oci8.stub', 'oci_fetch' => 'oci8/oci8.stub', 'oci_fetch_all' => 'oci8/oci8.stub', 'oci_fetch_array' => 'oci8/oci8.stub', 'oci_fetch_assoc' => 'oci8/oci8.stub', 'oci_fetch_object' => 'oci8/oci8.stub', 'oci_fetch_row' => 'oci8/oci8.stub', 'oci_field_is_null' => 'oci8/oci8.stub', 'oci_field_name' => 'oci8/oci8.stub', 'oci_field_precision' => 'oci8/oci8.stub', 'oci_field_scale' => 'oci8/oci8.stub', 'oci_field_size' => 'oci8/oci8.stub', 'oci_field_type' => 'oci8/oci8.stub', 'oci_field_type_raw' => 'oci8/oci8.stub', 'oci_free_cursor' => 'oci8/oci8.stub', 'oci_free_descriptor' => 'oci8/oci8.stub', 'oci_free_statement' => 'oci8/oci8.stub', 'oci_get_implicit_resultset' => 'oci8/oci8.stub', 'oci_internal_debug' => 'oci8/oci8.stub', 'oci_lob_copy' => 'oci8/oci8.stub', 'oci_lob_is_equal' => 'oci8/oci8.stub', 'oci_new_collection' => 'oci8/oci8.stub', 'oci_new_connect' => 'oci8/oci8.stub', 'oci_new_cursor' => 'oci8/oci8.stub', 'oci_new_descriptor' => 'oci8/oci8.stub', 'oci_num_fields' => 'oci8/oci8.stub', 'oci_num_rows' => 'oci8/oci8.stub', 'oci_parse' => 'oci8/oci8.stub', 'oci_password_change' => 'oci8/oci8.stub', 'oci_pconnect' => 'oci8/oci8.stub', 'oci_register_taf_callback' => 'oci8/oci8.stub', 'oci_result' => 'oci8/oci8.stub', 'oci_rollback' => 'oci8/oci8.stub', 'oci_server_version' => 'oci8/oci8.stub', 'oci_set_action' => 'oci8/oci8.stub', 'oci_set_call_timeout' => 'oci8/oci8v3.stub', 'oci_set_client_identifier' => 'oci8/oci8.stub', 'oci_set_client_info' => 'oci8/oci8.stub', 'oci_set_db_operation' => 'oci8/oci8v3.stub', 'oci_set_edition' => 'oci8/oci8.stub', 'oci_set_module_name' => 'oci8/oci8.stub', 'oci_set_prefetch' => 'oci8/oci8.stub', 'oci_set_prefetch_lob' => 'oci8/oci8v3.stub', 'oci_statement_type' => 'oci8/oci8.stub', 'oci_unregister_taf_callback' => 'oci8/oci8.stub', 'ocibindbyname' => 'oci8/oci8.stub', 'ocicancel' => 'oci8/oci8.stub', 'ocicloselob' => 'oci8/oci8.stub', 'ocicollappend' => 'oci8/oci8.stub', 'ocicollassign' => 'oci8/oci8.stub', 'ocicollassignelem' => 'oci8/oci8.stub', 'ocicollgetelem' => 'oci8/oci8.stub', 'ocicollmax' => 'oci8/oci8.stub', 'ocicollsize' => 'oci8/oci8.stub', 'ocicolltrim' => 'oci8/oci8.stub', 'ocicolumnisnull' => 'oci8/oci8.stub', 'ocicolumnname' => 'oci8/oci8.stub', 'ocicolumnprecision' => 'oci8/oci8.stub', 'ocicolumnscale' => 'oci8/oci8.stub', 'ocicolumnsize' => 'oci8/oci8.stub', 'ocicolumntype' => 'oci8/oci8.stub', 'ocicolumntyperaw' => 'oci8/oci8.stub', 'ocicommit' => 'oci8/oci8.stub', 'ocidefinebyname' => 'oci8/oci8.stub', 'ocierror' => 'oci8/oci8.stub', 'ociexecute' => 'oci8/oci8.stub', 'ocifetch' => 'oci8/oci8.stub', 'ocifetchinto' => 'oci8/oci8.stub', 'ocifetchstatement' => 'oci8/oci8.stub', 'ocifreecollection' => 'oci8/oci8.stub', 'ocifreecursor' => 'oci8/oci8.stub', 'ocifreedesc' => 'oci8/oci8.stub', 'ocifreestatement' => 'oci8/oci8.stub', 'ociinternaldebug' => 'oci8/oci8.stub', 'ociloadlob' => 'oci8/oci8.stub', 'ocilogoff' => 'oci8/oci8.stub', 'ocilogon' => 'oci8/oci8.stub', 'ocinewcollection' => 'oci8/oci8.stub', 'ocinewcursor' => 'oci8/oci8.stub', 'ocinewdescriptor' => 'oci8/oci8.stub', 'ocinlogon' => 'oci8/oci8.stub', 'ocinumcols' => 'oci8/oci8.stub', 'ociparse' => 'oci8/oci8.stub', 'ocipasswordchange' => 'oci8/oci8.stub', 'ociplogon' => 'oci8/oci8.stub', 'ociresult' => 'oci8/oci8.stub', 'ocirollback' => 'oci8/oci8.stub', 'ocirowcount' => 'oci8/oci8.stub', 'ocisavelob' => 'oci8/oci8.stub', 'ocisavelobfile' => 'oci8/oci8.stub', 'ociserverversion' => 'oci8/oci8.stub', 'ocisetprefetch' => 'oci8/oci8.stub', 'ocistatementtype' => 'oci8/oci8.stub', 'ociwritelobtofile' => 'oci8/oci8.stub', 'ociwritetemporarylob' => 'oci8/oci8.stub', 'octdec' => 'standard/standard_3.stub', 'odbc_autocommit' => 'odbc/odbc.stub', 'odbc_binmode' => 'odbc/odbc.stub', 'odbc_close' => 'odbc/odbc.stub', 'odbc_close_all' => 'odbc/odbc.stub', 'odbc_columnprivileges' => 'odbc/odbc.stub', 'odbc_columns' => 'odbc/odbc.stub', 'odbc_commit' => 'odbc/odbc.stub', 'odbc_connect' => 'odbc/odbc.stub', 'odbc_connection_string_is_quoted' => 'odbc/odbc.stub', 'odbc_connection_string_quote' => 'odbc/odbc.stub', 'odbc_connection_string_should_quote' => 'odbc/odbc.stub', 'odbc_cursor' => 'odbc/odbc.stub', 'odbc_data_source' => 'odbc/odbc.stub', 'odbc_do' => 'odbc/odbc.stub', 'odbc_error' => 'odbc/odbc.stub', 'odbc_errormsg' => 'odbc/odbc.stub', 'odbc_exec' => 'odbc/odbc.stub', 'odbc_execute' => 'odbc/odbc.stub', 'odbc_fetch_array' => 'odbc/odbc.stub', 'odbc_fetch_into' => 'odbc/odbc.stub', 'odbc_fetch_object' => 'odbc/odbc.stub', 'odbc_fetch_row' => 'odbc/odbc.stub', 'odbc_field_len' => 'odbc/odbc.stub', 'odbc_field_name' => 'odbc/odbc.stub', 'odbc_field_num' => 'odbc/odbc.stub', 'odbc_field_precision' => 'odbc/odbc.stub', 'odbc_field_scale' => 'odbc/odbc.stub', 'odbc_field_type' => 'odbc/odbc.stub', 'odbc_foreignkeys' => 'odbc/odbc.stub', 'odbc_free_result' => 'odbc/odbc.stub', 'odbc_gettypeinfo' => 'odbc/odbc.stub', 'odbc_longreadlen' => 'odbc/odbc.stub', 'odbc_next_result' => 'odbc/odbc.stub', 'odbc_num_fields' => 'odbc/odbc.stub', 'odbc_num_rows' => 'odbc/odbc.stub', 'odbc_pconnect' => 'odbc/odbc.stub', 'odbc_prepare' => 'odbc/odbc.stub', 'odbc_primarykeys' => 'odbc/odbc.stub', 'odbc_procedurecolumns' => 'odbc/odbc.stub', 'odbc_procedures' => 'odbc/odbc.stub', 'odbc_result' => 'odbc/odbc.stub', 'odbc_result_all' => 'odbc/odbc.stub', 'odbc_rollback' => 'odbc/odbc.stub', 'odbc_setoption' => 'odbc/odbc.stub', 'odbc_specialcolumns' => 'odbc/odbc.stub', 'odbc_statistics' => 'odbc/odbc.stub', 'odbc_tableprivileges' => 'odbc/odbc.stub', 'odbc_tables' => 'odbc/odbc.stub', 'opcache_compile_file' => 'Zend OPcache/OPcache.stub', 'opcache_get_configuration' => 'Zend OPcache/OPcache.stub', 'opcache_get_status' => 'Zend OPcache/OPcache.stub', 'opcache_invalidate' => 'Zend OPcache/OPcache.stub', 'opcache_is_script_cached' => 'Zend OPcache/OPcache.stub', 'opcache_reset' => 'Zend OPcache/OPcache.stub', 'opendir' => 'standard/standard_7.stub', 'openlog' => 'standard/standard_7.stub', 'openssl_cipher_iv_length' => 'openssl/openssl.stub', 'openssl_cipher_key_length' => 'openssl/openssl.stub', 'openssl_cms_decrypt' => 'openssl/openssl.stub', 'openssl_cms_encrypt' => 'openssl/openssl.stub', 'openssl_cms_read' => 'openssl/openssl.stub', 'openssl_cms_sign' => 'openssl/openssl.stub', 'openssl_cms_verify' => 'openssl/openssl.stub', 'openssl_csr_export' => 'openssl/openssl.stub', 'openssl_csr_export_to_file' => 'openssl/openssl.stub', 'openssl_csr_get_public_key' => 'openssl/openssl.stub', 'openssl_csr_get_subject' => 'openssl/openssl.stub', 'openssl_csr_new' => 'openssl/openssl.stub', 'openssl_csr_sign' => 'openssl/openssl.stub', 'openssl_decrypt' => 'openssl/openssl.stub', 'openssl_dh_compute_key' => 'openssl/openssl.stub', 'openssl_digest' => 'openssl/openssl.stub', 'openssl_encrypt' => 'openssl/openssl.stub', 'openssl_error_string' => 'openssl/openssl.stub', 'openssl_free_key' => 'openssl/openssl.stub', 'openssl_get_cert_locations' => 'openssl/openssl.stub', 'openssl_get_cipher_methods' => 'openssl/openssl.stub', 'openssl_get_curve_names' => 'openssl/openssl.stub', 'openssl_get_md_methods' => 'openssl/openssl.stub', 'openssl_get_privatekey' => 'openssl/openssl.stub', 'openssl_get_publickey' => 'openssl/openssl.stub', 'openssl_open' => 'openssl/openssl.stub', 'openssl_pbkdf2' => 'openssl/openssl.stub', 'openssl_pkcs12_export' => 'openssl/openssl.stub', 'openssl_pkcs12_export_to_file' => 'openssl/openssl.stub', 'openssl_pkcs12_read' => 'openssl/openssl.stub', 'openssl_pkcs7_decrypt' => 'openssl/openssl.stub', 'openssl_pkcs7_encrypt' => 'openssl/openssl.stub', 'openssl_pkcs7_read' => 'openssl/openssl.stub', 'openssl_pkcs7_sign' => 'openssl/openssl.stub', 'openssl_pkcs7_verify' => 'openssl/openssl.stub', 'openssl_pkey_derive' => 'openssl/openssl.stub', 'openssl_pkey_export' => 'openssl/openssl.stub', 'openssl_pkey_export_to_file' => 'openssl/openssl.stub', 'openssl_pkey_free' => 'openssl/openssl.stub', 'openssl_pkey_get_details' => 'openssl/openssl.stub', 'openssl_pkey_get_private' => 'openssl/openssl.stub', 'openssl_pkey_get_public' => 'openssl/openssl.stub', 'openssl_pkey_new' => 'openssl/openssl.stub', 'openssl_private_decrypt' => 'openssl/openssl.stub', 'openssl_private_encrypt' => 'openssl/openssl.stub', 'openssl_public_decrypt' => 'openssl/openssl.stub', 'openssl_public_encrypt' => 'openssl/openssl.stub', 'openssl_random_pseudo_bytes' => 'openssl/openssl.stub', 'openssl_seal' => 'openssl/openssl.stub', 'openssl_sign' => 'openssl/openssl.stub', 'openssl_spki_export' => 'openssl/openssl.stub', 'openssl_spki_export_challenge' => 'openssl/openssl.stub', 'openssl_spki_new' => 'openssl/openssl.stub', 'openssl_spki_verify' => 'openssl/openssl.stub', 'openssl_verify' => 'openssl/openssl.stub', 'openssl_x509_check_private_key' => 'openssl/openssl.stub', 'openssl_x509_checkpurpose' => 'openssl/openssl.stub', 'openssl_x509_export' => 'openssl/openssl.stub', 'openssl_x509_export_to_file' => 'openssl/openssl.stub', 'openssl_x509_fingerprint' => 'openssl/openssl.stub', 'openssl_x509_free' => 'openssl/openssl.stub', 'openssl_x509_parse' => 'openssl/openssl.stub', 'openssl_x509_read' => 'openssl/openssl.stub', 'openssl_x509_verify' => 'openssl/openssl.stub', 'ord' => 'standard/standard_2.stub', 'output_add_rewrite_var' => 'standard/standard_9.stub', 'output_cache_disable' => 'zend/zend.stub', 'output_cache_disable_compression' => 'zend/zend.stub', 'output_cache_exists' => 'zend/zend.stub', 'output_cache_fetch' => 'zend/zend.stub', 'output_cache_get' => 'zend/zend.stub', 'output_cache_output' => 'zend/zend.stub', 'output_cache_put' => 'zend/zend.stub', 'output_cache_remove' => 'zend/zend.stub', 'output_cache_remove_key' => 'zend/zend.stub', 'output_cache_remove_url' => 'zend/zend.stub', 'output_cache_stop' => 'zend/zend.stub', 'output_reset_rewrite_vars' => 'standard/standard_9.stub', 'pack' => 'standard/standard_7.stub', 'pam_auth' => 'pam/pam.stub', 'pam_chpass' => 'pam/pam.stub', 'parallel\\bootstrap' => 'parallel/parallel.stub', 'parallel\\count' => 'parallel/parallel.stub', 'parallel\\run' => 'parallel/parallel.stub', 'parse_ini_file' => 'standard/standard_4.stub', 'parse_ini_string' => 'standard/standard_4.stub', 'parse_str' => 'standard/standard_2.stub', 'parse_url' => 'standard/standard_2.stub', 'passthru' => 'standard/standard_2.stub', 'password_algos' => 'standard/password.stub', 'password_get_info' => 'standard/password.stub', 'password_hash' => 'standard/password.stub', 'password_needs_rehash' => 'standard/password.stub', 'password_verify' => 'standard/password.stub', 'pathinfo' => 'standard/standard_1.stub', 'pclose' => 'standard/standard_5.stub', 'pcntl_alarm' => 'pcntl/pcntl.stub', 'pcntl_async_signals' => 'pcntl/pcntl.stub', 'pcntl_errno' => 'pcntl/pcntl.stub', 'pcntl_exec' => 'pcntl/pcntl.stub', 'pcntl_fork' => 'pcntl/pcntl.stub', 'pcntl_get_last_error' => 'pcntl/pcntl.stub', 'pcntl_getcpu' => 'pcntl/pcntl.stub', 'pcntl_getcpuaffinity' => 'pcntl/pcntl.stub', 'pcntl_getpriority' => 'pcntl/pcntl.stub', 'pcntl_setcpuaffinity' => 'pcntl/pcntl.stub', 'pcntl_setpriority' => 'pcntl/pcntl.stub', 'pcntl_signal' => 'pcntl/pcntl.stub', 'pcntl_signal_dispatch' => 'pcntl/pcntl.stub', 'pcntl_signal_get_handler' => 'pcntl/pcntl.stub', 'pcntl_sigprocmask' => 'pcntl/pcntl.stub', 'pcntl_sigtimedwait' => 'pcntl/pcntl.stub', 'pcntl_sigwaitinfo' => 'pcntl/pcntl.stub', 'pcntl_strerror' => 'pcntl/pcntl.stub', 'pcntl_unshare' => 'pcntl/pcntl.stub', 'pcntl_wait' => 'pcntl/pcntl.stub', 'pcntl_waitid' => 'pcntl/pcntl.stub', 'pcntl_waitpid' => 'pcntl/pcntl.stub', 'pcntl_wexitstatus' => 'pcntl/pcntl.stub', 'pcntl_wifcontinued' => 'pcntl/pcntl.stub', 'pcntl_wifexited' => 'pcntl/pcntl.stub', 'pcntl_wifsignaled' => 'pcntl/pcntl.stub', 'pcntl_wifstopped' => 'pcntl/pcntl.stub', 'pcntl_wstopsig' => 'pcntl/pcntl.stub', 'pcntl_wtermsig' => 'pcntl/pcntl.stub', 'pcov\\clear' => 'pcov/pcov.stub', 'pcov\\collect' => 'pcov/pcov.stub', 'pcov\\memory' => 'pcov/pcov.stub', 'pcov\\start' => 'pcov/pcov.stub', 'pcov\\stop' => 'pcov/pcov.stub', 'pcov\\waiting' => 'pcov/pcov.stub', 'pdo_drivers' => 'PDO/PDO.stub', 'pfsockopen' => 'standard/standard_7.stub', 'pg_affected_rows' => 'pgsql/pgsql.stub', 'pg_cancel_query' => 'pgsql/pgsql.stub', 'pg_change_password' => 'pgsql/pgsql.stub', 'pg_client_encoding' => 'pgsql/pgsql.stub', 'pg_clientencoding' => 'pgsql/pgsql.stub', 'pg_close' => 'pgsql/pgsql.stub', 'pg_cmdtuples' => 'pgsql/pgsql.stub', 'pg_connect' => 'pgsql/pgsql.stub', 'pg_connect_poll' => 'pgsql/pgsql.stub', 'pg_connection_busy' => 'pgsql/pgsql.stub', 'pg_connection_reset' => 'pgsql/pgsql.stub', 'pg_connection_status' => 'pgsql/pgsql.stub', 'pg_consume_input' => 'pgsql/pgsql.stub', 'pg_convert' => 'pgsql/pgsql.stub', 'pg_copy_from' => 'pgsql/pgsql.stub', 'pg_copy_to' => 'pgsql/pgsql.stub', 'pg_dbname' => 'pgsql/pgsql.stub', 'pg_delete' => 'pgsql/pgsql.stub', 'pg_end_copy' => 'pgsql/pgsql.stub', 'pg_enter_pipeline_mode' => 'pgsql/pgsql.stub', 'pg_errormessage' => 'pgsql/pgsql.stub', 'pg_escape_bytea' => 'pgsql/pgsql.stub', 'pg_escape_identifier' => 'pgsql/pgsql.stub', 'pg_escape_literal' => 'pgsql/pgsql.stub', 'pg_escape_string' => 'pgsql/pgsql.stub', 'pg_exec' => 'pgsql/pgsql.stub', 'pg_execute' => 'pgsql/pgsql.stub', 'pg_exit_pipeline_mode' => 'pgsql/pgsql.stub', 'pg_fetch_all' => 'pgsql/pgsql.stub', 'pg_fetch_all_columns' => 'pgsql/pgsql.stub', 'pg_fetch_array' => 'pgsql/pgsql.stub', 'pg_fetch_assoc' => 'pgsql/pgsql.stub', 'pg_fetch_object' => 'pgsql/pgsql.stub', 'pg_fetch_result' => 'pgsql/pgsql.stub', 'pg_fetch_row' => 'pgsql/pgsql.stub', 'pg_field_is_null' => 'pgsql/pgsql.stub', 'pg_field_name' => 'pgsql/pgsql.stub', 'pg_field_num' => 'pgsql/pgsql.stub', 'pg_field_prtlen' => 'pgsql/pgsql.stub', 'pg_field_size' => 'pgsql/pgsql.stub', 'pg_field_table' => 'pgsql/pgsql.stub', 'pg_field_type' => 'pgsql/pgsql.stub', 'pg_field_type_oid' => 'pgsql/pgsql.stub', 'pg_fieldisnull' => 'pgsql/pgsql.stub', 'pg_fieldname' => 'pgsql/pgsql.stub', 'pg_fieldnum' => 'pgsql/pgsql.stub', 'pg_fieldprtlen' => 'pgsql/pgsql.stub', 'pg_fieldsize' => 'pgsql/pgsql.stub', 'pg_fieldtype' => 'pgsql/pgsql.stub', 'pg_flush' => 'pgsql/pgsql.stub', 'pg_free_result' => 'pgsql/pgsql.stub', 'pg_freeresult' => 'pgsql/pgsql.stub', 'pg_get_notify' => 'pgsql/pgsql.stub', 'pg_get_pid' => 'pgsql/pgsql.stub', 'pg_get_result' => 'pgsql/pgsql.stub', 'pg_getlastoid' => 'pgsql/pgsql.stub', 'pg_host' => 'pgsql/pgsql.stub', 'pg_insert' => 'pgsql/pgsql.stub', 'pg_jit' => 'pgsql/pgsql.stub', 'pg_last_error' => 'pgsql/pgsql.stub', 'pg_last_notice' => 'pgsql/pgsql.stub', 'pg_last_oid' => 'pgsql/pgsql.stub', 'pg_lo_close' => 'pgsql/pgsql.stub', 'pg_lo_create' => 'pgsql/pgsql.stub', 'pg_lo_export' => 'pgsql/pgsql.stub', 'pg_lo_import' => 'pgsql/pgsql.stub', 'pg_lo_open' => 'pgsql/pgsql.stub', 'pg_lo_read' => 'pgsql/pgsql.stub', 'pg_lo_read_all' => 'pgsql/pgsql.stub', 'pg_lo_seek' => 'pgsql/pgsql.stub', 'pg_lo_tell' => 'pgsql/pgsql.stub', 'pg_lo_truncate' => 'pgsql/pgsql.stub', 'pg_lo_unlink' => 'pgsql/pgsql.stub', 'pg_lo_write' => 'pgsql/pgsql.stub', 'pg_loclose' => 'pgsql/pgsql.stub', 'pg_locreate' => 'pgsql/pgsql.stub', 'pg_loexport' => 'pgsql/pgsql.stub', 'pg_loimport' => 'pgsql/pgsql.stub', 'pg_loopen' => 'pgsql/pgsql.stub', 'pg_loread' => 'pgsql/pgsql.stub', 'pg_loreadall' => 'pgsql/pgsql.stub', 'pg_lounlink' => 'pgsql/pgsql.stub', 'pg_lowrite' => 'pgsql/pgsql.stub', 'pg_meta_data' => 'pgsql/pgsql.stub', 'pg_num_fields' => 'pgsql/pgsql.stub', 'pg_num_rows' => 'pgsql/pgsql.stub', 'pg_numfields' => 'pgsql/pgsql.stub', 'pg_numrows' => 'pgsql/pgsql.stub', 'pg_options' => 'pgsql/pgsql.stub', 'pg_parameter_status' => 'pgsql/pgsql.stub', 'pg_pconnect' => 'pgsql/pgsql.stub', 'pg_ping' => 'pgsql/pgsql.stub', 'pg_pipeline_status' => 'pgsql/pgsql.stub', 'pg_pipeline_sync' => 'pgsql/pgsql.stub', 'pg_port' => 'pgsql/pgsql.stub', 'pg_prepare' => 'pgsql/pgsql.stub', 'pg_put_copy_data' => 'pgsql/pgsql.stub', 'pg_put_copy_end' => 'pgsql/pgsql.stub', 'pg_put_line' => 'pgsql/pgsql.stub', 'pg_query' => 'pgsql/pgsql.stub', 'pg_query_params' => 'pgsql/pgsql.stub', 'pg_result' => 'pgsql/pgsql.stub', 'pg_result_error' => 'pgsql/pgsql.stub', 'pg_result_error_field' => 'pgsql/pgsql.stub', 'pg_result_memory_size' => 'pgsql/pgsql.stub', 'pg_result_seek' => 'pgsql/pgsql.stub', 'pg_result_status' => 'pgsql/pgsql.stub', 'pg_select' => 'pgsql/pgsql.stub', 'pg_send_execute' => 'pgsql/pgsql.stub', 'pg_send_prepare' => 'pgsql/pgsql.stub', 'pg_send_query' => 'pgsql/pgsql.stub', 'pg_send_query_params' => 'pgsql/pgsql.stub', 'pg_set_client_encoding' => 'pgsql/pgsql.stub', 'pg_set_error_context_visibility' => 'pgsql/pgsql.stub', 'pg_set_error_verbosity' => 'pgsql/pgsql.stub', 'pg_setclientencoding' => 'pgsql/pgsql.stub', 'pg_socket' => 'pgsql/pgsql.stub', 'pg_socket_poll' => 'pgsql/pgsql.stub', 'pg_trace' => 'pgsql/pgsql.stub', 'pg_transaction_status' => 'pgsql/pgsql.stub', 'pg_tty' => 'pgsql/pgsql.stub', 'pg_unescape_bytea' => 'pgsql/pgsql.stub', 'pg_untrace' => 'pgsql/pgsql.stub', 'pg_update' => 'pgsql/pgsql.stub', 'pg_version' => 'pgsql/pgsql.stub', 'php_egg_logo_guid' => 'standard/standard_0.stub', 'php_ini_loaded_file' => 'standard/standard_0.stub', 'php_ini_scanned_files' => 'standard/standard_0.stub', 'php_logo_guid' => 'standard/standard_0.stub', 'php_real_logo_guid' => 'standard/standard_0.stub', 'php_sapi_name' => 'standard/standard_0.stub', 'php_strip_whitespace' => 'standard/standard_4.stub', 'php_uname' => 'standard/standard_0.stub', 'phpcredits' => 'standard/standard_0.stub', 'phpdbg_break_file' => 'phpdbg/phpdbg.stub', 'phpdbg_break_function' => 'phpdbg/phpdbg.stub', 'phpdbg_break_method' => 'phpdbg/phpdbg.stub', 'phpdbg_break_next' => 'phpdbg/phpdbg.stub', 'phpdbg_clear' => 'phpdbg/phpdbg.stub', 'phpdbg_color' => 'phpdbg/phpdbg.stub', 'phpdbg_end_oplog' => 'phpdbg/phpdbg.stub', 'phpdbg_exec' => 'phpdbg/phpdbg.stub', 'phpdbg_get_executable' => 'phpdbg/phpdbg.stub', 'phpdbg_prompt' => 'phpdbg/phpdbg.stub', 'phpdbg_start_oplog' => 'phpdbg/phpdbg.stub', 'phpinfo' => 'standard/standard_0.stub', 'phpversion' => 'standard/standard_0.stub', 'pi' => 'standard/standard_3.stub', 'png2wbmp' => 'gd/gd.stub', 'popen' => 'standard/standard_5.stub', 'pos' => 'standard/standard_9.stub', 'posix_access' => 'posix/posix.stub', 'posix_ctermid' => 'posix/posix.stub', 'posix_eaccess' => 'posix/posix.stub', 'posix_errno' => 'posix/posix.stub', 'posix_get_last_error' => 'posix/posix.stub', 'posix_getcwd' => 'posix/posix.stub', 'posix_getegid' => 'posix/posix.stub', 'posix_geteuid' => 'posix/posix.stub', 'posix_getgid' => 'posix/posix.stub', 'posix_getgrgid' => 'posix/posix.stub', 'posix_getgrnam' => 'posix/posix.stub', 'posix_getgroups' => 'posix/posix.stub', 'posix_getlogin' => 'posix/posix.stub', 'posix_getpgid' => 'posix/posix.stub', 'posix_getpgrp' => 'posix/posix.stub', 'posix_getpid' => 'posix/posix.stub', 'posix_getppid' => 'posix/posix.stub', 'posix_getpwnam' => 'posix/posix.stub', 'posix_getpwuid' => 'posix/posix.stub', 'posix_getrlimit' => 'posix/posix.stub', 'posix_getsid' => 'posix/posix.stub', 'posix_getuid' => 'posix/posix.stub', 'posix_initgroups' => 'posix/posix.stub', 'posix_isatty' => 'posix/posix.stub', 'posix_kill' => 'posix/posix.stub', 'posix_mkfifo' => 'posix/posix.stub', 'posix_mknod' => 'posix/posix.stub', 'posix_setegid' => 'posix/posix.stub', 'posix_seteuid' => 'posix/posix.stub', 'posix_setgid' => 'posix/posix.stub', 'posix_setpgid' => 'posix/posix.stub', 'posix_setrlimit' => 'posix/posix.stub', 'posix_setsid' => 'posix/posix.stub', 'posix_setuid' => 'posix/posix.stub', 'posix_strerror' => 'posix/posix.stub', 'posix_sysconf' => 'posix/posix.stub', 'posix_times' => 'posix/posix.stub', 'posix_ttyname' => 'posix/posix.stub', 'posix_uname' => 'posix/posix.stub', 'pow' => 'standard/standard_3.stub', 'preg_filter' => 'pcre/pcre.stub', 'preg_grep' => 'pcre/pcre.stub', 'preg_last_error' => 'pcre/pcre.stub', 'preg_last_error_msg' => 'pcre/pcre.stub', 'preg_match' => 'pcre/pcre.stub', 'preg_match_all' => 'pcre/pcre.stub', 'preg_quote' => 'pcre/pcre.stub', 'preg_replace' => 'pcre/pcre.stub', 'preg_replace_callback' => 'pcre/pcre.stub', 'preg_replace_callback_array' => 'pcre/pcre.stub', 'preg_split' => 'pcre/pcre.stub', 'prev' => 'standard/standard_8.stub', 'print_r' => 'standard/standard_4.stub', 'printf' => 'standard/standard_2.stub', 'proc_close' => 'standard/standard_2.stub', 'proc_get_status' => 'standard/standard_2.stub', 'proc_nice' => 'standard/standard_2.stub', 'proc_open' => 'standard/standard_2.stub', 'proc_terminate' => 'standard/standard_2.stub', 'property_exists' => 'Core/Core.stub', 'pspell_add_to_personal' => 'pspell/pspell.stub', 'pspell_add_to_session' => 'pspell/pspell.stub', 'pspell_check' => 'pspell/pspell.stub', 'pspell_clear_session' => 'pspell/pspell.stub', 'pspell_config_create' => 'pspell/pspell.stub', 'pspell_config_data_dir' => 'pspell/pspell.stub', 'pspell_config_dict_dir' => 'pspell/pspell.stub', 'pspell_config_ignore' => 'pspell/pspell.stub', 'pspell_config_mode' => 'pspell/pspell.stub', 'pspell_config_personal' => 'pspell/pspell.stub', 'pspell_config_repl' => 'pspell/pspell.stub', 'pspell_config_runtogether' => 'pspell/pspell.stub', 'pspell_config_save_repl' => 'pspell/pspell.stub', 'pspell_new' => 'pspell/pspell.stub', 'pspell_new_config' => 'pspell/pspell.stub', 'pspell_new_personal' => 'pspell/pspell.stub', 'pspell_save_wordlist' => 'pspell/pspell.stub', 'pspell_store_replacement' => 'pspell/pspell.stub', 'pspell_suggest' => 'pspell/pspell.stub', 'putenv' => 'standard/standard_3.stub', 'quoted_printable_decode' => 'standard/standard_3.stub', 'quoted_printable_encode' => 'standard/standard_3.stub', 'quotemeta' => 'standard/standard_1.stub', 'rad2deg' => 'standard/standard_3.stub', 'radius_acct_open' => 'radius/radius.stub', 'radius_add_server' => 'radius/radius.stub', 'radius_auth_open' => 'radius/radius.stub', 'radius_close' => 'radius/radius.stub', 'radius_config' => 'radius/radius.stub', 'radius_create_request' => 'radius/radius.stub', 'rand' => 'random/random.stub', 'random_bytes' => 'random/random.stub', 'random_int' => 'random/random.stub', 'range' => 'standard/standard_8.stub', 'rawurldecode' => 'standard/standard_2.stub', 'rawurlencode' => 'standard/standard_2.stub', 'rd_kafka_err2str' => 'rdkafka/functions.stub', 'rd_kafka_errno' => 'rdkafka/functions.stub', 'rd_kafka_errno2err' => 'rdkafka/functions.stub', 'rd_kafka_get_err_descs' => 'rdkafka/functions.stub', 'rd_kafka_offset_tail' => 'rdkafka/functions.stub', 'rd_kafka_thread_cnt' => 'rdkafka/functions.stub', 'read_exif_data' => 'exif/exif.stub', 'readdir' => 'standard/standard_7.stub', 'readfile' => 'standard/standard_5.stub', 'readgzfile' => 'zlib/zlib.stub', 'readline' => 'readline/readline.stub', 'readline_add_history' => 'readline/readline.stub', 'readline_callback_handler_install' => 'readline/readline.stub', 'readline_callback_handler_remove' => 'readline/readline.stub', 'readline_callback_read_char' => 'readline/readline.stub', 'readline_clear_history' => 'readline/readline.stub', 'readline_completion_function' => 'readline/readline.stub', 'readline_info' => 'readline/readline.stub', 'readline_list_history' => 'readline/readline.stub', 'readline_on_new_line' => 'readline/readline.stub', 'readline_read_history' => 'readline/readline.stub', 'readline_redisplay' => 'readline/readline.stub', 'readline_write_history' => 'readline/readline.stub', 'readlink' => 'standard/standard_2.stub', 'realpath' => 'standard/standard_6.stub', 'realpath_cache_get' => 'standard/standard_9.stub', 'realpath_cache_size' => 'standard/standard_9.stub', 'recode' => 'recode/recode.stub', 'recode_file' => 'recode/recode.stub', 'recode_string' => 'recode/recode.stub', 'register_event_handler' => 'zend/zend.stub', 'register_shutdown_function' => 'standard/standard_4.stub', 'register_tick_function' => 'standard/standard_4.stub', 'rename' => 'standard/standard_5.stub', 'request_parse_body' => 'standard/standard_10.stub', 'reset' => 'standard/standard_8.stub', 'resourcebundle_count' => 'intl/intl.stub', 'resourcebundle_create' => 'intl/intl.stub', 'resourcebundle_get' => 'intl/intl.stub', 'resourcebundle_get_error_code' => 'intl/intl.stub', 'resourcebundle_get_error_message' => 'intl/intl.stub', 'resourcebundle_locales' => 'intl/intl.stub', 'restore_error_handler' => 'Core/Core.stub', 'restore_exception_handler' => 'Core/Core.stub', 'restore_include_path' => 'standard/standard_4.stub', 'rewind' => 'standard/standard_5.stub', 'rewinddir' => 'standard/standard_7.stub', 'rmdir' => 'standard/standard_5.stub', 'round' => 'standard/standard_3.stub', 'rpmaddtag' => 'rpminfo/rpminfo.stub', 'rpmdbinfo' => 'rpminfo/rpminfo.stub', 'rpmdbsearch' => 'rpminfo/rpminfo.stub', 'rpminfo' => 'rpminfo/rpminfo.stub', 'rpmvercmp' => 'rpminfo/rpminfo.stub', 'rrd_create' => 'rrd/rrd.stub', 'rrd_disconnect' => 'rrd/rrd.stub', 'rrd_error' => 'rrd/rrd.stub', 'rrd_fetch' => 'rrd/rrd.stub', 'rrd_first' => 'rrd/rrd.stub', 'rrd_graph' => 'rrd/rrd.stub', 'rrd_info' => 'rrd/rrd.stub', 'rrd_last' => 'rrd/rrd.stub', 'rrd_lastupdate' => 'rrd/rrd.stub', 'rrd_restore' => 'rrd/rrd.stub', 'rrd_tune' => 'rrd/rrd.stub', 'rrd_update' => 'rrd/rrd.stub', 'rrd_version' => 'rrd/rrd.stub', 'rrd_xport' => 'rrd/rrd.stub', 'rrdc_disconnect' => 'rrd/rrd.stub', 'rsort' => 'standard/standard_8.stub', 'rtrim' => 'standard/standard_1.stub', 'sapi_windows_cp_conv' => 'standard/basic.stub', 'sapi_windows_cp_get' => 'standard/basic.stub', 'sapi_windows_cp_is_utf8' => 'standard/basic.stub', 'sapi_windows_cp_set' => 'standard/basic.stub', 'sapi_windows_generate_ctrl_event' => 'standard/basic.stub', 'sapi_windows_set_ctrl_handler' => 'standard/basic.stub', 'sapi_windows_vt100_support' => 'standard/basic.stub', 'scandir' => 'standard/standard_7.stub', 'sem_acquire' => 'sysvsem/sysvsem.stub', 'sem_get' => 'sysvsem/sysvsem.stub', 'sem_release' => 'sysvsem/sysvsem.stub', 'sem_remove' => 'sysvsem/sysvsem.stub', 'serialize' => 'standard/standard_4.stub', 'session_abort' => 'session/session.stub', 'session_cache_expire' => 'session/session.stub', 'session_cache_limiter' => 'session/session.stub', 'session_commit' => 'session/session.stub', 'session_create_id' => 'session/session.stub', 'session_decode' => 'session/session.stub', 'session_destroy' => 'session/session.stub', 'session_encode' => 'session/session.stub', 'session_gc' => 'session/session.stub', 'session_get_cookie_params' => 'session/session.stub', 'session_id' => 'session/session.stub', 'session_is_registered' => 'session/session.stub', 'session_module_name' => 'session/session.stub', 'session_name' => 'session/session.stub', 'session_regenerate_id' => 'session/session.stub', 'session_register' => 'session/session.stub', 'session_register_shutdown' => 'session/session.stub', 'session_reset' => 'session/session.stub', 'session_save_path' => 'session/session.stub', 'session_set_cookie_params' => 'session/session.stub', 'session_set_save_handler' => 'session/session.stub', 'session_start' => 'session/session.stub', 'session_status' => 'session/session.stub', 'session_unregister' => 'session/session.stub', 'session_unset' => 'session/session.stub', 'session_write_close' => 'session/session.stub', 'set_error_handler' => 'Core/Core.stub', 'set_exception_handler' => 'Core/Core.stub', 'set_file_buffer' => 'standard/standard_6.stub', 'set_include_path' => 'standard/standard_4.stub', 'set_job_failed' => 'zend/zend_f.stub', 'set_magic_quotes_runtime' => 'standard/standard_3.stub', 'set_socket_blocking' => 'standard/standard_6.stub', 'set_time_limit' => 'standard/standard_3.stub', 'setcookie' => 'standard/standard_4.stub', 'setlocale' => 'standard/standard_1.stub', 'setrawcookie' => 'standard/standard_4.stub', 'settype' => 'standard/standard_5.stub', 'sha1' => 'standard/standard_0.stub', 'sha1_file' => 'standard/standard_0.stub', 'shell_exec' => 'standard/standard_2.stub', 'shm_attach' => 'sysvshm/sysvshm.stub', 'shm_detach' => 'sysvshm/sysvshm.stub', 'shm_get_var' => 'sysvshm/sysvshm.stub', 'shm_has_var' => 'sysvshm/sysvshm.stub', 'shm_put_var' => 'sysvshm/sysvshm.stub', 'shm_remove' => 'sysvshm/sysvshm.stub', 'shm_remove_var' => 'sysvshm/sysvshm.stub', 'shmop_close' => 'shmop/shmop.stub', 'shmop_delete' => 'shmop/shmop.stub', 'shmop_open' => 'shmop/shmop.stub', 'shmop_read' => 'shmop/shmop.stub', 'shmop_size' => 'shmop/shmop.stub', 'shmop_write' => 'shmop/shmop.stub', 'show_source' => 'standard/standard_4.stub', 'shuffle' => 'standard/standard_8.stub', 'simdjson_decode' => 'simdjson/simdjson.stub', 'simdjson_is_valid' => 'simdjson/simdjson.stub', 'simdjson_key_count' => 'simdjson/simdjson.stub', 'simdjson_key_exists' => 'simdjson/simdjson.stub', 'simdjson_key_value' => 'simdjson/simdjson.stub', 'similar_text' => 'standard/standard_1.stub', 'simplexml_import_dom' => 'SimpleXML/SimpleXML.stub', 'simplexml_load_file' => 'SimpleXML/SimpleXML.stub', 'simplexml_load_string' => 'SimpleXML/SimpleXML.stub', 'sin' => 'standard/standard_3.stub', 'sinh' => 'standard/standard_3.stub', 'sizeof' => 'standard/standard_9.stub', 'sleep' => 'standard/standard_0.stub', 'snappy_compress' => 'snappy/snappy/snappy.stub', 'snappy_uncompress' => 'snappy/snappy/snappy.stub', 'snmp2_get' => 'snmp/snmp.stub', 'snmp2_getnext' => 'snmp/snmp.stub', 'snmp2_real_walk' => 'snmp/snmp.stub', 'snmp2_set' => 'snmp/snmp.stub', 'snmp2_walk' => 'snmp/snmp.stub', 'snmp3_get' => 'snmp/snmp.stub', 'snmp3_getnext' => 'snmp/snmp.stub', 'snmp3_real_walk' => 'snmp/snmp.stub', 'snmp3_set' => 'snmp/snmp.stub', 'snmp3_walk' => 'snmp/snmp.stub', 'snmp_get_quick_print' => 'snmp/snmp.stub', 'snmp_get_valueretrieval' => 'snmp/snmp.stub', 'snmp_read_mib' => 'snmp/snmp.stub', 'snmp_set_enum_print' => 'snmp/snmp.stub', 'snmp_set_oid_numeric_print' => 'snmp/snmp.stub', 'snmp_set_oid_output_format' => 'snmp/snmp.stub', 'snmp_set_quick_print' => 'snmp/snmp.stub', 'snmp_set_valueretrieval' => 'snmp/snmp.stub', 'snmpget' => 'snmp/snmp.stub', 'snmpgetnext' => 'snmp/snmp.stub', 'snmprealwalk' => 'snmp/snmp.stub', 'snmpset' => 'snmp/snmp.stub', 'snmpwalk' => 'snmp/snmp.stub', 'snmpwalkoid' => 'snmp/snmp.stub', 'socket_accept' => 'sockets/sockets.stub', 'socket_addrinfo_bind' => 'sockets/sockets.stub', 'socket_addrinfo_connect' => 'sockets/sockets.stub', 'socket_addrinfo_explain' => 'sockets/sockets.stub', 'socket_addrinfo_lookup' => 'sockets/sockets.stub', 'socket_atmark' => 'sockets/sockets.stub', 'socket_bind' => 'sockets/sockets.stub', 'socket_clear_error' => 'sockets/sockets.stub', 'socket_close' => 'sockets/sockets.stub', 'socket_cmsg_space' => 'sockets/sockets.stub', 'socket_connect' => 'sockets/sockets.stub', 'socket_create' => 'sockets/sockets.stub', 'socket_create_listen' => 'sockets/sockets.stub', 'socket_create_pair' => 'sockets/sockets.stub', 'socket_export_stream' => 'sockets/sockets.stub', 'socket_get_option' => 'sockets/sockets.stub', 'socket_get_status' => 'standard/standard_6.stub', 'socket_getopt' => 'sockets/sockets.stub', 'socket_getpeername' => 'sockets/sockets.stub', 'socket_getsockname' => 'sockets/sockets.stub', 'socket_import_stream' => 'sockets/sockets.stub', 'socket_last_error' => 'sockets/sockets.stub', 'socket_listen' => 'sockets/sockets.stub', 'socket_read' => 'sockets/sockets.stub', 'socket_recv' => 'sockets/sockets.stub', 'socket_recvfrom' => 'sockets/sockets.stub', 'socket_recvmsg' => 'sockets/sockets.stub', 'socket_select' => 'sockets/sockets.stub', 'socket_send' => 'sockets/sockets.stub', 'socket_sendmsg' => 'sockets/sockets.stub', 'socket_sendto' => 'sockets/sockets.stub', 'socket_set_block' => 'sockets/sockets.stub', 'socket_set_blocking' => 'standard/standard_6.stub', 'socket_set_nonblock' => 'sockets/sockets.stub', 'socket_set_option' => 'sockets/sockets.stub', 'socket_set_timeout' => 'standard/standard_6.stub', 'socket_setopt' => 'sockets/sockets.stub', 'socket_shutdown' => 'sockets/sockets.stub', 'socket_strerror' => 'sockets/sockets.stub', 'socket_write' => 'sockets/sockets.stub', 'socket_wsaprotocol_info_export' => 'sockets/sockets.stub', 'socket_wsaprotocol_info_import' => 'sockets/sockets.stub', 'socket_wsaprotocol_info_release' => 'sockets/sockets.stub', 'sodium_add' => 'sodium/sodium.stub', 'sodium_base642bin' => 'sodium/sodium.stub', 'sodium_bin2base64' => 'sodium/sodium.stub', 'sodium_bin2hex' => 'sodium/sodium.stub', 'sodium_compare' => 'sodium/sodium.stub', 'sodium_crypto_aead_aegis128l_decrypt' => 'libsodium/libsodium_f.stub', 'sodium_crypto_aead_aegis128l_encrypt' => 'libsodium/libsodium_f.stub', 'sodium_crypto_aead_aegis128l_keygen' => 'libsodium/libsodium_f.stub', 'sodium_crypto_aead_aegis256_decrypt' => 'libsodium/libsodium_f.stub', 'sodium_crypto_aead_aegis256_encrypt' => 'libsodium/libsodium_f.stub', 'sodium_crypto_aead_aegis256_keygen' => 'libsodium/libsodium_f.stub', 'sodium_crypto_aead_aes256gcm_decrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_aes256gcm_encrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_aes256gcm_is_available' => 'sodium/sodium.stub', 'sodium_crypto_aead_aes256gcm_keygen' => 'sodium/sodium.stub', 'sodium_crypto_aead_chacha20poly1305_decrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_chacha20poly1305_encrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_chacha20poly1305_ietf_decrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_chacha20poly1305_ietf_encrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_chacha20poly1305_ietf_keygen' => 'sodium/sodium.stub', 'sodium_crypto_aead_chacha20poly1305_keygen' => 'sodium/sodium.stub', 'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt' => 'sodium/sodium.stub', 'sodium_crypto_aead_xchacha20poly1305_ietf_keygen' => 'sodium/sodium.stub', 'sodium_crypto_auth' => 'sodium/sodium.stub', 'sodium_crypto_auth_keygen' => 'sodium/sodium.stub', 'sodium_crypto_auth_verify' => 'sodium/sodium.stub', 'sodium_crypto_box' => 'sodium/sodium.stub', 'sodium_crypto_box_keypair' => 'sodium/sodium.stub', 'sodium_crypto_box_keypair_from_secretkey_and_publickey' => 'sodium/sodium.stub', 'sodium_crypto_box_open' => 'sodium/sodium.stub', 'sodium_crypto_box_publickey' => 'sodium/sodium.stub', 'sodium_crypto_box_publickey_from_secretkey' => 'sodium/sodium.stub', 'sodium_crypto_box_seal' => 'sodium/sodium.stub', 'sodium_crypto_box_seal_open' => 'sodium/sodium.stub', 'sodium_crypto_box_secretkey' => 'sodium/sodium.stub', 'sodium_crypto_box_seed_keypair' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_add' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_from_hash' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_is_valid_point' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_random' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_add' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_complement' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_invert' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_mul' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_negate' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_random' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_reduce' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_scalar_sub' => 'sodium/sodium.stub', 'sodium_crypto_core_ristretto255_sub' => 'sodium/sodium.stub', 'sodium_crypto_generichash' => 'sodium/sodium.stub', 'sodium_crypto_generichash_final' => 'sodium/sodium.stub', 'sodium_crypto_generichash_init' => 'sodium/sodium.stub', 'sodium_crypto_generichash_keygen' => 'sodium/sodium.stub', 'sodium_crypto_generichash_update' => 'sodium/sodium.stub', 'sodium_crypto_kdf_derive_from_key' => 'sodium/sodium.stub', 'sodium_crypto_kdf_keygen' => 'sodium/sodium.stub', 'sodium_crypto_kx' => 'sodium/sodium.stub', 'sodium_crypto_kx_client_session_keys' => 'sodium/sodium.stub', 'sodium_crypto_kx_keypair' => 'sodium/sodium.stub', 'sodium_crypto_kx_publickey' => 'sodium/sodium.stub', 'sodium_crypto_kx_secretkey' => 'sodium/sodium.stub', 'sodium_crypto_kx_seed_keypair' => 'sodium/sodium.stub', 'sodium_crypto_kx_server_session_keys' => 'sodium/sodium.stub', 'sodium_crypto_pwhash' => 'sodium/sodium.stub', 'sodium_crypto_pwhash_scryptsalsa208sha256' => 'sodium/sodium.stub', 'sodium_crypto_pwhash_scryptsalsa208sha256_str' => 'sodium/sodium.stub', 'sodium_crypto_pwhash_scryptsalsa208sha256_str_verify' => 'sodium/sodium.stub', 'sodium_crypto_pwhash_str' => 'sodium/sodium.stub', 'sodium_crypto_pwhash_str_needs_rehash' => 'sodium/sodium.stub', 'sodium_crypto_pwhash_str_verify' => 'sodium/sodium.stub', 'sodium_crypto_scalarmult' => 'sodium/sodium.stub', 'sodium_crypto_scalarmult_base' => 'sodium/sodium.stub', 'sodium_crypto_scalarmult_ristretto255' => 'sodium/sodium.stub', 'sodium_crypto_scalarmult_ristretto255_base' => 'sodium/sodium.stub', 'sodium_crypto_secretbox' => 'sodium/sodium.stub', 'sodium_crypto_secretbox_keygen' => 'sodium/sodium.stub', 'sodium_crypto_secretbox_open' => 'sodium/sodium.stub', 'sodium_crypto_secretstream_xchacha20poly1305_init_pull' => 'sodium/sodium.stub', 'sodium_crypto_secretstream_xchacha20poly1305_init_push' => 'sodium/sodium.stub', 'sodium_crypto_secretstream_xchacha20poly1305_keygen' => 'sodium/sodium.stub', 'sodium_crypto_secretstream_xchacha20poly1305_pull' => 'sodium/sodium.stub', 'sodium_crypto_secretstream_xchacha20poly1305_push' => 'sodium/sodium.stub', 'sodium_crypto_secretstream_xchacha20poly1305_rekey' => 'sodium/sodium.stub', 'sodium_crypto_shorthash' => 'sodium/sodium.stub', 'sodium_crypto_shorthash_keygen' => 'sodium/sodium.stub', 'sodium_crypto_sign' => 'sodium/sodium.stub', 'sodium_crypto_sign_detached' => 'sodium/sodium.stub', 'sodium_crypto_sign_ed25519_pk_to_curve25519' => 'sodium/sodium.stub', 'sodium_crypto_sign_ed25519_sk_to_curve25519' => 'sodium/sodium.stub', 'sodium_crypto_sign_keypair' => 'sodium/sodium.stub', 'sodium_crypto_sign_keypair_from_secretkey_and_publickey' => 'sodium/sodium.stub', 'sodium_crypto_sign_open' => 'sodium/sodium.stub', 'sodium_crypto_sign_publickey' => 'sodium/sodium.stub', 'sodium_crypto_sign_publickey_from_secretkey' => 'sodium/sodium.stub', 'sodium_crypto_sign_secretkey' => 'sodium/sodium.stub', 'sodium_crypto_sign_seed_keypair' => 'sodium/sodium.stub', 'sodium_crypto_sign_verify_detached' => 'sodium/sodium.stub', 'sodium_crypto_stream' => 'sodium/sodium.stub', 'sodium_crypto_stream_keygen' => 'sodium/sodium.stub', 'sodium_crypto_stream_xchacha20' => 'sodium/sodium.stub', 'sodium_crypto_stream_xchacha20_keygen' => 'sodium/sodium.stub', 'sodium_crypto_stream_xchacha20_xor' => 'sodium/sodium.stub', 'sodium_crypto_stream_xchacha20_xor_ic' => 'sodium/sodium.stub', 'sodium_crypto_stream_xor' => 'sodium/sodium.stub', 'sodium_hex2bin' => 'sodium/sodium.stub', 'sodium_increment' => 'sodium/sodium.stub', 'sodium_library_version_major' => 'sodium/sodium.stub', 'sodium_library_version_minor' => 'sodium/sodium.stub', 'sodium_memcmp' => 'sodium/sodium.stub', 'sodium_memzero' => 'sodium/sodium.stub', 'sodium_pad' => 'sodium/sodium.stub', 'sodium_randombytes_buf' => 'sodium/sodium.stub', 'sodium_randombytes_random16' => 'sodium/sodium.stub', 'sodium_randombytes_uniform' => 'sodium/sodium.stub', 'sodium_unpad' => 'sodium/sodium.stub', 'sodium_version_string' => 'sodium/sodium.stub', 'solr_get_version' => 'solr/functions.stub', 'sort' => 'standard/standard_8.stub', 'soundex' => 'standard/standard_2.stub', 'spl_autoload' => 'SPL/SPL_f.stub', 'spl_autoload_call' => 'SPL/SPL_f.stub', 'spl_autoload_extensions' => 'SPL/SPL_f.stub', 'spl_autoload_functions' => 'SPL/SPL_f.stub', 'spl_autoload_register' => 'SPL/SPL_f.stub', 'spl_autoload_unregister' => 'SPL/SPL_f.stub', 'spl_classes' => 'SPL/SPL_f.stub', 'spl_object_hash' => 'SPL/SPL_f.stub', 'spl_object_id' => 'SPL/SPL_f.stub', 'split' => 'regex/ereg.stub', 'spliti' => 'regex/ereg.stub', 'sprintf' => 'standard/standard_2.stub', 'sql_regcase' => 'regex/ereg.stub', 'sqlite_array_query' => 'SQLite/SQLite.stub', 'sqlite_busy_timeout' => 'SQLite/SQLite.stub', 'sqlite_changes' => 'SQLite/SQLite.stub', 'sqlite_close' => 'SQLite/SQLite.stub', 'sqlite_column' => 'SQLite/SQLite.stub', 'sqlite_create_aggregate' => 'SQLite/SQLite.stub', 'sqlite_create_function' => 'SQLite/SQLite.stub', 'sqlite_current' => 'SQLite/SQLite.stub', 'sqlite_error_string' => 'SQLite/SQLite.stub', 'sqlite_escape_string' => 'SQLite/SQLite.stub', 'sqlite_exec' => 'SQLite/SQLite.stub', 'sqlite_factory' => 'SQLite/SQLite.stub', 'sqlite_fetch_all' => 'SQLite/SQLite.stub', 'sqlite_fetch_array' => 'SQLite/SQLite.stub', 'sqlite_fetch_column_types' => 'SQLite/SQLite.stub', 'sqlite_fetch_object' => 'SQLite/SQLite.stub', 'sqlite_fetch_single' => 'SQLite/SQLite.stub', 'sqlite_fetch_string' => 'SQLite/SQLite.stub', 'sqlite_field_name' => 'SQLite/SQLite.stub', 'sqlite_has_more' => 'SQLite/SQLite.stub', 'sqlite_has_prev' => 'SQLite/SQLite.stub', 'sqlite_last_error' => 'SQLite/SQLite.stub', 'sqlite_last_insert_rowid' => 'SQLite/SQLite.stub', 'sqlite_libencoding' => 'SQLite/SQLite.stub', 'sqlite_libversion' => 'SQLite/SQLite.stub', 'sqlite_next' => 'SQLite/SQLite.stub', 'sqlite_num_fields' => 'SQLite/SQLite.stub', 'sqlite_num_rows' => 'SQLite/SQLite.stub', 'sqlite_open' => 'SQLite/SQLite.stub', 'sqlite_popen' => 'SQLite/SQLite.stub', 'sqlite_prev' => 'SQLite/SQLite.stub', 'sqlite_query' => 'SQLite/SQLite.stub', 'sqlite_rewind' => 'SQLite/SQLite.stub', 'sqlite_seek' => 'SQLite/SQLite.stub', 'sqlite_single_query' => 'SQLite/SQLite.stub', 'sqlite_udf_decode_binary' => 'SQLite/SQLite.stub', 'sqlite_udf_encode_binary' => 'SQLite/SQLite.stub', 'sqlite_unbuffered_query' => 'SQLite/SQLite.stub', 'sqlite_valid' => 'SQLite/SQLite.stub', 'sqlsrv_begin_transaction' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_cancel' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_client_info' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_close' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_commit' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_configure' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_connect' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_errors' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_execute' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_fetch' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_fetch_array' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_fetch_object' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_field_metadata' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_free_stmt' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_get_config' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_get_field' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_has_rows' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_next_result' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_num_fields' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_num_rows' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_prepare' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_query' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_rollback' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_rows_affected' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_send_stream_data' => 'sqlsrv/sqlsrv.stub', 'sqlsrv_server_info' => 'sqlsrv/sqlsrv.stub', 'sqrt' => 'standard/standard_3.stub', 'srand' => 'random/random.stub', 'sscanf' => 'standard/standard_2.stub', 'ssh2_auth_agent' => 'ssh2/ssh2.stub', 'ssh2_auth_hostbased_file' => 'ssh2/ssh2.stub', 'ssh2_auth_none' => 'ssh2/ssh2.stub', 'ssh2_auth_password' => 'ssh2/ssh2.stub', 'ssh2_auth_pubkey_file' => 'ssh2/ssh2.stub', 'ssh2_connect' => 'ssh2/ssh2.stub', 'ssh2_disconnect' => 'ssh2/ssh2.stub', 'ssh2_exec' => 'ssh2/ssh2.stub', 'ssh2_fetch_stream' => 'ssh2/ssh2.stub', 'ssh2_fingerprint' => 'ssh2/ssh2.stub', 'ssh2_forward_accept' => 'ssh2/ssh2.stub', 'ssh2_forward_listen' => 'ssh2/ssh2.stub', 'ssh2_methods_negotiated' => 'ssh2/ssh2.stub', 'ssh2_poll' => 'ssh2/ssh2.stub', 'ssh2_publickey_add' => 'ssh2/ssh2.stub', 'ssh2_publickey_init' => 'ssh2/ssh2.stub', 'ssh2_publickey_list' => 'ssh2/ssh2.stub', 'ssh2_publickey_remove' => 'ssh2/ssh2.stub', 'ssh2_scp_recv' => 'ssh2/ssh2.stub', 'ssh2_scp_send' => 'ssh2/ssh2.stub', 'ssh2_send_eof' => 'ssh2/ssh2.stub', 'ssh2_sftp' => 'ssh2/ssh2.stub', 'ssh2_sftp_chmod' => 'ssh2/ssh2.stub', 'ssh2_sftp_lstat' => 'ssh2/ssh2.stub', 'ssh2_sftp_mkdir' => 'ssh2/ssh2.stub', 'ssh2_sftp_readlink' => 'ssh2/ssh2.stub', 'ssh2_sftp_realpath' => 'ssh2/ssh2.stub', 'ssh2_sftp_rename' => 'ssh2/ssh2.stub', 'ssh2_sftp_rmdir' => 'ssh2/ssh2.stub', 'ssh2_sftp_stat' => 'ssh2/ssh2.stub', 'ssh2_sftp_symlink' => 'ssh2/ssh2.stub', 'ssh2_sftp_unlink' => 'ssh2/ssh2.stub', 'ssh2_shell' => 'ssh2/ssh2.stub', 'ssh2_tunnel' => 'ssh2/ssh2.stub', 'stat' => 'standard/standard_7.stub', 'stats_absolute_deviation' => 'stats/stats.stub', 'stats_cdf_beta' => 'stats/stats.stub', 'stats_cdf_binomial' => 'stats/stats.stub', 'stats_cdf_cauchy' => 'stats/stats.stub', 'stats_cdf_chisquare' => 'stats/stats.stub', 'stats_cdf_exponential' => 'stats/stats.stub', 'stats_cdf_f' => 'stats/stats.stub', 'stats_cdf_gamma' => 'stats/stats.stub', 'stats_cdf_laplace' => 'stats/stats.stub', 'stats_cdf_logistic' => 'stats/stats.stub', 'stats_cdf_negative_binomial' => 'stats/stats.stub', 'stats_cdf_noncentral_chisquare' => 'stats/stats.stub', 'stats_cdf_noncentral_f' => 'stats/stats.stub', 'stats_cdf_noncentral_t' => 'stats/stats.stub', 'stats_cdf_normal' => 'stats/stats.stub', 'stats_cdf_poisson' => 'stats/stats.stub', 'stats_cdf_t' => 'stats/stats.stub', 'stats_cdf_uniform' => 'stats/stats.stub', 'stats_cdf_weibull' => 'stats/stats.stub', 'stats_covariance' => 'stats/stats.stub', 'stats_dens_beta' => 'stats/stats.stub', 'stats_dens_cauchy' => 'stats/stats.stub', 'stats_dens_chisquare' => 'stats/stats.stub', 'stats_dens_exponential' => 'stats/stats.stub', 'stats_dens_f' => 'stats/stats.stub', 'stats_dens_gamma' => 'stats/stats.stub', 'stats_dens_laplace' => 'stats/stats.stub', 'stats_dens_logistic' => 'stats/stats.stub', 'stats_dens_normal' => 'stats/stats.stub', 'stats_dens_pmf_binomial' => 'stats/stats.stub', 'stats_dens_pmf_hypergeometric' => 'stats/stats.stub', 'stats_dens_pmf_negative_binomial' => 'stats/stats.stub', 'stats_dens_pmf_poisson' => 'stats/stats.stub', 'stats_dens_t' => 'stats/stats.stub', 'stats_dens_uniform' => 'stats/stats.stub', 'stats_dens_weibull' => 'stats/stats.stub', 'stats_harmonic_mean' => 'stats/stats.stub', 'stats_kurtosis' => 'stats/stats.stub', 'stats_rand_gen_beta' => 'stats/stats.stub', 'stats_rand_gen_chisquare' => 'stats/stats.stub', 'stats_rand_gen_exponential' => 'stats/stats.stub', 'stats_rand_gen_f' => 'stats/stats.stub', 'stats_rand_gen_funiform' => 'stats/stats.stub', 'stats_rand_gen_gamma' => 'stats/stats.stub', 'stats_rand_gen_ibinomial' => 'stats/stats.stub', 'stats_rand_gen_ibinomial_negative' => 'stats/stats.stub', 'stats_rand_gen_int' => 'stats/stats.stub', 'stats_rand_gen_ipoisson' => 'stats/stats.stub', 'stats_rand_gen_iuniform' => 'stats/stats.stub', 'stats_rand_gen_noncentral_f' => 'stats/stats.stub', 'stats_rand_gen_noncentral_t' => 'stats/stats.stub', 'stats_rand_gen_normal' => 'stats/stats.stub', 'stats_rand_gen_t' => 'stats/stats.stub', 'stats_rand_get_seeds' => 'stats/stats.stub', 'stats_rand_phrase_to_seeds' => 'stats/stats.stub', 'stats_rand_ranf' => 'stats/stats.stub', 'stats_rand_setall' => 'stats/stats.stub', 'stats_skew' => 'stats/stats.stub', 'stats_standard_deviation' => 'stats/stats.stub', 'stats_stat_binomial_coef' => 'stats/stats.stub', 'stats_stat_correlation' => 'stats/stats.stub', 'stats_stat_factorial' => 'stats/stats.stub', 'stats_stat_independent_t' => 'stats/stats.stub', 'stats_stat_innerproduct' => 'stats/stats.stub', 'stats_stat_paired_t' => 'stats/stats.stub', 'stats_stat_percentile' => 'stats/stats.stub', 'stats_stat_powersum' => 'stats/stats.stub', 'stats_variance' => 'stats/stats.stub', 'stomp_abort' => 'stomp/stomp.stub', 'stomp_ack' => 'stomp/stomp.stub', 'stomp_begin' => 'stomp/stomp.stub', 'stomp_close' => 'stomp/stomp.stub', 'stomp_commit' => 'stomp/stomp.stub', 'stomp_connect' => 'stomp/stomp.stub', 'stomp_error' => 'stomp/stomp.stub', 'stomp_get_session_id' => 'stomp/stomp.stub', 'stomp_get_timeout' => 'stomp/stomp.stub', 'stomp_has_frame' => 'stomp/stomp.stub', 'stomp_read_frame' => 'stomp/stomp.stub', 'stomp_send' => 'stomp/stomp.stub', 'stomp_set_timeout' => 'stomp/stomp.stub', 'stomp_subscribe' => 'stomp/stomp.stub', 'stomp_unsubscribe' => 'stomp/stomp.stub', 'stomp_version' => 'stomp/stomp.stub', 'str_contains' => 'Core/Core.stub', 'str_decrement' => 'Core/Core.stub', 'str_ends_with' => 'Core/Core.stub', 'str_getcsv' => 'standard/standard_2.stub', 'str_increment' => 'Core/Core.stub', 'str_ireplace' => 'standard/standard_1.stub', 'str_pad' => 'standard/standard_2.stub', 'str_repeat' => 'standard/standard_1.stub', 'str_replace' => 'standard/standard_1.stub', 'str_rot13' => 'standard/standard_9.stub', 'str_shuffle' => 'standard/standard_1.stub', 'str_split' => 'standard/standard_1.stub', 'str_starts_with' => 'Core/Core.stub', 'str_word_count' => 'standard/standard_1.stub', 'strcasecmp' => 'Core/Core.stub', 'strchr' => 'standard/standard_2.stub', 'strcmp' => 'Core/Core.stub', 'strcoll' => 'standard/standard_1.stub', 'strcspn' => 'standard/standard_0.stub', 'stream_bucket_append' => 'standard/standard_9.stub', 'stream_bucket_make_writeable' => 'standard/standard_9.stub', 'stream_bucket_new' => 'standard/standard_9.stub', 'stream_bucket_prepend' => 'standard/standard_9.stub', 'stream_context_create' => 'standard/standard_6.stub', 'stream_context_get_default' => 'standard/standard_6.stub', 'stream_context_get_options' => 'standard/standard_6.stub', 'stream_context_get_params' => 'standard/standard_6.stub', 'stream_context_set_default' => 'standard/standard_6.stub', 'stream_context_set_option' => 'standard/standard_6.stub', 'stream_context_set_options' => 'standard/standard_6.stub', 'stream_context_set_params' => 'standard/standard_6.stub', 'stream_copy_to_stream' => 'standard/standard_6.stub', 'stream_filter_append' => 'standard/standard_6.stub', 'stream_filter_prepend' => 'standard/standard_6.stub', 'stream_filter_register' => 'standard/standard_9.stub', 'stream_filter_remove' => 'standard/standard_6.stub', 'stream_get_contents' => 'standard/standard_6.stub', 'stream_get_filters' => 'standard/standard_9.stub', 'stream_get_line' => 'standard/standard_6.stub', 'stream_get_meta_data' => 'standard/standard_6.stub', 'stream_get_transports' => 'standard/standard_6.stub', 'stream_get_wrappers' => 'standard/standard_6.stub', 'stream_is_local' => 'standard/standard_6.stub', 'stream_isatty' => 'standard/standard_9.stub', 'stream_register_wrapper' => 'standard/standard_6.stub', 'stream_resolve_include_path' => 'standard/standard_6.stub', 'stream_select' => 'standard/standard_6.stub', 'stream_set_blocking' => 'standard/standard_6.stub', 'stream_set_chunk_size' => 'standard/standard_8.stub', 'stream_set_read_buffer' => 'standard/standard_6.stub', 'stream_set_timeout' => 'standard/standard_6.stub', 'stream_set_write_buffer' => 'standard/standard_6.stub', 'stream_socket_accept' => 'standard/standard_6.stub', 'stream_socket_client' => 'standard/standard_6.stub', 'stream_socket_enable_crypto' => 'standard/standard_6.stub', 'stream_socket_get_name' => 'standard/standard_6.stub', 'stream_socket_pair' => 'standard/standard_6.stub', 'stream_socket_recvfrom' => 'standard/standard_6.stub', 'stream_socket_sendto' => 'standard/standard_6.stub', 'stream_socket_server' => 'standard/standard_6.stub', 'stream_socket_shutdown' => 'standard/standard_6.stub', 'stream_supports_lock' => 'standard/standard_6.stub', 'stream_wrapper_register' => 'standard/standard_6.stub', 'stream_wrapper_restore' => 'standard/standard_6.stub', 'stream_wrapper_unregister' => 'standard/standard_6.stub', 'strftime' => 'date/date.stub', 'strip_tags' => 'standard/standard_1.stub', 'stripcslashes' => 'standard/standard_1.stub', 'stripos' => 'standard/standard_1.stub', 'stripslashes' => 'standard/standard_1.stub', 'stristr' => 'standard/standard_1.stub', 'strlen' => 'Core/Core.stub', 'strnatcasecmp' => 'standard/standard_0.stub', 'strnatcmp' => 'standard/standard_0.stub', 'strncasecmp' => 'Core/Core.stub', 'strncmp' => 'Core/Core.stub', 'strpbrk' => 'standard/standard_1.stub', 'strpos' => 'standard/standard_1.stub', 'strptime' => 'standard/standard_0.stub', 'strrchr' => 'standard/standard_1.stub', 'strrev' => 'standard/standard_1.stub', 'strripos' => 'standard/standard_1.stub', 'strrpos' => 'standard/standard_1.stub', 'strspn' => 'standard/standard_0.stub', 'strstr' => 'standard/standard_1.stub', 'strtok' => 'standard/standard_0.stub', 'strtolower' => 'standard/standard_1.stub', 'strtotime' => 'date/date.stub', 'strtoupper' => 'standard/standard_1.stub', 'strtr' => 'standard/standard_1.stub', 'strval' => 'standard/standard_5.stub', 'substr' => 'standard/standard_1.stub', 'substr_compare' => 'standard/standard_1.stub', 'substr_count' => 'standard/standard_0.stub', 'substr_replace' => 'standard/standard_1.stub', 'suhosin_encrypt_cookie' => 'suhosin/suhosin.stub', 'suhosin_get_raw_cookies' => 'suhosin/suhosin.stub', 'svn_add' => 'svn/svn.stub', 'svn_auth_get_parameter' => 'svn/svn.stub', 'svn_auth_set_parameter' => 'svn/svn.stub', 'svn_blame' => 'svn/svn.stub', 'svn_cat' => 'svn/svn.stub', 'svn_checkout' => 'svn/svn.stub', 'svn_cleanup' => 'svn/svn.stub', 'svn_client_version' => 'svn/svn.stub', 'svn_commit' => 'svn/svn.stub', 'svn_config_ensure' => 'svn/svn.stub', 'svn_copy' => 'svn/svn.stub', 'svn_delete' => 'svn/svn.stub', 'svn_diff' => 'svn/svn.stub', 'svn_export' => 'svn/svn.stub', 'svn_fs_abort_txn' => 'svn/svn.stub', 'svn_fs_apply_text' => 'svn/svn.stub', 'svn_fs_begin_txn2' => 'svn/svn.stub', 'svn_fs_change_node_prop' => 'svn/svn.stub', 'svn_fs_check_path' => 'svn/svn.stub', 'svn_fs_contents_changed' => 'svn/svn.stub', 'svn_fs_copy' => 'svn/svn.stub', 'svn_fs_delete' => 'svn/svn.stub', 'svn_fs_dir_entries' => 'svn/svn.stub', 'svn_fs_file_contents' => 'svn/svn.stub', 'svn_fs_file_length' => 'svn/svn.stub', 'svn_fs_is_dir' => 'svn/svn.stub', 'svn_fs_is_file' => 'svn/svn.stub', 'svn_fs_make_dir' => 'svn/svn.stub', 'svn_fs_make_file' => 'svn/svn.stub', 'svn_fs_node_created_rev' => 'svn/svn.stub', 'svn_fs_node_prop' => 'svn/svn.stub', 'svn_fs_props_changed' => 'svn/svn.stub', 'svn_fs_revision_prop' => 'svn/svn.stub', 'svn_fs_revision_root' => 'svn/svn.stub', 'svn_fs_txn_root' => 'svn/svn.stub', 'svn_fs_youngest_rev' => 'svn/svn.stub', 'svn_import' => 'svn/svn.stub', 'svn_info' => 'svn/svn.stub', 'svn_lock' => 'svn/svn.stub', 'svn_log' => 'svn/svn.stub', 'svn_ls' => 'svn/svn.stub', 'svn_mkdir' => 'svn/svn.stub', 'svn_move' => 'svn/svn.stub', 'svn_propget' => 'svn/svn.stub', 'svn_proplist' => 'svn/svn.stub', 'svn_repos_create' => 'svn/svn.stub', 'svn_repos_fs' => 'svn/svn.stub', 'svn_repos_fs_begin_txn_for_commit' => 'svn/svn.stub', 'svn_repos_fs_commit_txn' => 'svn/svn.stub', 'svn_repos_hotcopy' => 'svn/svn.stub', 'svn_repos_open' => 'svn/svn.stub', 'svn_repos_recover' => 'svn/svn.stub', 'svn_resolved' => 'svn/svn.stub', 'svn_revert' => 'svn/svn.stub', 'svn_status' => 'svn/svn.stub', 'svn_switch' => 'svn/svn.stub', 'svn_unlock' => 'svn/svn.stub', 'svn_update' => 'svn/svn.stub', 'swoole_async_dns_lookup_coro' => 'swoole/functions.stub', 'swoole_async_set' => 'swoole/functions.stub', 'swoole_clear_dns_cache' => 'swoole/functions.stub', 'swoole_clear_error' => 'swoole/functions.stub', 'swoole_client_select' => 'swoole/functions.stub', 'swoole_coroutine_create' => 'swoole/functions.stub', 'swoole_coroutine_defer' => 'swoole/functions.stub', 'swoole_coroutine_socketpair' => 'swoole/functions.stub', 'swoole_cpu_num' => 'swoole/functions.stub', 'swoole_errno' => 'swoole/functions.stub', 'swoole_error_log' => 'swoole/functions.stub', 'swoole_error_log_ex' => 'swoole/functions.stub', 'swoole_event_add' => 'swoole/functions.stub', 'swoole_event_cycle' => 'swoole/functions.stub', 'swoole_event_defer' => 'swoole/functions.stub', 'swoole_event_del' => 'swoole/functions.stub', 'swoole_event_dispatch' => 'swoole/functions.stub', 'swoole_event_exit' => 'swoole/functions.stub', 'swoole_event_isset' => 'swoole/functions.stub', 'swoole_event_set' => 'swoole/functions.stub', 'swoole_event_wait' => 'swoole/functions.stub', 'swoole_event_write' => 'swoole/functions.stub', 'swoole_get_local_ip' => 'swoole/functions.stub', 'swoole_get_local_mac' => 'swoole/functions.stub', 'swoole_get_mime_type' => 'swoole/functions.stub', 'swoole_get_object_by_handle' => 'swoole/functions.stub', 'swoole_get_objects' => 'swoole/functions.stub', 'swoole_get_vm_status' => 'swoole/functions.stub', 'swoole_hashcode' => 'swoole/functions.stub', 'swoole_ignore_error' => 'swoole/functions.stub', 'swoole_internal_call_user_shutdown_begin' => 'swoole/functions.stub', 'swoole_last_error' => 'swoole/functions.stub', 'swoole_mime_type_add' => 'swoole/functions.stub', 'swoole_mime_type_delete' => 'swoole/functions.stub', 'swoole_mime_type_exists' => 'swoole/functions.stub', 'swoole_mime_type_get' => 'swoole/functions.stub', 'swoole_mime_type_list' => 'swoole/functions.stub', 'swoole_mime_type_set' => 'swoole/functions.stub', 'swoole_select' => 'swoole/functions.stub', 'swoole_set_process_name' => 'swoole/functions.stub', 'swoole_strerror' => 'swoole/functions.stub', 'swoole_substr_json_decode' => 'swoole/functions.stub', 'swoole_substr_unserialize' => 'swoole/functions.stub', 'swoole_test_kernel_coroutine' => 'swoole/functions.stub', 'swoole_timer_after' => 'swoole/functions.stub', 'swoole_timer_clear' => 'swoole/functions.stub', 'swoole_timer_clear_all' => 'swoole/functions.stub', 'swoole_timer_exists' => 'swoole/functions.stub', 'swoole_timer_info' => 'swoole/functions.stub', 'swoole_timer_list' => 'swoole/functions.stub', 'swoole_timer_set' => 'swoole/functions.stub', 'swoole_timer_stats' => 'swoole/functions.stub', 'swoole_timer_tick' => 'swoole/functions.stub', 'swoole_version' => 'swoole/functions.stub', 'sybase_affected_rows' => 'sybase/sybase_ct.stub', 'sybase_close' => 'sybase/sybase_ct.stub', 'sybase_connect' => 'sybase/sybase_ct.stub', 'sybase_data_seek' => 'sybase/sybase_ct.stub', 'sybase_deadlock_retry_count' => 'sybase/sybase_ct.stub', 'sybase_fetch_array' => 'sybase/sybase_ct.stub', 'sybase_fetch_assoc' => 'sybase/sybase_ct.stub', 'sybase_fetch_field' => 'sybase/sybase_ct.stub', 'sybase_fetch_object' => 'sybase/sybase_ct.stub', 'sybase_fetch_row' => 'sybase/sybase_ct.stub', 'sybase_field_seek' => 'sybase/sybase_ct.stub', 'sybase_free_result' => 'sybase/sybase_ct.stub', 'sybase_get_last_message' => 'sybase/sybase_ct.stub', 'sybase_min_client_severity' => 'sybase/sybase_ct.stub', 'sybase_min_server_severity' => 'sybase/sybase_ct.stub', 'sybase_num_fields' => 'sybase/sybase_ct.stub', 'sybase_num_rows' => 'sybase/sybase_ct.stub', 'sybase_pconnect' => 'sybase/sybase_ct.stub', 'sybase_query' => 'sybase/sybase_ct.stub', 'sybase_result' => 'sybase/sybase_ct.stub', 'sybase_select_db' => 'sybase/sybase_ct.stub', 'sybase_set_message_handler' => 'sybase/sybase_ct.stub', 'sybase_unbuffered_query' => 'sybase/sybase_ct.stub', 'symlink' => 'standard/standard_2.stub', 'sys_get_temp_dir' => 'standard/standard_9.stub', 'sys_getloadavg' => 'standard/standard_3.stub', 'syslog' => 'standard/standard_8.stub', 'system' => 'standard/standard_2.stub', 'tan' => 'standard/standard_3.stub', 'tanh' => 'standard/standard_3.stub', 'tempnam' => 'standard/standard_5.stub', 'textdomain' => 'gettext/gettext.stub', 'tidy_access_count' => 'tidy/tidy.stub', 'tidy_clean_repair' => 'tidy/tidy.stub', 'tidy_config_count' => 'tidy/tidy.stub', 'tidy_diagnose' => 'tidy/tidy.stub', 'tidy_error_count' => 'tidy/tidy.stub', 'tidy_get_body' => 'tidy/tidy.stub', 'tidy_get_config' => 'tidy/tidy.stub', 'tidy_get_error_buffer' => 'tidy/tidy.stub', 'tidy_get_head' => 'tidy/tidy.stub', 'tidy_get_html' => 'tidy/tidy.stub', 'tidy_get_html_ver' => 'tidy/tidy.stub', 'tidy_get_opt_doc' => 'tidy/tidy.stub', 'tidy_get_output' => 'tidy/tidy.stub', 'tidy_get_release' => 'tidy/tidy.stub', 'tidy_get_root' => 'tidy/tidy.stub', 'tidy_get_status' => 'tidy/tidy.stub', 'tidy_getopt' => 'tidy/tidy.stub', 'tidy_is_xhtml' => 'tidy/tidy.stub', 'tidy_is_xml' => 'tidy/tidy.stub', 'tidy_parse_file' => 'tidy/tidy.stub', 'tidy_parse_string' => 'tidy/tidy.stub', 'tidy_repair_file' => 'tidy/tidy.stub', 'tidy_repair_string' => 'tidy/tidy.stub', 'tidy_warning_count' => 'tidy/tidy.stub', 'time' => 'date/date.stub', 'time_nanosleep' => 'standard/standard_0.stub', 'time_sleep_until' => 'standard/standard_0.stub', 'timezone_abbreviations_list' => 'date/date.stub', 'timezone_identifiers_list' => 'date/date.stub', 'timezone_location_get' => 'date/date.stub', 'timezone_name_from_abbr' => 'date/date.stub', 'timezone_name_get' => 'date/date.stub', 'timezone_offset_get' => 'date/date.stub', 'timezone_open' => 'date/date.stub', 'timezone_transitions_get' => 'date/date.stub', 'timezone_version_get' => 'date/date.stub', 'tmpfile' => 'standard/standard_5.stub', 'token_get_all' => 'tokenizer/tokenizer.stub', 'token_name' => 'tokenizer/tokenizer.stub', 'touch' => 'standard/standard_7.stub', 'trait_exists' => 'Core/Core.stub', 'transliterator_create' => 'intl/intl.stub', 'transliterator_create_from_rules' => 'intl/intl.stub', 'transliterator_create_inverse' => 'intl/intl.stub', 'transliterator_get_error_code' => 'intl/intl.stub', 'transliterator_get_error_message' => 'intl/intl.stub', 'transliterator_list_ids' => 'intl/intl.stub', 'transliterator_transliterate' => 'intl/intl.stub', 'trigger_error' => 'Core/Core.stub', 'trim' => 'standard/standard_1.stub', 'uasort' => 'standard/standard_8.stub', 'ucfirst' => 'standard/standard_1.stub', 'ucwords' => 'standard/standard_1.stub', 'uksort' => 'standard/standard_8.stub', 'umask' => 'standard/standard_5.stub', 'uniqid' => 'standard/standard_3.stub', 'unixtojd' => 'calendar/calendar.stub', 'unlink' => 'standard/standard_2.stub', 'unpack' => 'standard/standard_7.stub', 'unregister_event_handler' => 'zend/zend.stub', 'unregister_tick_function' => 'standard/standard_4.stub', 'unserialize' => 'standard/standard_4.stub', 'uopz_add_function' => 'uopz/uopz.stub', 'uopz_allow_exit' => 'uopz/uopz.stub', 'uopz_call_user_func' => 'uopz/uopz.stub', 'uopz_call_user_func_array' => 'uopz/uopz.stub', 'uopz_del_function' => 'uopz/uopz.stub', 'uopz_extend' => 'uopz/uopz.stub', 'uopz_flags' => 'uopz/uopz.stub', 'uopz_get_exit_status' => 'uopz/uopz.stub', 'uopz_get_hook' => 'uopz/uopz.stub', 'uopz_get_mock' => 'uopz/uopz.stub', 'uopz_get_property' => 'uopz/uopz.stub', 'uopz_get_return' => 'uopz/uopz.stub', 'uopz_get_static' => 'uopz/uopz.stub', 'uopz_implement' => 'uopz/uopz.stub', 'uopz_redefine' => 'uopz/uopz.stub', 'uopz_set_hook' => 'uopz/uopz.stub', 'uopz_set_mock' => 'uopz/uopz.stub', 'uopz_set_property' => 'uopz/uopz.stub', 'uopz_set_return' => 'uopz/uopz.stub', 'uopz_set_static' => 'uopz/uopz.stub', 'uopz_undefine' => 'uopz/uopz.stub', 'uopz_unset_hook' => 'uopz/uopz.stub', 'uopz_unset_mock' => 'uopz/uopz.stub', 'uopz_unset_return' => 'uopz/uopz.stub', 'uploadprogress_get_contents' => 'uploadprogress/uploadprogress.stub', 'uploadprogress_get_info' => 'uploadprogress/uploadprogress.stub', 'urldecode' => 'standard/standard_2.stub', 'urlencode' => 'standard/standard_2.stub', 'use_soap_error_handler' => 'soap/soap.stub', 'user_error' => 'Core/Core.stub', 'usleep' => 'standard/standard_0.stub', 'usort' => 'standard/standard_8.stub', 'utf8_decode' => 'standard/basic.stub', 'utf8_encode' => 'standard/basic.stub', 'uuid_compare' => 'uuid/uuid_c.stub', 'uuid_create' => 'uuid/uuid_c.stub', 'uuid_generate_md5' => 'uuid/uuid_c.stub', 'uuid_generate_sha1' => 'uuid/uuid_c.stub', 'uuid_is_null' => 'uuid/uuid_c.stub', 'uuid_is_valid' => 'uuid/uuid_c.stub', 'uuid_mac' => 'uuid/uuid_c.stub', 'uuid_parse' => 'uuid/uuid_c.stub', 'uuid_time' => 'uuid/uuid_c.stub', 'uuid_type' => 'uuid/uuid_c.stub', 'uuid_unparse' => 'uuid/uuid_c.stub', 'uuid_variant' => 'uuid/uuid_c.stub', 'uv_accept' => 'uv/uv_functions.stub', 'uv_async_init' => 'uv/uv_functions.stub', 'uv_async_send' => 'uv/uv_functions.stub', 'uv_chdir' => 'uv/uv_functions.stub', 'uv_check_init' => 'uv/uv_functions.stub', 'uv_check_start' => 'uv/uv_functions.stub', 'uv_check_stop' => 'uv/uv_functions.stub', 'uv_close' => 'uv/uv_functions.stub', 'uv_cpu_info' => 'uv/uv_functions.stub', 'uv_default_loop' => 'uv/uv_functions.stub', 'uv_err_name' => 'uv/uv_functions.stub', 'uv_exepath' => 'uv/uv_functions.stub', 'uv_fs_chmod' => 'uv/uv_functions.stub', 'uv_fs_chown' => 'uv/uv_functions.stub', 'uv_fs_close' => 'uv/uv_functions.stub', 'uv_fs_event_init' => 'uv/uv_functions.stub', 'uv_fs_fchmod' => 'uv/uv_functions.stub', 'uv_fs_fchown' => 'uv/uv_functions.stub', 'uv_fs_fdatasync' => 'uv/uv_functions.stub', 'uv_fs_fstat' => 'uv/uv_functions.stub', 'uv_fs_fsync' => 'uv/uv_functions.stub', 'uv_fs_ftruncate' => 'uv/uv_functions.stub', 'uv_fs_futime' => 'uv/uv_functions.stub', 'uv_fs_link' => 'uv/uv_functions.stub', 'uv_fs_lstat' => 'uv/uv_functions.stub', 'uv_fs_mkdir' => 'uv/uv_functions.stub', 'uv_fs_open' => 'uv/uv_functions.stub', 'uv_fs_poll_init' => 'uv/uv_functions.stub', 'uv_fs_poll_start' => 'uv/uv_functions.stub', 'uv_fs_poll_stop' => 'uv/uv_functions.stub', 'uv_fs_read' => 'uv/uv_functions.stub', 'uv_fs_readdir' => 'uv/uv_functions.stub', 'uv_fs_readlink' => 'uv/uv_functions.stub', 'uv_fs_rename' => 'uv/uv_functions.stub', 'uv_fs_rmdir' => 'uv/uv_functions.stub', 'uv_fs_sendfile' => 'uv/uv_functions.stub', 'uv_fs_stat' => 'uv/uv_functions.stub', 'uv_fs_symlink' => 'uv/uv_functions.stub', 'uv_fs_unlink' => 'uv/uv_functions.stub', 'uv_fs_utime' => 'uv/uv_functions.stub', 'uv_fs_write' => 'uv/uv_functions.stub', 'uv_get_free_memory' => 'uv/uv_functions.stub', 'uv_get_total_memory' => 'uv/uv_functions.stub', 'uv_getaddrinfo' => 'uv/uv_functions.stub', 'uv_guess_handle' => 'uv/uv_functions.stub', 'uv_hrtime' => 'uv/uv_functions.stub', 'uv_idle_init' => 'uv/uv_functions.stub', 'uv_idle_start' => 'uv/uv_functions.stub', 'uv_idle_stop' => 'uv/uv_functions.stub', 'uv_interface_addresses' => 'uv/uv_functions.stub', 'uv_ip4_addr' => 'uv/uv_functions.stub', 'uv_ip4_name' => 'uv/uv_functions.stub', 'uv_ip6_addr' => 'uv/uv_functions.stub', 'uv_ip6_name' => 'uv/uv_functions.stub', 'uv_is_active' => 'uv/uv_functions.stub', 'uv_is_closing' => 'uv/uv_functions.stub', 'uv_is_readable' => 'uv/uv_functions.stub', 'uv_is_writable' => 'uv/uv_functions.stub', 'uv_kill' => 'uv/uv_functions.stub', 'uv_last_error' => 'uv/uv_functions.stub', 'uv_listen' => 'uv/uv_functions.stub', 'uv_loadavg' => 'uv/uv_functions.stub', 'uv_loop_delete' => 'uv/uv_functions.stub', 'uv_loop_new' => 'uv/uv_functions.stub', 'uv_mutex_init' => 'uv/uv_functions.stub', 'uv_mutex_lock' => 'uv/uv_functions.stub', 'uv_mutex_trylock' => 'uv/uv_functions.stub', 'uv_now' => 'uv/uv_functions.stub', 'uv_pipe_bind' => 'uv/uv_functions.stub', 'uv_pipe_connect' => 'uv/uv_functions.stub', 'uv_pipe_init' => 'uv/uv_functions.stub', 'uv_pipe_open' => 'uv/uv_functions.stub', 'uv_pipe_pending_instances' => 'uv/uv_functions.stub', 'uv_poll_init' => 'uv/uv_functions.stub', 'uv_poll_start' => 'uv/uv_functions.stub', 'uv_poll_stop' => 'uv/uv_functions.stub', 'uv_prepare_init' => 'uv/uv_functions.stub', 'uv_prepare_start' => 'uv/uv_functions.stub', 'uv_prepare_stop' => 'uv/uv_functions.stub', 'uv_process_kill' => 'uv/uv_functions.stub', 'uv_queue_work' => 'uv/uv_functions.stub', 'uv_read_start' => 'uv/uv_functions.stub', 'uv_read_stop' => 'uv/uv_functions.stub', 'uv_ref' => 'uv/uv_functions.stub', 'uv_resident_set_memory' => 'uv/uv_functions.stub', 'uv_run' => 'uv/uv_functions.stub', 'uv_run_once' => 'uv/uv_functions.stub', 'uv_rwlock_init' => 'uv/uv_functions.stub', 'uv_rwlock_rdlock' => 'uv/uv_functions.stub', 'uv_rwlock_rdunlock' => 'uv/uv_functions.stub', 'uv_rwlock_tryrdlock' => 'uv/uv_functions.stub', 'uv_rwlock_trywrlock' => 'uv/uv_functions.stub', 'uv_rwlock_wrlock' => 'uv/uv_functions.stub', 'uv_rwlock_wrunlock' => 'uv/uv_functions.stub', 'uv_sem_init' => 'uv/uv_functions.stub', 'uv_sem_post' => 'uv/uv_functions.stub', 'uv_sem_trywait' => 'uv/uv_functions.stub', 'uv_sem_wait' => 'uv/uv_functions.stub', 'uv_shutdown' => 'uv/uv_functions.stub', 'uv_signal_stop' => 'uv/uv_functions.stub', 'uv_spawn' => 'uv/uv_functions.stub', 'uv_stdio_new' => 'uv/uv_functions.stub', 'uv_stop' => 'uv/uv_functions.stub', 'uv_strerror' => 'uv/uv_functions.stub', 'uv_tcp_bind' => 'uv/uv_functions.stub', 'uv_tcp_bind6' => 'uv/uv_functions.stub', 'uv_tcp_connect' => 'uv/uv_functions.stub', 'uv_tcp_connect6' => 'uv/uv_functions.stub', 'uv_tcp_getpeername' => 'uv/uv_functions.stub', 'uv_tcp_getsockname' => 'uv/uv_functions.stub', 'uv_tcp_init' => 'uv/uv_functions.stub', 'uv_tcp_nodelay' => 'uv/uv_functions.stub', 'uv_timer_again' => 'uv/uv_functions.stub', 'uv_timer_get_repeat' => 'uv/uv_functions.stub', 'uv_timer_init' => 'uv/uv_functions.stub', 'uv_timer_set_repeat' => 'uv/uv_functions.stub', 'uv_timer_start' => 'uv/uv_functions.stub', 'uv_timer_stop' => 'uv/uv_functions.stub', 'uv_tty_get_winsize' => 'uv/uv_functions.stub', 'uv_tty_init' => 'uv/uv_functions.stub', 'uv_tty_reset_mode' => 'uv/uv_functions.stub', 'uv_tty_set_mode' => 'uv/uv_functions.stub', 'uv_udp_bind' => 'uv/uv_functions.stub', 'uv_udp_bind6' => 'uv/uv_functions.stub', 'uv_udp_getsockname' => 'uv/uv_functions.stub', 'uv_udp_init' => 'uv/uv_functions.stub', 'uv_udp_recv_start' => 'uv/uv_functions.stub', 'uv_udp_recv_stop' => 'uv/uv_functions.stub', 'uv_udp_send' => 'uv/uv_functions.stub', 'uv_udp_send6' => 'uv/uv_functions.stub', 'uv_udp_set_broadcast' => 'uv/uv_functions.stub', 'uv_udp_set_membership' => 'uv/uv_functions.stub', 'uv_udp_set_multicast_loop' => 'uv/uv_functions.stub', 'uv_udp_set_multicast_ttl' => 'uv/uv_functions.stub', 'uv_unref' => 'uv/uv_functions.stub', 'uv_update_time' => 'uv/uv_functions.stub', 'uv_uptime' => 'uv/uv_functions.stub', 'uv_walk' => 'uv/uv_functions.stub', 'uv_write' => 'uv/uv_functions.stub', 'uv_write2' => 'uv/uv_functions.stub', 'var_dump' => 'standard/standard_4.stub', 'var_export' => 'standard/standard_4.stub', 'variant_abs' => 'com_dotnet/com_dotnet.stub', 'variant_add' => 'com_dotnet/com_dotnet.stub', 'variant_and' => 'com_dotnet/com_dotnet.stub', 'variant_cast' => 'com_dotnet/com_dotnet.stub', 'variant_cat' => 'com_dotnet/com_dotnet.stub', 'variant_cmp' => 'com_dotnet/com_dotnet.stub', 'variant_date_from_timestamp' => 'com_dotnet/com_dotnet.stub', 'variant_date_to_timestamp' => 'com_dotnet/com_dotnet.stub', 'variant_div' => 'com_dotnet/com_dotnet.stub', 'variant_eqv' => 'com_dotnet/com_dotnet.stub', 'variant_fix' => 'com_dotnet/com_dotnet.stub', 'variant_get_type' => 'com_dotnet/com_dotnet.stub', 'variant_idiv' => 'com_dotnet/com_dotnet.stub', 'variant_imp' => 'com_dotnet/com_dotnet.stub', 'variant_int' => 'com_dotnet/com_dotnet.stub', 'variant_mod' => 'com_dotnet/com_dotnet.stub', 'variant_mul' => 'com_dotnet/com_dotnet.stub', 'variant_neg' => 'com_dotnet/com_dotnet.stub', 'variant_not' => 'com_dotnet/com_dotnet.stub', 'variant_or' => 'com_dotnet/com_dotnet.stub', 'variant_pow' => 'com_dotnet/com_dotnet.stub', 'variant_round' => 'com_dotnet/com_dotnet.stub', 'variant_set' => 'com_dotnet/com_dotnet.stub', 'variant_set_type' => 'com_dotnet/com_dotnet.stub', 'variant_sub' => 'com_dotnet/com_dotnet.stub', 'variant_xor' => 'com_dotnet/com_dotnet.stub', 'version_compare' => 'standard/standard_9.stub', 'vfprintf' => 'standard/standard_2.stub', 'virtual' => 'apache/apache.stub', 'vprintf' => 'standard/standard_2.stub', 'vsprintf' => 'standard/standard_2.stub', 'wb_call_function' => 'winbinder/winbinder.stub', 'wb_create_font' => 'winbinder/winbinder.stub', 'wb_create_image' => 'winbinder/winbinder.stub', 'wb_create_mask' => 'winbinder/winbinder.stub', 'wb_create_timer' => 'winbinder/winbinder.stub', 'wb_create_window' => 'winbinder/winbinder.stub', 'wb_delete_items' => 'winbinder/winbinder.stub', 'wb_destroy_control' => 'winbinder/winbinder.stub', 'wb_destroy_font' => 'winbinder/winbinder.stub', 'wb_destroy_image' => 'winbinder/winbinder.stub', 'wb_destroy_timer' => 'winbinder/winbinder.stub', 'wb_destroy_window' => 'winbinder/winbinder.stub', 'wb_draw_ellipse' => 'winbinder/winbinder.stub', 'wb_draw_image' => 'winbinder/winbinder.stub', 'wb_draw_line' => 'winbinder/winbinder.stub', 'wb_draw_point' => 'winbinder/winbinder.stub', 'wb_draw_rect' => 'winbinder/winbinder.stub', 'wb_draw_text' => 'winbinder/winbinder.stub', 'wb_exec' => 'winbinder/winbinder.stub', 'wb_find_file' => 'winbinder/winbinder.stub', 'wb_get_address' => 'winbinder/winbinder.stub', 'wb_get_class' => 'winbinder/winbinder.stub', 'wb_get_control' => 'winbinder/winbinder.stub', 'wb_get_enabled' => 'winbinder/winbinder.stub', 'wb_get_enum_callback' => 'winbinder/winbinder.stub', 'wb_get_focus' => 'winbinder/winbinder.stub', 'wb_get_function_address' => 'winbinder/winbinder.stub', 'wb_get_hook_callback' => 'winbinder/winbinder.stub', 'wb_get_id' => 'winbinder/winbinder.stub', 'wb_get_image_data' => 'winbinder/winbinder.stub', 'wb_get_instance' => 'winbinder/winbinder.stub', 'wb_get_item_count' => 'winbinder/winbinder.stub', 'wb_get_item_list' => 'winbinder/winbinder.stub', 'wb_get_level' => 'winbinder/winbinder.stub', 'wb_get_midi_callback' => 'winbinder/winbinder.stub', 'wb_get_parent' => 'winbinder/winbinder.stub', 'wb_get_pixel' => 'winbinder/winbinder.stub', 'wb_get_position' => 'winbinder/winbinder.stub', 'wb_get_registry_key' => 'winbinder/winbinder.stub', 'wb_get_selected' => 'winbinder/winbinder.stub', 'wb_get_size' => 'winbinder/winbinder.stub', 'wb_get_state' => 'winbinder/winbinder.stub', 'wb_get_system_info' => 'winbinder/winbinder.stub', 'wb_get_value' => 'winbinder/winbinder.stub', 'wb_get_visible' => 'winbinder/winbinder.stub', 'wb_load_image' => 'winbinder/winbinder.stub', 'wb_load_library' => 'winbinder/winbinder.stub', 'wb_main_loop' => 'winbinder/winbinder.stub', 'wb_message_box' => 'winbinder/winbinder.stub', 'wb_peek' => 'winbinder/winbinder.stub', 'wb_play_sound' => 'winbinder/winbinder.stub', 'wb_poke' => 'winbinder/winbinder.stub', 'wb_refresh' => 'winbinder/winbinder.stub', 'wb_release_library' => 'winbinder/winbinder.stub', 'wb_save_image' => 'winbinder/winbinder.stub', 'wb_send_message' => 'winbinder/winbinder.stub', 'wb_set_area' => 'winbinder/winbinder.stub', 'wb_set_cursor' => 'winbinder/winbinder.stub', 'wb_set_enabled' => 'winbinder/winbinder.stub', 'wb_set_focus' => 'winbinder/winbinder.stub', 'wb_set_font' => 'winbinder/winbinder.stub', 'wb_set_handler' => 'winbinder/winbinder.stub', 'wb_set_image' => 'winbinder/winbinder.stub', 'wb_set_item_image' => 'winbinder/winbinder.stub', 'wb_set_location' => 'winbinder/winbinder.stub', 'wb_set_position' => 'winbinder/winbinder.stub', 'wb_set_range' => 'winbinder/winbinder.stub', 'wb_set_registry_key' => 'winbinder/winbinder.stub', 'wb_set_size' => 'winbinder/winbinder.stub', 'wb_set_state' => 'winbinder/winbinder.stub', 'wb_set_style' => 'winbinder/winbinder.stub', 'wb_set_visible' => 'winbinder/winbinder.stub', 'wb_sort' => 'winbinder/winbinder.stub', 'wb_stop_sound' => 'winbinder/winbinder.stub', 'wb_sys_dlg_color' => 'winbinder/winbinder.stub', 'wb_sys_dlg_path' => 'winbinder/winbinder.stub', 'wb_wait' => 'winbinder/winbinder.stub', 'wbtemp_clear_listview_columns' => 'winbinder/winbinder.stub', 'wbtemp_create_control' => 'winbinder/winbinder.stub', 'wbtemp_create_item' => 'winbinder/winbinder.stub', 'wbtemp_create_listview_column' => 'winbinder/winbinder.stub', 'wbtemp_create_listview_item' => 'winbinder/winbinder.stub', 'wbtemp_create_menu' => 'winbinder/winbinder.stub', 'wbtemp_create_statusbar_items' => 'winbinder/winbinder.stub', 'wbtemp_create_toolbar' => 'winbinder/winbinder.stub', 'wbtemp_create_treeview_item' => 'winbinder/winbinder.stub', 'wbtemp_get_listview_columns' => 'winbinder/winbinder.stub', 'wbtemp_get_listview_item_checked' => 'winbinder/winbinder.stub', 'wbtemp_get_listview_text' => 'winbinder/winbinder.stub', 'wbtemp_get_menu_item_checked' => 'winbinder/winbinder.stub', 'wbtemp_get_text' => 'winbinder/winbinder.stub', 'wbtemp_get_treeview_item_text' => 'winbinder/winbinder.stub', 'wbtemp_select_all_listview_items' => 'winbinder/winbinder.stub', 'wbtemp_select_listview_item' => 'winbinder/winbinder.stub', 'wbtemp_select_tab' => 'winbinder/winbinder.stub', 'wbtemp_set_accel_table' => 'winbinder/winbinder.stub', 'wbtemp_set_listview_item_checked' => 'winbinder/winbinder.stub', 'wbtemp_set_listview_item_text' => 'winbinder/winbinder.stub', 'wbtemp_set_menu_item_checked' => 'winbinder/winbinder.stub', 'wbtemp_set_menu_item_image' => 'winbinder/winbinder.stub', 'wbtemp_set_menu_item_selected' => 'winbinder/winbinder.stub', 'wbtemp_set_text' => 'winbinder/winbinder.stub', 'wbtemp_set_treeview_item_selected' => 'winbinder/winbinder.stub', 'wbtemp_set_treeview_item_text' => 'winbinder/winbinder.stub', 'wbtemp_set_treeview_item_value' => 'winbinder/winbinder.stub', 'wbtemp_set_value' => 'winbinder/winbinder.stub', 'wbtemp_sys_dlg_open' => 'winbinder/winbinder.stub', 'wbtemp_sys_dlg_save' => 'winbinder/winbinder.stub', 'wddx_add_vars' => 'wddx/wddx.stub', 'wddx_deserialize' => 'wddx/wddx.stub', 'wddx_packet_end' => 'wddx/wddx.stub', 'wddx_packet_start' => 'wddx/wddx.stub', 'wddx_serialize_value' => 'wddx/wddx.stub', 'wddx_serialize_vars' => 'wddx/wddx.stub', 'win32_continue_service' => 'win32service/win32service.stub', 'win32_create_service' => 'win32service/win32service.stub', 'win32_delete_service' => 'win32service/win32service.stub', 'win32_get_last_control_message' => 'win32service/win32service.stub', 'win32_pause_service' => 'win32service/win32service.stub', 'win32_query_service_status' => 'win32service/win32service.stub', 'win32_set_service_status' => 'win32service/win32service.stub', 'win32_start_service' => 'win32service/win32service.stub', 'win32_start_service_ctrl_dispatcher' => 'win32service/win32service.stub', 'win32_stop_service' => 'win32service/win32service.stub', 'wincache_fcache_fileinfo' => 'wincache/wincache.stub', 'wincache_fcache_meminfo' => 'wincache/wincache.stub', 'wincache_lock' => 'wincache/wincache.stub', 'wincache_ocache_fileinfo' => 'wincache/wincache.stub', 'wincache_ocache_meminfo' => 'wincache/wincache.stub', 'wincache_refresh_if_changed' => 'wincache/wincache.stub', 'wincache_rplist_fileinfo' => 'wincache/wincache.stub', 'wincache_rplist_meminfo' => 'wincache/wincache.stub', 'wincache_scache_info' => 'wincache/wincache.stub', 'wincache_scache_meminfo' => 'wincache/wincache.stub', 'wincache_ucache_add' => 'wincache/wincache.stub', 'wincache_ucache_cas' => 'wincache/wincache.stub', 'wincache_ucache_clear' => 'wincache/wincache.stub', 'wincache_ucache_dec' => 'wincache/wincache.stub', 'wincache_ucache_delete' => 'wincache/wincache.stub', 'wincache_ucache_exists' => 'wincache/wincache.stub', 'wincache_ucache_get' => 'wincache/wincache.stub', 'wincache_ucache_inc' => 'wincache/wincache.stub', 'wincache_ucache_info' => 'wincache/wincache.stub', 'wincache_ucache_meminfo' => 'wincache/wincache.stub', 'wincache_ucache_set' => 'wincache/wincache.stub', 'wincache_unlock' => 'wincache/wincache.stub', 'wordwrap' => 'standard/standard_0.stub', 'xcache_asm' => 'xcache/xcache.stub', 'xcache_clear_cache' => 'xcache/xcache.stub', 'xcache_coredump' => 'xcache/xcache.stub', 'xcache_count' => 'xcache/xcache.stub', 'xcache_coverager_decode' => 'xcache/xcache.stub', 'xcache_coverager_get' => 'xcache/xcache.stub', 'xcache_coverager_start' => 'xcache/xcache.stub', 'xcache_coverager_stop' => 'xcache/xcache.stub', 'xcache_dasm_file' => 'xcache/xcache.stub', 'xcache_dasm_string' => 'xcache/xcache.stub', 'xcache_dec' => 'xcache/xcache.stub', 'xcache_decode' => 'xcache/xcache.stub', 'xcache_encode' => 'xcache/xcache.stub', 'xcache_get' => 'xcache/xcache.stub', 'xcache_get_data_type' => 'xcache/xcache.stub', 'xcache_get_op_spec' => 'xcache/xcache.stub', 'xcache_get_op_type' => 'xcache/xcache.stub', 'xcache_get_opcode' => 'xcache/xcache.stub', 'xcache_get_opcode_spec' => 'xcache/xcache.stub', 'xcache_inc' => 'xcache/xcache.stub', 'xcache_info' => 'xcache/xcache.stub', 'xcache_is_autoglobal' => 'xcache/xcache.stub', 'xcache_isset' => 'xcache/xcache.stub', 'xcache_list' => 'xcache/xcache.stub', 'xcache_set' => 'xcache/xcache.stub', 'xcache_unset' => 'xcache/xcache.stub', 'xcache_unset_by_prefix' => 'xcache/xcache.stub', 'xdebug_break' => 'xdebug/xdebug.stub', 'xdebug_call_class' => 'xdebug/xdebug.stub', 'xdebug_call_file' => 'xdebug/xdebug.stub', 'xdebug_call_function' => 'xdebug/xdebug.stub', 'xdebug_call_line' => 'xdebug/xdebug.stub', 'xdebug_clear_aggr_profiling_data' => 'xdebug/xdebug.stub', 'xdebug_code_coverage_started' => 'xdebug/xdebug.stub', 'xdebug_connect_to_client' => 'xdebug/xdebug.stub', 'xdebug_debug_zval' => 'xdebug/xdebug.stub', 'xdebug_debug_zval_stdout' => 'xdebug/xdebug.stub', 'xdebug_disable' => 'xdebug/xdebug.stub', 'xdebug_dump_aggr_profiling_data' => 'xdebug/xdebug.stub', 'xdebug_dump_superglobals' => 'xdebug/xdebug.stub', 'xdebug_enable' => 'xdebug/xdebug.stub', 'xdebug_get_code_coverage' => 'xdebug/xdebug.stub', 'xdebug_get_collected_errors' => 'xdebug/xdebug.stub', 'xdebug_get_declared_vars' => 'xdebug/xdebug.stub', 'xdebug_get_formatted_function_stack' => 'xdebug/xdebug.stub', 'xdebug_get_function_count' => 'xdebug/xdebug.stub', 'xdebug_get_function_stack' => 'xdebug/xdebug.stub', 'xdebug_get_gc_run_count' => 'xdebug/xdebug.stub', 'xdebug_get_gc_total_collected_roots' => 'xdebug/xdebug.stub', 'xdebug_get_gcstats_filename' => 'xdebug/xdebug.stub', 'xdebug_get_headers' => 'xdebug/xdebug.stub', 'xdebug_get_monitored_functions' => 'xdebug/xdebug.stub', 'xdebug_get_profiler_filename' => 'xdebug/xdebug.stub', 'xdebug_get_stack_depth' => 'xdebug/xdebug.stub', 'xdebug_get_tracefile_name' => 'xdebug/xdebug.stub', 'xdebug_info' => 'xdebug/xdebug.stub', 'xdebug_is_debugger_active' => 'xdebug/xdebug.stub', 'xdebug_is_enabled' => 'xdebug/xdebug.stub', 'xdebug_memory_usage' => 'xdebug/xdebug.stub', 'xdebug_notify' => 'xdebug/xdebug.stub', 'xdebug_peak_memory_usage' => 'xdebug/xdebug.stub', 'xdebug_print_function_stack' => 'xdebug/xdebug.stub', 'xdebug_set_filter' => 'xdebug/xdebug.stub', 'xdebug_start_code_coverage' => 'xdebug/xdebug.stub', 'xdebug_start_error_collection' => 'xdebug/xdebug.stub', 'xdebug_start_function_monitor' => 'xdebug/xdebug.stub', 'xdebug_start_gcstats' => 'xdebug/xdebug.stub', 'xdebug_start_trace' => 'xdebug/xdebug.stub', 'xdebug_stop_code_coverage' => 'xdebug/xdebug.stub', 'xdebug_stop_error_collection' => 'xdebug/xdebug.stub', 'xdebug_stop_function_monitor' => 'xdebug/xdebug.stub', 'xdebug_stop_gcstats' => 'xdebug/xdebug.stub', 'xdebug_stop_trace' => 'xdebug/xdebug.stub', 'xdebug_time_index' => 'xdebug/xdebug.stub', 'xdebug_var_dump' => 'xdebug/xdebug.stub', 'xdiff_file_bdiff' => 'xdiff/xdiff.stub', 'xdiff_file_bdiff_size' => 'xdiff/xdiff.stub', 'xdiff_file_bpatch' => 'xdiff/xdiff.stub', 'xdiff_file_diff' => 'xdiff/xdiff.stub', 'xdiff_file_diff_binary' => 'xdiff/xdiff.stub', 'xdiff_file_merge3' => 'xdiff/xdiff.stub', 'xdiff_file_patch' => 'xdiff/xdiff.stub', 'xdiff_file_patch_binary' => 'xdiff/xdiff.stub', 'xdiff_file_rabdiff' => 'xdiff/xdiff.stub', 'xdiff_string_bdiff' => 'xdiff/xdiff.stub', 'xdiff_string_bdiff_size' => 'xdiff/xdiff.stub', 'xdiff_string_bpatch' => 'xdiff/xdiff.stub', 'xdiff_string_diff' => 'xdiff/xdiff.stub', 'xdiff_string_diff_binary' => 'xdiff/xdiff.stub', 'xdiff_string_merge3' => 'xdiff/xdiff.stub', 'xdiff_string_patch' => 'xdiff/xdiff.stub', 'xdiff_string_patch_binary' => 'xdiff/xdiff.stub', 'xdiff_string_rabdiff' => 'xdiff/xdiff.stub', 'xhprof_disable' => 'xhprof/xhprof.stub', 'xhprof_enable' => 'xhprof/xhprof.stub', 'xhprof_sample_disable' => 'xhprof/xhprof.stub', 'xhprof_sample_enable' => 'xhprof/xhprof.stub', 'xml_error_string' => 'xml/xml.stub', 'xml_get_current_byte_index' => 'xml/xml.stub', 'xml_get_current_column_number' => 'xml/xml.stub', 'xml_get_current_line_number' => 'xml/xml.stub', 'xml_get_error_code' => 'xml/xml.stub', 'xml_parse' => 'xml/xml.stub', 'xml_parse_into_struct' => 'xml/xml.stub', 'xml_parser_create' => 'xml/xml.stub', 'xml_parser_create_ns' => 'xml/xml.stub', 'xml_parser_free' => 'xml/xml.stub', 'xml_parser_get_option' => 'xml/xml.stub', 'xml_parser_set_option' => 'xml/xml.stub', 'xml_set_character_data_handler' => 'xml/xml.stub', 'xml_set_default_handler' => 'xml/xml.stub', 'xml_set_element_handler' => 'xml/xml.stub', 'xml_set_end_namespace_decl_handler' => 'xml/xml.stub', 'xml_set_external_entity_ref_handler' => 'xml/xml.stub', 'xml_set_notation_decl_handler' => 'xml/xml.stub', 'xml_set_object' => 'xml/xml.stub', 'xml_set_processing_instruction_handler' => 'xml/xml.stub', 'xml_set_start_namespace_decl_handler' => 'xml/xml.stub', 'xml_set_unparsed_entity_decl_handler' => 'xml/xml.stub', 'xmlrpc_decode' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_decode_request' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_encode' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_encode_request' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_get_type' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_is_fault' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_parse_method_descriptions' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_server_add_introspection_data' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_server_call_method' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_server_create' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_server_destroy' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_server_register_introspection_callback' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_server_register_method' => 'xmlrpc/xmlrpc.stub', 'xmlrpc_set_type' => 'xmlrpc/xmlrpc.stub', 'xmlwriter_end_attribute' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_cdata' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_comment' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_document' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_dtd' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_dtd_attlist' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_dtd_element' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_dtd_entity' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_element' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_end_pi' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_flush' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_full_end_element' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_open_memory' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_open_uri' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_output_memory' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_set_indent' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_set_indent_string' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_attribute' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_attribute_ns' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_cdata' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_comment' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_document' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_dtd' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_dtd_attlist' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_dtd_element' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_dtd_entity' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_element' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_element_ns' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_start_pi' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_text' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_attribute' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_attribute_ns' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_cdata' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_comment' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_dtd' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_dtd_attlist' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_dtd_element' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_dtd_entity' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_element' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_element_ns' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_pi' => 'xmlwriter/xmlwriter.stub', 'xmlwriter_write_raw' => 'xmlwriter/xmlwriter.stub', 'xxtea_decrypt' => 'xxtea/xxtea.stub', 'xxtea_encrypt' => 'xxtea/xxtea.stub', 'yaml_emit' => 'yaml/yaml.stub', 'yaml_emit_file' => 'yaml/yaml.stub', 'yaml_parse' => 'yaml/yaml.stub', 'yaml_parse_file' => 'yaml/yaml.stub', 'yaml_parse_url' => 'yaml/yaml.stub', 'zem_get_extension_info_by_id' => 'ZendUtils/ZendUtils.stub', 'zem_get_extension_info_by_name' => 'ZendUtils/ZendUtils.stub', 'zem_get_extensions_info' => 'ZendUtils/ZendUtils.stub', 'zem_get_license_info' => 'ZendUtils/ZendUtils.stub', 'zend_current_obfuscation_level' => 'zend/zend_f.stub', 'zend_disk_cache_clear' => 'ZendCache/ZendCache.stub', 'zend_disk_cache_delete' => 'ZendCache/ZendCache.stub', 'zend_disk_cache_fetch' => 'ZendCache/ZendCache.stub', 'zend_disk_cache_info' => 'ZendCache/ZendCache.stub', 'zend_disk_cache_store' => 'ZendCache/ZendCache.stub', 'zend_get_id' => 'zend/zend_f.stub', 'zend_is_configuration_changed' => 'ZendUtils/ZendUtils.stub', 'zend_loader_current_file' => 'zend/zend_f.stub', 'zend_loader_enabled' => 'zend/zend_f.stub', 'zend_loader_file_encoded' => 'zend/zend_f.stub', 'zend_loader_file_licensed' => 'zend/zend_f.stub', 'zend_loader_install_license' => 'zend/zend_f.stub', 'zend_logo_guid' => 'standard/standard_0.stub', 'zend_obfuscate_class_name' => 'zend/zend_f.stub', 'zend_obfuscate_function_name' => 'zend/zend_f.stub', 'zend_optimizer_version' => 'zend/zend_f.stub', 'zend_runtime_obfuscate' => 'zend/zend_f.stub', 'zend_send_buffer' => 'zend/zend.stub', 'zend_send_file' => 'zend/zend.stub', 'zend_set_configuration_changed' => 'ZendUtils/ZendUtils.stub', 'zend_shm_cache_clear' => 'ZendCache/ZendCache.stub', 'zend_shm_cache_delete' => 'ZendCache/ZendCache.stub', 'zend_shm_cache_fetch' => 'ZendCache/ZendCache.stub', 'zend_shm_cache_info' => 'ZendCache/ZendCache.stub', 'zend_shm_cache_store' => 'ZendCache/ZendCache.stub', 'zend_version' => 'Core/Core.stub', 'zip_close' => 'zip/zip.stub', 'zip_entry_close' => 'zip/zip.stub', 'zip_entry_compressedsize' => 'zip/zip.stub', 'zip_entry_compressionmethod' => 'zip/zip.stub', 'zip_entry_filesize' => 'zip/zip.stub', 'zip_entry_name' => 'zip/zip.stub', 'zip_entry_open' => 'zip/zip.stub', 'zip_entry_read' => 'zip/zip.stub', 'zip_open' => 'zip/zip.stub', 'zip_read' => 'zip/zip.stub', 'zlib_decode' => 'zlib/zlib.stub', 'zlib_encode' => 'zlib/zlib.stub', 'zlib_get_coding_type' => 'zlib/zlib.stub', 'zstd_compress' => 'zstd/zstd.stub', 'zstd_compress_dict' => 'zstd/zstd.stub', 'zstd_compress_usingcdict' => 'zstd/zstd.stub', 'zstd_decompress_dict' => 'zstd/zstd.stub', 'zstd_decompress_usingcdict' => 'zstd/zstd.stub', 'zstd_uncompress' => 'zstd/zstd.stub', 'zstd_uncompress_dict' => 'zstd/zstd.stub', 'zstd_uncompress_usingcdict' => 'zstd/zstd.stub');
    const CONSTANTS = array('ABDAY_1' => 'standard/standard_defines.stub', 'ABDAY_2' => 'standard/standard_defines.stub', 'ABDAY_3' => 'standard/standard_defines.stub', 'ABDAY_4' => 'standard/standard_defines.stub', 'ABDAY_5' => 'standard/standard_defines.stub', 'ABDAY_6' => 'standard/standard_defines.stub', 'ABDAY_7' => 'standard/standard_defines.stub', 'ABMON_1' => 'standard/standard_defines.stub', 'ABMON_10' => 'standard/standard_defines.stub', 'ABMON_11' => 'standard/standard_defines.stub', 'ABMON_12' => 'standard/standard_defines.stub', 'ABMON_2' => 'standard/standard_defines.stub', 'ABMON_3' => 'standard/standard_defines.stub', 'ABMON_4' => 'standard/standard_defines.stub', 'ABMON_5' => 'standard/standard_defines.stub', 'ABMON_6' => 'standard/standard_defines.stub', 'ABMON_7' => 'standard/standard_defines.stub', 'ABMON_8' => 'standard/standard_defines.stub', 'ABMON_9' => 'standard/standard_defines.stub', 'AF_INET' => 'sockets/sockets.stub', 'AF_INET6' => 'sockets/sockets.stub', 'AF_UNIX' => 'sockets/sockets.stub', 'AI_ADDRCONFIG' => 'sockets/sockets.stub', 'AI_ALL' => 'sockets/sockets.stub', 'AI_CANONNAME' => 'sockets/sockets.stub', 'AI_NUMERICHOST' => 'sockets/sockets.stub', 'AI_NUMERICSERV' => 'sockets/sockets.stub', 'AI_PASSIVE' => 'sockets/sockets.stub', 'AI_V4MAPPED' => 'sockets/sockets.stub', 'ALT_DIGITS' => 'standard/standard_defines.stub', 'AMQP_AUTOACK' => 'amqp/amqp.stub', 'AMQP_AUTODELETE' => 'amqp/amqp.stub', 'AMQP_DELIVERY_MODE_PERSISTENT' => 'amqp/amqp.stub', 'AMQP_DELIVERY_MODE_TRANSIENT' => 'amqp/amqp.stub', 'AMQP_DURABLE' => 'amqp/amqp.stub', 'AMQP_EXCLUSIVE' => 'amqp/amqp.stub', 'AMQP_EXTENSION_VERSION' => 'amqp/amqp.stub', 'AMQP_EXTENSION_VERSION_EXTRA' => 'amqp/amqp.stub', 'AMQP_EXTENSION_VERSION_ID' => 'amqp/amqp.stub', 'AMQP_EXTENSION_VERSION_MAJOR' => 'amqp/amqp.stub', 'AMQP_EXTENSION_VERSION_MINOR' => 'amqp/amqp.stub', 'AMQP_EXTENSION_VERSION_PATCH' => 'amqp/amqp.stub', 'AMQP_EX_TYPE_DIRECT' => 'amqp/amqp.stub', 'AMQP_EX_TYPE_FANOUT' => 'amqp/amqp.stub', 'AMQP_EX_TYPE_HEADERS' => 'amqp/amqp.stub', 'AMQP_EX_TYPE_TOPIC' => 'amqp/amqp.stub', 'AMQP_IFEMPTY' => 'amqp/amqp.stub', 'AMQP_IFUNUSED' => 'amqp/amqp.stub', 'AMQP_IMMEDIATE' => 'amqp/amqp.stub', 'AMQP_INTERNAL' => 'amqp/amqp.stub', 'AMQP_JUST_CONSUME' => 'amqp/amqp.stub', 'AMQP_MANDATORY' => 'amqp/amqp.stub', 'AMQP_MULTIPLE' => 'amqp/amqp.stub', 'AMQP_NOLOCAL' => 'amqp/amqp.stub', 'AMQP_NOPARAM' => 'amqp/amqp.stub', 'AMQP_NOWAIT' => 'amqp/amqp.stub', 'AMQP_OS_SOCKET_TIMEOUT_ERRNO' => 'amqp/amqp.stub', 'AMQP_PASSIVE' => 'amqp/amqp.stub', 'AMQP_REQUEUE' => 'amqp/amqp.stub', 'AMQP_SASL_METHOD_EXTERNAL' => 'amqp/amqp.stub', 'AMQP_SASL_METHOD_PLAIN' => 'amqp/amqp.stub', 'AM_STR' => 'standard/standard_defines.stub', 'APACHE_MAP' => 'soap/soap.stub', 'APC_BIN_VERIFY_CRC32' => 'apcu/apcu.stub', 'APC_BIN_VERIFY_MD5' => 'apcu/apcu.stub', 'APC_ITER_ALL' => 'apcu/apcu.stub', 'APC_ITER_ATIME' => 'apcu/apcu.stub', 'APC_ITER_CTIME' => 'apcu/apcu.stub', 'APC_ITER_DEVICE' => 'apcu/apcu.stub', 'APC_ITER_DTIME' => 'apcu/apcu.stub', 'APC_ITER_FILENAME' => 'apcu/apcu.stub', 'APC_ITER_INODE' => 'apcu/apcu.stub', 'APC_ITER_KEY' => 'apcu/apcu.stub', 'APC_ITER_MD5' => 'apcu/apcu.stub', 'APC_ITER_MEM_SIZE' => 'apcu/apcu.stub', 'APC_ITER_MTIME' => 'apcu/apcu.stub', 'APC_ITER_NONE' => 'apcu/apcu.stub', 'APC_ITER_NUM_HITS' => 'apcu/apcu.stub', 'APC_ITER_REFCOUNT' => 'apcu/apcu.stub', 'APC_ITER_TTL' => 'apcu/apcu.stub', 'APC_ITER_TYPE' => 'apcu/apcu.stub', 'APC_ITER_VALUE' => 'apcu/apcu.stub', 'APC_LIST_ACTIVE' => 'apcu/apcu.stub', 'APC_LIST_DELETED' => 'apcu/apcu.stub', 'ARRAY_FILTER_USE_BOTH' => 'standard/standard_9.stub', 'ARRAY_FILTER_USE_KEY' => 'standard/standard_9.stub', 'ASSERT_ACTIVE' => 'standard/standard_defines.stub', 'ASSERT_BAIL' => 'standard/standard_defines.stub', 'ASSERT_CALLBACK' => 'standard/standard_defines.stub', 'ASSERT_EXCEPTION' => 'standard/standard_defines.stub', 'ASSERT_QUIET_EVAL' => 'standard/standard_defines.stub', 'ASSERT_WARNING' => 'standard/standard_defines.stub', 'Accel' => 'winbinder/winbinder.stub', 'AppWindow' => 'winbinder/winbinder.stub', 'BLACK' => 'winbinder/winbinder.stub', 'BLUE' => 'winbinder/winbinder.stub', 'BROTLI_COMPRESS_LEVEL_DEFAULT' => 'brotli/brotli.stub', 'BROTLI_COMPRESS_LEVEL_MAX' => 'brotli/brotli.stub', 'BROTLI_COMPRESS_LEVEL_MIN' => 'brotli/brotli.stub', 'BROTLI_FINISH' => 'brotli/brotli.stub', 'BROTLI_FLUSH' => 'brotli/brotli.stub', 'BROTLI_FONT' => 'brotli/brotli.stub', 'BROTLI_GENERIC' => 'brotli/brotli.stub', 'BROTLI_PROCESS' => 'brotli/brotli.stub', 'BROTLI_TEXT' => 'brotli/brotli.stub', 'BUS_ADRALN' => 'pcntl/pcntl.stub', 'BUS_ADRERR' => 'pcntl/pcntl.stub', 'BUS_OBJERR' => 'pcntl/pcntl.stub', 'CAL_DOW_DAYNO' => 'calendar/calendar.stub', 'CAL_DOW_LONG' => 'calendar/calendar.stub', 'CAL_DOW_SHORT' => 'calendar/calendar.stub', 'CAL_EASTER_ALWAYS_GREGORIAN' => 'calendar/calendar.stub', 'CAL_EASTER_ALWAYS_JULIAN' => 'calendar/calendar.stub', 'CAL_EASTER_DEFAULT' => 'calendar/calendar.stub', 'CAL_EASTER_ROMAN' => 'calendar/calendar.stub', 'CAL_FRENCH' => 'calendar/calendar.stub', 'CAL_GREGORIAN' => 'calendar/calendar.stub', 'CAL_JEWISH' => 'calendar/calendar.stub', 'CAL_JEWISH_ADD_ALAFIM' => 'calendar/calendar.stub', 'CAL_JEWISH_ADD_ALAFIM_GERESH' => 'calendar/calendar.stub', 'CAL_JEWISH_ADD_GERESHAYIM' => 'calendar/calendar.stub', 'CAL_JULIAN' => 'calendar/calendar.stub', 'CAL_MONTH_FRENCH' => 'calendar/calendar.stub', 'CAL_MONTH_GREGORIAN_LONG' => 'calendar/calendar.stub', 'CAL_MONTH_GREGORIAN_SHORT' => 'calendar/calendar.stub', 'CAL_MONTH_JEWISH' => 'calendar/calendar.stub', 'CAL_MONTH_JULIAN_LONG' => 'calendar/calendar.stub', 'CAL_MONTH_JULIAN_SHORT' => 'calendar/calendar.stub', 'CAL_NUM_CALS' => 'calendar/calendar.stub', 'CASE_LOWER' => 'standard/standard_defines.stub', 'CASE_UPPER' => 'standard/standard_defines.stub', 'CHAR_MAX' => 'standard/standard_defines.stub', 'CLD_CONTINUED' => 'pcntl/pcntl.stub', 'CLD_DUMPED' => 'pcntl/pcntl.stub', 'CLD_EXITED' => 'pcntl/pcntl.stub', 'CLD_KILLED' => 'pcntl/pcntl.stub', 'CLD_STOPPED' => 'pcntl/pcntl.stub', 'CLD_TRAPPED' => 'pcntl/pcntl.stub', 'CLONE_NEWCGROUP' => 'pcntl/pcntl.stub', 'CLONE_NEWIPC' => 'pcntl/pcntl.stub', 'CLONE_NEWNET' => 'pcntl/pcntl.stub', 'CLONE_NEWNS' => 'pcntl/pcntl.stub', 'CLONE_NEWPID' => 'pcntl/pcntl.stub', 'CLONE_NEWUSER' => 'pcntl/pcntl.stub', 'CLONE_NEWUTS' => 'pcntl/pcntl.stub', 'CLSCTX_ALL' => 'com_dotnet/com_dotnet.stub', 'CLSCTX_INPROC_HANDLER' => 'com_dotnet/com_dotnet.stub', 'CLSCTX_INPROC_SERVER' => 'com_dotnet/com_dotnet.stub', 'CLSCTX_LOCAL_SERVER' => 'com_dotnet/com_dotnet.stub', 'CLSCTX_REMOTE_SERVER' => 'com_dotnet/com_dotnet.stub', 'CLSCTX_SERVER' => 'com_dotnet/com_dotnet.stub', 'CL_EXPUNGE' => 'imap/imap.stub', 'CODESET' => 'standard/standard_defines.stub', 'CONNECTION_ABORTED' => 'standard/standard_defines.stub', 'CONNECTION_NORMAL' => 'standard/standard_defines.stub', 'CONNECTION_TIMEOUT' => 'standard/standard_defines.stub', 'COUNT_NORMAL' => 'standard/standard_defines.stub', 'COUNT_RECURSIVE' => 'standard/standard_defines.stub', 'CP_ACP' => 'com_dotnet/com_dotnet.stub', 'CP_MACCP' => 'com_dotnet/com_dotnet.stub', 'CP_MOVE' => 'imap/imap.stub', 'CP_OEMCP' => 'com_dotnet/com_dotnet.stub', 'CP_SYMBOL' => 'com_dotnet/com_dotnet.stub', 'CP_THREAD_ACP' => 'com_dotnet/com_dotnet.stub', 'CP_UID' => 'imap/imap.stub', 'CP_UTF7' => 'com_dotnet/com_dotnet.stub', 'CP_UTF8' => 'com_dotnet/com_dotnet.stub', 'CREDITS_ALL' => 'standard/standard_defines.stub', 'CREDITS_DOCS' => 'standard/standard_defines.stub', 'CREDITS_FULLPAGE' => 'standard/standard_defines.stub', 'CREDITS_GENERAL' => 'standard/standard_defines.stub', 'CREDITS_GROUP' => 'standard/standard_defines.stub', 'CREDITS_MODULES' => 'standard/standard_defines.stub', 'CREDITS_QA' => 'standard/standard_defines.stub', 'CREDITS_SAPI' => 'standard/standard_defines.stub', 'CRNCYSTR' => 'standard/standard_defines.stub', 'CRYPT_BLOWFISH' => 'standard/standard_defines.stub', 'CRYPT_EXT_DES' => 'standard/standard_defines.stub', 'CRYPT_MD5' => 'standard/standard_defines.stub', 'CRYPT_SALT_LENGTH' => 'standard/standard_defines.stub', 'CRYPT_SHA256' => 'standard/standard_defines.stub', 'CRYPT_SHA512' => 'standard/standard_defines.stub', 'CRYPT_STD_DES' => 'standard/standard_defines.stub', 'CUBRID_ASSOC' => 'cubrid/cubrid.stub', 'CUBRID_ASYNC' => 'cubrid/cubrid.stub', 'CUBRID_AUTOCOMMIT_FALSE' => 'cubrid/cubrid.stub', 'CUBRID_AUTOCOMMIT_TRUE' => 'cubrid/cubrid.stub', 'CUBRID_BOTH' => 'cubrid/cubrid.stub', 'CUBRID_CURSOR_CURRENT' => 'cubrid/cubrid.stub', 'CUBRID_CURSOR_ERROR' => 'cubrid/cubrid.stub', 'CUBRID_CURSOR_FIRST' => 'cubrid/cubrid.stub', 'CUBRID_CURSOR_LAST' => 'cubrid/cubrid.stub', 'CUBRID_CURSOR_SUCCESS' => 'cubrid/cubrid.stub', 'CUBRID_EXEC_QUERY_ALL' => 'cubrid/cubrid.stub', 'CUBRID_INCLUDE_OID' => 'cubrid/cubrid.stub', 'CUBRID_NO_MORE_DATA' => 'cubrid/cubrid.stub', 'CUBRID_NUM' => 'cubrid/cubrid.stub', 'CUBRID_OBJECT' => 'cubrid/cubrid.stub', 'CURLALTSVC_H1' => 'curl/curl_d.stub', 'CURLALTSVC_H2' => 'curl/curl_d.stub', 'CURLALTSVC_H3' => 'curl/curl_d.stub', 'CURLALTSVC_READONLYFILE' => 'curl/curl_d.stub', 'CURLAUTH_ANY' => 'curl/curl_d.stub', 'CURLAUTH_ANYSAFE' => 'curl/curl_d.stub', 'CURLAUTH_AWS_SIGV4' => 'curl/curl_d.stub', 'CURLAUTH_BASIC' => 'curl/curl_d.stub', 'CURLAUTH_BEARER' => 'curl/curl_d.stub', 'CURLAUTH_DIGEST' => 'curl/curl_d.stub', 'CURLAUTH_DIGEST_IE' => 'curl/curl_d.stub', 'CURLAUTH_GSSAPI' => 'curl/curl_d.stub', 'CURLAUTH_GSSNEGOTIATE' => 'curl/curl_d.stub', 'CURLAUTH_NEGOTIATE' => 'curl/curl_d.stub', 'CURLAUTH_NONE' => 'curl/curl_d.stub', 'CURLAUTH_NTLM' => 'curl/curl_d.stub', 'CURLAUTH_NTLM_WB' => 'curl/curl_d.stub', 'CURLAUTH_ONLY' => 'curl/curl_d.stub', 'CURLCLOSEPOLICY_CALLBACK' => 'curl/curl_d.stub', 'CURLCLOSEPOLICY_LEAST_RECENTLY_USED' => 'curl/curl_d.stub', 'CURLCLOSEPOLICY_LEAST_TRAFFIC' => 'curl/curl_d.stub', 'CURLCLOSEPOLICY_OLDEST' => 'curl/curl_d.stub', 'CURLCLOSEPOLICY_SLOWEST' => 'curl/curl_d.stub', 'CURLE_ABORTED_BY_CALLBACK' => 'curl/curl_d.stub', 'CURLE_BAD_CALLING_ORDER' => 'curl/curl_d.stub', 'CURLE_BAD_CONTENT_ENCODING' => 'curl/curl_d.stub', 'CURLE_BAD_DOWNLOAD_RESUME' => 'curl/curl_d.stub', 'CURLE_BAD_FUNCTION_ARGUMENT' => 'curl/curl_d.stub', 'CURLE_BAD_PASSWORD_ENTERED' => 'curl/curl_d.stub', 'CURLE_COULDNT_CONNECT' => 'curl/curl_d.stub', 'CURLE_COULDNT_RESOLVE_HOST' => 'curl/curl_d.stub', 'CURLE_COULDNT_RESOLVE_PROXY' => 'curl/curl_d.stub', 'CURLE_FAILED_INIT' => 'curl/curl_d.stub', 'CURLE_FILESIZE_EXCEEDED' => 'curl/curl_d.stub', 'CURLE_FILE_COULDNT_READ_FILE' => 'curl/curl_d.stub', 'CURLE_FTP_ACCESS_DENIED' => 'curl/curl_d.stub', 'CURLE_FTP_BAD_DOWNLOAD_RESUME' => 'curl/curl_d.stub', 'CURLE_FTP_CANT_GET_HOST' => 'curl/curl_d.stub', 'CURLE_FTP_CANT_RECONNECT' => 'curl/curl_d.stub', 'CURLE_FTP_COULDNT_GET_SIZE' => 'curl/curl_d.stub', 'CURLE_FTP_COULDNT_RETR_FILE' => 'curl/curl_d.stub', 'CURLE_FTP_COULDNT_SET_ASCII' => 'curl/curl_d.stub', 'CURLE_FTP_COULDNT_SET_BINARY' => 'curl/curl_d.stub', 'CURLE_FTP_COULDNT_STOR_FILE' => 'curl/curl_d.stub', 'CURLE_FTP_COULDNT_USE_REST' => 'curl/curl_d.stub', 'CURLE_FTP_PARTIAL_FILE' => 'curl/curl_d.stub', 'CURLE_FTP_PORT_FAILED' => 'curl/curl_d.stub', 'CURLE_FTP_QUOTE_ERROR' => 'curl/curl_d.stub', 'CURLE_FTP_SSL_FAILED' => 'curl/curl_d.stub', 'CURLE_FTP_USER_PASSWORD_INCORRECT' => 'curl/curl_d.stub', 'CURLE_FTP_WEIRD_227_FORMAT' => 'curl/curl_d.stub', 'CURLE_FTP_WEIRD_PASS_REPLY' => 'curl/curl_d.stub', 'CURLE_FTP_WEIRD_PASV_REPLY' => 'curl/curl_d.stub', 'CURLE_FTP_WEIRD_SERVER_REPLY' => 'curl/curl_d.stub', 'CURLE_FTP_WEIRD_USER_REPLY' => 'curl/curl_d.stub', 'CURLE_FTP_WRITE_ERROR' => 'curl/curl_d.stub', 'CURLE_FUNCTION_NOT_FOUND' => 'curl/curl_d.stub', 'CURLE_GOT_NOTHING' => 'curl/curl_d.stub', 'CURLE_HTTP_NOT_FOUND' => 'curl/curl_d.stub', 'CURLE_HTTP_PORT_FAILED' => 'curl/curl_d.stub', 'CURLE_HTTP_POST_ERROR' => 'curl/curl_d.stub', 'CURLE_HTTP_RANGE_ERROR' => 'curl/curl_d.stub', 'CURLE_HTTP_RETURNED_ERROR' => 'curl/curl_d.stub', 'CURLE_LDAP_CANNOT_BIND' => 'curl/curl_d.stub', 'CURLE_LDAP_INVALID_URL' => 'curl/curl_d.stub', 'CURLE_LDAP_SEARCH_FAILED' => 'curl/curl_d.stub', 'CURLE_LIBRARY_NOT_FOUND' => 'curl/curl_d.stub', 'CURLE_MALFORMAT_USER' => 'curl/curl_d.stub', 'CURLE_OBSOLETE' => 'curl/curl_d.stub', 'CURLE_OK' => 'curl/curl_d.stub', 'CURLE_OPERATION_TIMEDOUT' => 'curl/curl_d.stub', 'CURLE_OPERATION_TIMEOUTED' => 'curl/curl_d.stub', 'CURLE_OUT_OF_MEMORY' => 'curl/curl_d.stub', 'CURLE_PARTIAL_FILE' => 'curl/curl_d.stub', 'CURLE_PROXY' => 'curl/curl_d.stub', 'CURLE_READ_ERROR' => 'curl/curl_d.stub', 'CURLE_RECV_ERROR' => 'curl/curl_d.stub', 'CURLE_SEND_ERROR' => 'curl/curl_d.stub', 'CURLE_SHARE_IN_USE' => 'curl/curl_d.stub', 'CURLE_SSH' => 'curl/curl_d.stub', 'CURLE_SSL_CACERT' => 'curl/curl_d.stub', 'CURLE_SSL_CACERT_BADFILE' => 'curl/curl_d.stub', 'CURLE_SSL_CERTPROBLEM' => 'curl/curl_d.stub', 'CURLE_SSL_CIPHER' => 'curl/curl_d.stub', 'CURLE_SSL_CONNECT_ERROR' => 'curl/curl_d.stub', 'CURLE_SSL_ENGINE_NOTFOUND' => 'curl/curl_d.stub', 'CURLE_SSL_ENGINE_SETFAILED' => 'curl/curl_d.stub', 'CURLE_SSL_PEER_CERTIFICATE' => 'curl/curl_d.stub', 'CURLE_SSL_PINNEDPUBKEYNOTMATCH' => 'curl/curl_d.stub', 'CURLE_TELNET_OPTION_SYNTAX' => 'curl/curl_d.stub', 'CURLE_TOO_MANY_REDIRECTS' => 'curl/curl_d.stub', 'CURLE_UNKNOWN_TELNET_OPTION' => 'curl/curl_d.stub', 'CURLE_UNSUPPORTED_PROTOCOL' => 'curl/curl_d.stub', 'CURLE_URL_MALFORMAT' => 'curl/curl_d.stub', 'CURLE_URL_MALFORMAT_USER' => 'curl/curl_d.stub', 'CURLE_WEIRD_SERVER_REPLY' => 'curl/curl_d.stub', 'CURLE_WRITE_ERROR' => 'curl/curl_d.stub', 'CURLFTPAUTH_DEFAULT' => 'curl/curl_d.stub', 'CURLFTPAUTH_SSL' => 'curl/curl_d.stub', 'CURLFTPAUTH_TLS' => 'curl/curl_d.stub', 'CURLFTPMETHOD_DEFAULT' => 'curl/curl_d.stub', 'CURLFTPMETHOD_MULTICWD' => 'curl/curl_d.stub', 'CURLFTPMETHOD_NOCWD' => 'curl/curl_d.stub', 'CURLFTPMETHOD_SINGLECWD' => 'curl/curl_d.stub', 'CURLFTPSSL_ALL' => 'curl/curl_d.stub', 'CURLFTPSSL_CCC_ACTIVE' => 'curl/curl_d.stub', 'CURLFTPSSL_CCC_NONE' => 'curl/curl_d.stub', 'CURLFTPSSL_CCC_PASSIVE' => 'curl/curl_d.stub', 'CURLFTPSSL_CONTROL' => 'curl/curl_d.stub', 'CURLFTPSSL_NONE' => 'curl/curl_d.stub', 'CURLFTPSSL_TRY' => 'curl/curl_d.stub', 'CURLFTP_CREATE_DIR' => 'curl/curl_d.stub', 'CURLFTP_CREATE_DIR_NONE' => 'curl/curl_d.stub', 'CURLFTP_CREATE_DIR_RETRY' => 'curl/curl_d.stub', 'CURLGSSAPI_DELEGATION_FLAG' => 'curl/curl_d.stub', 'CURLGSSAPI_DELEGATION_POLICY_FLAG' => 'curl/curl_d.stub', 'CURLHEADER_SEPARATE' => 'curl/curl_d.stub', 'CURLHEADER_UNIFIED' => 'curl/curl_d.stub', 'CURLHSTS_ENABLE' => 'curl/curl_d.stub', 'CURLHSTS_READONLYFILE' => 'curl/curl_d.stub', 'CURLINFO_APPCONNECT_TIME' => 'curl/curl_d.stub', 'CURLINFO_APPCONNECT_TIME_T' => 'curl/curl_d.stub', 'CURLINFO_CAINFO' => 'curl/curl_d.stub', 'CURLINFO_CAPATH' => 'curl/curl_d.stub', 'CURLINFO_CERTINFO' => 'curl/curl_d.stub', 'CURLINFO_CONDITION_UNMET' => 'curl/curl_d.stub', 'CURLINFO_CONNECT_TIME' => 'curl/curl_d.stub', 'CURLINFO_CONNECT_TIME_T' => 'curl/curl_d.stub', 'CURLINFO_CONTENT_LENGTH_DOWNLOAD' => 'curl/curl_d.stub', 'CURLINFO_CONTENT_LENGTH_DOWNLOAD_T' => 'curl/curl_d.stub', 'CURLINFO_CONTENT_LENGTH_UPLOAD' => 'curl/curl_d.stub', 'CURLINFO_CONTENT_LENGTH_UPLOAD_T' => 'curl/curl_d.stub', 'CURLINFO_CONTENT_TYPE' => 'curl/curl_d.stub', 'CURLINFO_COOKIELIST' => 'curl/curl_d.stub', 'CURLINFO_EFFECTIVE_METHOD' => 'curl/curl_d.stub', 'CURLINFO_EFFECTIVE_URL' => 'curl/curl_d.stub', 'CURLINFO_FILETIME' => 'curl/curl_d.stub', 'CURLINFO_FILETIME_T' => 'curl/curl_d.stub', 'CURLINFO_FTP_ENTRY_PATH' => 'curl/curl_d.stub', 'CURLINFO_HEADER_OUT' => 'curl/curl_d.stub', 'CURLINFO_HEADER_SIZE' => 'curl/curl_d.stub', 'CURLINFO_HTTPAUTH_AVAIL' => 'curl/curl_d.stub', 'CURLINFO_HTTP_CODE' => 'curl/curl_d.stub', 'CURLINFO_HTTP_CONNECTCODE' => 'curl/curl_d.stub', 'CURLINFO_HTTP_VERSION' => 'curl/curl_d.stub', 'CURLINFO_LASTONE' => 'curl/curl_d.stub', 'CURLINFO_LOCAL_IP' => 'curl/curl_d.stub', 'CURLINFO_LOCAL_PORT' => 'curl/curl_d.stub', 'CURLINFO_NAMELOOKUP_TIME' => 'curl/curl_d.stub', 'CURLINFO_NAMELOOKUP_TIME_T' => 'curl/curl_d.stub', 'CURLINFO_NUM_CONNECTS' => 'curl/curl_d.stub', 'CURLINFO_OS_ERRNO' => 'curl/curl_d.stub', 'CURLINFO_PRETRANSFER_TIME' => 'curl/curl_d.stub', 'CURLINFO_PRETRANSFER_TIME_T' => 'curl/curl_d.stub', 'CURLINFO_PRIMARY_IP' => 'curl/curl_d.stub', 'CURLINFO_PRIMARY_PORT' => 'curl/curl_d.stub', 'CURLINFO_PRIVATE' => 'curl/curl_d.stub', 'CURLINFO_PROTOCOL' => 'curl/curl_d.stub', 'CURLINFO_PROXYAUTH_AVAIL' => 'curl/curl_d.stub', 'CURLINFO_PROXY_ERROR' => 'curl/curl_d.stub', 'CURLINFO_PROXY_SSL_VERIFYRESULT' => 'curl/curl_d.stub', 'CURLINFO_REDIRECT_COUNT' => 'curl/curl_d.stub', 'CURLINFO_REDIRECT_TIME' => 'curl/curl_d.stub', 'CURLINFO_REDIRECT_TIME_T' => 'curl/curl_d.stub', 'CURLINFO_REDIRECT_URL' => 'curl/curl_d.stub', 'CURLINFO_REFERER' => 'curl/curl_d.stub', 'CURLINFO_REQUEST_SIZE' => 'curl/curl_d.stub', 'CURLINFO_RESPONSE_CODE' => 'curl/curl_d.stub', 'CURLINFO_RETRY_AFTER' => 'curl/curl_d.stub', 'CURLINFO_RTSP_CLIENT_CSEQ' => 'curl/curl_d.stub', 'CURLINFO_RTSP_CSEQ_RECV' => 'curl/curl_d.stub', 'CURLINFO_RTSP_SERVER_CSEQ' => 'curl/curl_d.stub', 'CURLINFO_RTSP_SESSION_ID' => 'curl/curl_d.stub', 'CURLINFO_SCHEME' => 'curl/curl_d.stub', 'CURLINFO_SIZE_DOWNLOAD' => 'curl/curl_d.stub', 'CURLINFO_SIZE_DOWNLOAD_T' => 'curl/curl_d.stub', 'CURLINFO_SIZE_UPLOAD' => 'curl/curl_d.stub', 'CURLINFO_SIZE_UPLOAD_T' => 'curl/curl_d.stub', 'CURLINFO_SPEED_DOWNLOAD' => 'curl/curl_d.stub', 'CURLINFO_SPEED_DOWNLOAD_T' => 'curl/curl_d.stub', 'CURLINFO_SPEED_UPLOAD' => 'curl/curl_d.stub', 'CURLINFO_SPEED_UPLOAD_T' => 'curl/curl_d.stub', 'CURLINFO_SSL_ENGINES' => 'curl/curl_d.stub', 'CURLINFO_SSL_VERIFYRESULT' => 'curl/curl_d.stub', 'CURLINFO_STARTTRANSFER_TIME' => 'curl/curl_d.stub', 'CURLINFO_STARTTRANSFER_TIME_T' => 'curl/curl_d.stub', 'CURLINFO_TOTAL_TIME' => 'curl/curl_d.stub', 'CURLINFO_TOTAL_TIME_T' => 'curl/curl_d.stub', 'CURLKHMATCH_LAST' => 'curl/curl_d.stub', 'CURLKHMATCH_MISMATCH' => 'curl/curl_d.stub', 'CURLKHMATCH_MISSING' => 'curl/curl_d.stub', 'CURLKHMATCH_OK' => 'curl/curl_d.stub', 'CURLMIMEOPT_FORMESCAPE' => 'curl/curl_d.stub', 'CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE' => 'curl/curl_d.stub', 'CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE' => 'curl/curl_d.stub', 'CURLMOPT_MAXCONNECTS' => 'curl/curl_d.stub', 'CURLMOPT_MAX_CONCURRENT_STREAMS' => 'curl/curl_d.stub', 'CURLMOPT_MAX_HOST_CONNECTIONS' => 'curl/curl_d.stub', 'CURLMOPT_MAX_PIPELINE_LENGTH' => 'curl/curl_d.stub', 'CURLMOPT_MAX_TOTAL_CONNECTIONS' => 'curl/curl_d.stub', 'CURLMOPT_PIPELINING' => 'curl/curl_d.stub', 'CURLMOPT_PUSHFUNCTION' => 'curl/curl_d.stub', 'CURLMSG_DONE' => 'curl/curl_d.stub', 'CURLM_ADDED_ALREADY' => 'curl/curl_d.stub', 'CURLM_BAD_EASY_HANDLE' => 'curl/curl_d.stub', 'CURLM_BAD_HANDLE' => 'curl/curl_d.stub', 'CURLM_CALL_MULTI_PERFORM' => 'curl/curl_d.stub', 'CURLM_INTERNAL_ERROR' => 'curl/curl_d.stub', 'CURLM_OK' => 'curl/curl_d.stub', 'CURLM_OUT_OF_MEMORY' => 'curl/curl_d.stub', 'CURLOPT_ABSTRACT_UNIX_SOCKET' => 'curl/curl_d.stub', 'CURLOPT_ACCEPTTIMEOUT_MS' => 'curl/curl_d.stub', 'CURLOPT_ACCEPT_ENCODING' => 'curl/curl_d.stub', 'CURLOPT_ADDRESS_SCOPE' => 'curl/curl_d.stub', 'CURLOPT_ALTSVC' => 'curl/curl_d.stub', 'CURLOPT_ALTSVC_CTRL' => 'curl/curl_d.stub', 'CURLOPT_APPEND' => 'curl/curl_d.stub', 'CURLOPT_AUTOREFERER' => 'curl/curl_d.stub', 'CURLOPT_AWS_SIGV4' => 'curl/curl_d.stub', 'CURLOPT_BINARYTRANSFER' => 'curl/curl_d.stub', 'CURLOPT_BUFFERSIZE' => 'curl/curl_d.stub', 'CURLOPT_CAINFO' => 'curl/curl_d.stub', 'CURLOPT_CAINFO_BLOB' => 'curl/curl_d.stub', 'CURLOPT_CAPATH' => 'curl/curl_d.stub', 'CURLOPT_CA_CACHE_TIMEOUT' => 'curl/curl_d.stub', 'CURLOPT_CERTINFO' => 'curl/curl_d.stub', 'CURLOPT_CLOSEPOLICY' => 'curl/curl_d.stub', 'CURLOPT_CONNECTTIMEOUT' => 'curl/curl_d.stub', 'CURLOPT_CONNECTTIMEOUT_MS' => 'curl/curl_d.stub', 'CURLOPT_CONNECT_ONLY' => 'curl/curl_d.stub', 'CURLOPT_CONNECT_TO' => 'curl/curl_d.stub', 'CURLOPT_COOKIE' => 'curl/curl_d.stub', 'CURLOPT_COOKIEFILE' => 'curl/curl_d.stub', 'CURLOPT_COOKIEJAR' => 'curl/curl_d.stub', 'CURLOPT_COOKIELIST' => 'curl/curl_d.stub', 'CURLOPT_COOKIESESSION' => 'curl/curl_d.stub', 'CURLOPT_CRLF' => 'curl/curl_d.stub', 'CURLOPT_CRLFILE' => 'curl/curl_d.stub', 'CURLOPT_CUSTOMREQUEST' => 'curl/curl_d.stub', 'CURLOPT_DEFAULT_PROTOCOL' => 'curl/curl_d.stub', 'CURLOPT_DIRLISTONLY' => 'curl/curl_d.stub', 'CURLOPT_DISALLOW_USERNAME_IN_URL' => 'curl/curl_d.stub', 'CURLOPT_DNS_CACHE_TIMEOUT' => 'curl/curl_d.stub', 'CURLOPT_DNS_INTERFACE' => 'curl/curl_d.stub', 'CURLOPT_DNS_LOCAL_IP4' => 'curl/curl_d.stub', 'CURLOPT_DNS_LOCAL_IP6' => 'curl/curl_d.stub', 'CURLOPT_DNS_SERVERS' => 'curl/curl_d.stub', 'CURLOPT_DNS_SHUFFLE_ADDRESSES' => 'curl/curl_d.stub', 'CURLOPT_DNS_USE_GLOBAL_CACHE' => 'curl/curl_d.stub', 'CURLOPT_DOH_SSL_VERIFYHOST' => 'curl/curl_d.stub', 'CURLOPT_DOH_SSL_VERIFYPEER' => 'curl/curl_d.stub', 'CURLOPT_DOH_SSL_VERIFYSTATUS' => 'curl/curl_d.stub', 'CURLOPT_DOH_URL' => 'curl/curl_d.stub', 'CURLOPT_EGDSOCKET' => 'curl/curl_d.stub', 'CURLOPT_ENCODING' => 'curl/curl_d.stub', 'CURLOPT_EXPECT_100_TIMEOUT_MS' => 'curl/curl_d.stub', 'CURLOPT_FAILONERROR' => 'curl/curl_d.stub', 'CURLOPT_FILE' => 'curl/curl_d.stub', 'CURLOPT_FILETIME' => 'curl/curl_d.stub', 'CURLOPT_FNMATCH_FUNCTION' => 'curl/curl_d.stub', 'CURLOPT_FOLLOWLOCATION' => 'curl/curl_d.stub', 'CURLOPT_FORBID_REUSE' => 'curl/curl_d.stub', 'CURLOPT_FRESH_CONNECT' => 'curl/curl_d.stub', 'CURLOPT_FTPAPPEND' => 'curl/curl_d.stub', 'CURLOPT_FTPASCII' => 'curl/curl_d.stub', 'CURLOPT_FTPLISTONLY' => 'curl/curl_d.stub', 'CURLOPT_FTPPORT' => 'curl/curl_d.stub', 'CURLOPT_FTPSSLAUTH' => 'curl/curl_d.stub', 'CURLOPT_FTP_ACCOUNT' => 'curl/curl_d.stub', 'CURLOPT_FTP_ALTERNATIVE_TO_USER' => 'curl/curl_d.stub', 'CURLOPT_FTP_CREATE_MISSING_DIRS' => 'curl/curl_d.stub', 'CURLOPT_FTP_FILEMETHOD' => 'curl/curl_d.stub', 'CURLOPT_FTP_RESPONSE_TIMEOUT' => 'curl/curl_d.stub', 'CURLOPT_FTP_SKIP_PASV_IP' => 'curl/curl_d.stub', 'CURLOPT_FTP_SSL' => 'curl/curl_d.stub', 'CURLOPT_FTP_SSL_CCC' => 'curl/curl_d.stub', 'CURLOPT_FTP_USE_EPRT' => 'curl/curl_d.stub', 'CURLOPT_FTP_USE_EPSV' => 'curl/curl_d.stub', 'CURLOPT_FTP_USE_PRET' => 'curl/curl_d.stub', 'CURLOPT_GSSAPI_DELEGATION' => 'curl/curl_d.stub', 'CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS' => 'curl/curl_d.stub', 'CURLOPT_HAPROXYPROTOCOL' => 'curl/curl_d.stub', 'CURLOPT_HEADER' => 'curl/curl_d.stub', 'CURLOPT_HEADERFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_HEADEROPT' => 'curl/curl_d.stub', 'CURLOPT_HSTS' => 'curl/curl_d.stub', 'CURLOPT_HSTS_CTRL' => 'curl/curl_d.stub', 'CURLOPT_HTTP09_ALLOWED' => 'curl/curl_d.stub', 'CURLOPT_HTTP200ALIASES' => 'curl/curl_d.stub', 'CURLOPT_HTTPAUTH' => 'curl/curl_d.stub', 'CURLOPT_HTTPGET' => 'curl/curl_d.stub', 'CURLOPT_HTTPHEADER' => 'curl/curl_d.stub', 'CURLOPT_HTTPPROXYTUNNEL' => 'curl/curl_d.stub', 'CURLOPT_HTTP_CONTENT_DECODING' => 'curl/curl_d.stub', 'CURLOPT_HTTP_TRANSFER_DECODING' => 'curl/curl_d.stub', 'CURLOPT_HTTP_VERSION' => 'curl/curl_d.stub', 'CURLOPT_IGNORE_CONTENT_LENGTH' => 'curl/curl_d.stub', 'CURLOPT_INFILE' => 'curl/curl_d.stub', 'CURLOPT_INFILESIZE' => 'curl/curl_d.stub', 'CURLOPT_INTERFACE' => 'curl/curl_d.stub', 'CURLOPT_IPRESOLVE' => 'curl/curl_d.stub', 'CURLOPT_ISSUERCERT' => 'curl/curl_d.stub', 'CURLOPT_ISSUERCERT_BLOB' => 'curl/curl_d.stub', 'CURLOPT_KEEP_SENDING_ON_ERROR' => 'curl/curl_d.stub', 'CURLOPT_KEYPASSWD' => 'curl/curl_d.stub', 'CURLOPT_KRB4LEVEL' => 'curl/curl_d.stub', 'CURLOPT_KRBLEVEL' => 'curl/curl_d.stub', 'CURLOPT_LOCALPORT' => 'curl/curl_d.stub', 'CURLOPT_LOCALPORTRANGE' => 'curl/curl_d.stub', 'CURLOPT_LOGIN_OPTIONS' => 'curl/curl_d.stub', 'CURLOPT_LOW_SPEED_LIMIT' => 'curl/curl_d.stub', 'CURLOPT_LOW_SPEED_TIME' => 'curl/curl_d.stub', 'CURLOPT_MAIL_AUTH' => 'curl/curl_d.stub', 'CURLOPT_MAIL_FROM' => 'curl/curl_d.stub', 'CURLOPT_MAIL_RCPT' => 'curl/curl_d.stub', 'CURLOPT_MAIL_RCPT_ALLLOWFAILS' => 'curl/curl_d.stub', 'CURLOPT_MAXAGE_CONN' => 'curl/curl_d.stub', 'CURLOPT_MAXCONNECTS' => 'curl/curl_d.stub', 'CURLOPT_MAXFILESIZE' => 'curl/curl_d.stub', 'CURLOPT_MAXFILESIZE_LARGE' => 'curl/curl_d.stub', 'CURLOPT_MAXLIFETIME_CONN' => 'curl/curl_d.stub', 'CURLOPT_MAXREDIRS' => 'curl/curl_d.stub', 'CURLOPT_MAX_RECV_SPEED_LARGE' => 'curl/curl_d.stub', 'CURLOPT_MAX_SEND_SPEED_LARGE' => 'curl/curl_d.stub', 'CURLOPT_MIME_OPTIONS' => 'curl/curl_d.stub', 'CURLOPT_MUTE' => 'curl/curl_d.stub', 'CURLOPT_NETRC' => 'curl/curl_d.stub', 'CURLOPT_NETRC_FILE' => 'curl/curl_d.stub', 'CURLOPT_NEW_DIRECTORY_PERMS' => 'curl/curl_d.stub', 'CURLOPT_NEW_FILE_PERMS' => 'curl/curl_d.stub', 'CURLOPT_NOBODY' => 'curl/curl_d.stub', 'CURLOPT_NOPROGRESS' => 'curl/curl_d.stub', 'CURLOPT_NOPROXY' => 'curl/curl_d.stub', 'CURLOPT_NOSIGNAL' => 'curl/curl_d.stub', 'CURLOPT_PASSWDFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_PASSWORD' => 'curl/curl_d.stub', 'CURLOPT_PATH_AS_IS' => 'curl/curl_d.stub', 'CURLOPT_PINNEDPUBLICKEY' => 'curl/curl_d.stub', 'CURLOPT_PIPEWAIT' => 'curl/curl_d.stub', 'CURLOPT_PORT' => 'curl/curl_d.stub', 'CURLOPT_POST' => 'curl/curl_d.stub', 'CURLOPT_POSTFIELDS' => 'curl/curl_d.stub', 'CURLOPT_POSTQUOTE' => 'curl/curl_d.stub', 'CURLOPT_POSTREDIR' => 'curl/curl_d.stub', 'CURLOPT_PREQUOTE' => 'curl/curl_d.stub', 'CURLOPT_PREREQFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_PRE_PROXY' => 'curl/curl_d.stub', 'CURLOPT_PRIVATE' => 'curl/curl_d.stub', 'CURLOPT_PROGRESSFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_PROTOCOLS' => 'curl/curl_d.stub', 'CURLOPT_PROTOCOLS_STR' => 'curl/curl_d.stub', 'CURLOPT_PROXY' => 'curl/curl_d.stub', 'CURLOPT_PROXYAUTH' => 'curl/curl_d.stub', 'CURLOPT_PROXYHEADER' => 'curl/curl_d.stub', 'CURLOPT_PROXYPASSWORD' => 'curl/curl_d.stub', 'CURLOPT_PROXYPORT' => 'curl/curl_d.stub', 'CURLOPT_PROXYTYPE' => 'curl/curl_d.stub', 'CURLOPT_PROXYUSERNAME' => 'curl/curl_d.stub', 'CURLOPT_PROXYUSERPWD' => 'curl/curl_d.stub', 'CURLOPT_PROXY_CAINFO' => 'curl/curl_d.stub', 'CURLOPT_PROXY_CAINFO_BLOB' => 'curl/curl_d.stub', 'CURLOPT_PROXY_CAPATH' => 'curl/curl_d.stub', 'CURLOPT_PROXY_CRLFILE' => 'curl/curl_d.stub', 'CURLOPT_PROXY_ISSUERCERT' => 'curl/curl_d.stub', 'CURLOPT_PROXY_ISSUERCERT_BLOB' => 'curl/curl_d.stub', 'CURLOPT_PROXY_KEYPASSWD' => 'curl/curl_d.stub', 'CURLOPT_PROXY_PINNEDPUBLICKEY' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SERVICE_NAME' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSLCERT' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSLCERTTYPE' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSLCERT_BLOB' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSLKEY' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSLKEYTYPE' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSLKEY_BLOB' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSLVERSION' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSL_CIPHER_LIST' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSL_OPTIONS' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSL_VERIFYHOST' => 'curl/curl_d.stub', 'CURLOPT_PROXY_SSL_VERIFYPEER' => 'curl/curl_d.stub', 'CURLOPT_PROXY_TLS13_CIPHERS' => 'curl/curl_d.stub', 'CURLOPT_PROXY_TLSAUTH_PASSWORD' => 'curl/curl_d.stub', 'CURLOPT_PROXY_TLSAUTH_TYPE' => 'curl/curl_d.stub', 'CURLOPT_PROXY_TLSAUTH_USERNAME' => 'curl/curl_d.stub', 'CURLOPT_PROXY_TRANSFER_MODE' => 'curl/curl_d.stub', 'CURLOPT_PUT' => 'curl/curl_d.stub', 'CURLOPT_QUICK_EXIT' => 'curl/curl_d.stub', 'CURLOPT_QUOTE' => 'curl/curl_d.stub', 'CURLOPT_RANDOM_FILE' => 'curl/curl_d.stub', 'CURLOPT_RANGE' => 'curl/curl_d.stub', 'CURLOPT_READDATA' => 'curl/curl_d.stub', 'CURLOPT_READFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_REDIR_PROTOCOLS' => 'curl/curl_d.stub', 'CURLOPT_REDIR_PROTOCOLS_STR' => 'curl/curl_d.stub', 'CURLOPT_REFERER' => 'curl/curl_d.stub', 'CURLOPT_REQUEST_TARGET' => 'curl/curl_d.stub', 'CURLOPT_RESOLVE' => 'curl/curl_d.stub', 'CURLOPT_RESUME_FROM' => 'curl/curl_d.stub', 'CURLOPT_RETURNTRANSFER' => 'curl/curl_d.stub', 'CURLOPT_RTSP_CLIENT_CSEQ' => 'curl/curl_d.stub', 'CURLOPT_RTSP_REQUEST' => 'curl/curl_d.stub', 'CURLOPT_RTSP_SERVER_CSEQ' => 'curl/curl_d.stub', 'CURLOPT_RTSP_SESSION_ID' => 'curl/curl_d.stub', 'CURLOPT_RTSP_STREAM_URI' => 'curl/curl_d.stub', 'CURLOPT_RTSP_TRANSPORT' => 'curl/curl_d.stub', 'CURLOPT_SAFE_UPLOAD' => 'curl/curl_d.stub', 'CURLOPT_SASL_AUTHZID' => 'curl/curl_d.stub', 'CURLOPT_SASL_IR' => 'curl/curl_d.stub', 'CURLOPT_SERVICE_NAME' => 'curl/curl_d.stub', 'CURLOPT_SHARE' => 'curl/curl_d.stub', 'CURLOPT_SOCKS5_AUTH' => 'curl/curl_d.stub', 'CURLOPT_SOCKS5_GSSAPI_NEC' => 'curl/curl_d.stub', 'CURLOPT_SOCKS5_GSSAPI_SERVICE' => 'curl/curl_d.stub', 'CURLOPT_SSH_AUTH_TYPES' => 'curl/curl_d.stub', 'CURLOPT_SSH_COMPRESSION' => 'curl/curl_d.stub', 'CURLOPT_SSH_HOSTKEYFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_SSH_HOST_PUBLIC_KEY_MD5' => 'curl/curl_d.stub', 'CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256' => 'curl/curl_d.stub', 'CURLOPT_SSH_KNOWNHOSTS' => 'curl/curl_d.stub', 'CURLOPT_SSH_PRIVATE_KEYFILE' => 'curl/curl_d.stub', 'CURLOPT_SSH_PUBLIC_KEYFILE' => 'curl/curl_d.stub', 'CURLOPT_SSLCERT' => 'curl/curl_d.stub', 'CURLOPT_SSLCERTPASSWD' => 'curl/curl_d.stub', 'CURLOPT_SSLCERTTYPE' => 'curl/curl_d.stub', 'CURLOPT_SSLCERT_BLOB' => 'curl/curl_d.stub', 'CURLOPT_SSLENGINE' => 'curl/curl_d.stub', 'CURLOPT_SSLENGINE_DEFAULT' => 'curl/curl_d.stub', 'CURLOPT_SSLKEY' => 'curl/curl_d.stub', 'CURLOPT_SSLKEYPASSWD' => 'curl/curl_d.stub', 'CURLOPT_SSLKEYTYPE' => 'curl/curl_d.stub', 'CURLOPT_SSLKEY_BLOB' => 'curl/curl_d.stub', 'CURLOPT_SSLVERSION' => 'curl/curl_d.stub', 'CURLOPT_SSL_CIPHER_LIST' => 'curl/curl_d.stub', 'CURLOPT_SSL_EC_CURVES' => 'curl/curl_d.stub', 'CURLOPT_SSL_ENABLE_ALPN' => 'curl/curl_d.stub', 'CURLOPT_SSL_ENABLE_NPN' => 'curl/curl_d.stub', 'CURLOPT_SSL_FALSESTART' => 'curl/curl_d.stub', 'CURLOPT_SSL_OPTIONS' => 'curl/curl_d.stub', 'CURLOPT_SSL_SESSIONID_CACHE' => 'curl/curl_d.stub', 'CURLOPT_SSL_VERIFYHOST' => 'curl/curl_d.stub', 'CURLOPT_SSL_VERIFYPEER' => 'curl/curl_d.stub', 'CURLOPT_SSL_VERIFYSTATUS' => 'curl/curl_d.stub', 'CURLOPT_STDERR' => 'curl/curl_d.stub', 'CURLOPT_STREAM_WEIGHT' => 'curl/curl_d.stub', 'CURLOPT_SUPPRESS_CONNECT_HEADERS' => 'curl/curl_d.stub', 'CURLOPT_TCP_FASTOPEN' => 'curl/curl_d.stub', 'CURLOPT_TCP_KEEPALIVE' => 'curl/curl_d.stub', 'CURLOPT_TCP_KEEPCNT' => 'curl/curl_d.stub', 'CURLOPT_TCP_KEEPIDLE' => 'curl/curl_d.stub', 'CURLOPT_TCP_KEEPINTVL' => 'curl/curl_d.stub', 'CURLOPT_TCP_NODELAY' => 'curl/curl_d.stub', 'CURLOPT_TELNETOPTIONS' => 'curl/curl_d.stub', 'CURLOPT_TFTP_BLKSIZE' => 'curl/curl_d.stub', 'CURLOPT_TFTP_NO_OPTIONS' => 'curl/curl_d.stub', 'CURLOPT_TIMECONDITION' => 'curl/curl_d.stub', 'CURLOPT_TIMEOUT' => 'curl/curl_d.stub', 'CURLOPT_TIMEOUT_MS' => 'curl/curl_d.stub', 'CURLOPT_TIMEVALUE' => 'curl/curl_d.stub', 'CURLOPT_TIMEVALUE_LARGE' => 'curl/curl_d.stub', 'CURLOPT_TLS13_CIPHERS' => 'curl/curl_d.stub', 'CURLOPT_TLSAUTH_PASSWORD' => 'curl/curl_d.stub', 'CURLOPT_TLSAUTH_TYPE' => 'curl/curl_d.stub', 'CURLOPT_TLSAUTH_USERNAME' => 'curl/curl_d.stub', 'CURLOPT_TRANSFERTEXT' => 'curl/curl_d.stub', 'CURLOPT_TRANSFER_ENCODING' => 'curl/curl_d.stub', 'CURLOPT_UNIX_SOCKET_PATH' => 'curl/curl_d.stub', 'CURLOPT_UNRESTRICTED_AUTH' => 'curl/curl_d.stub', 'CURLOPT_UPKEEP_INTERVAL_MS' => 'curl/curl_d.stub', 'CURLOPT_UPLOAD' => 'curl/curl_d.stub', 'CURLOPT_UPLOAD_BUFFERSIZE' => 'curl/curl_d.stub', 'CURLOPT_URL' => 'curl/curl_d.stub', 'CURLOPT_USERAGENT' => 'curl/curl_d.stub', 'CURLOPT_USERNAME' => 'curl/curl_d.stub', 'CURLOPT_USERPWD' => 'curl/curl_d.stub', 'CURLOPT_USE_SSL' => 'curl/curl_d.stub', 'CURLOPT_VERBOSE' => 'curl/curl_d.stub', 'CURLOPT_WILDCARDMATCH' => 'curl/curl_d.stub', 'CURLOPT_WRITEFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_WRITEHEADER' => 'curl/curl_d.stub', 'CURLOPT_WS_OPTIONS' => 'curl/curl_d.stub', 'CURLOPT_XFERINFOFUNCTION' => 'curl/curl_d.stub', 'CURLOPT_XOAUTH2_BEARER' => 'curl/curl_d.stub', 'CURLPAUSE_ALL' => 'curl/curl_d.stub', 'CURLPAUSE_CONT' => 'curl/curl_d.stub', 'CURLPAUSE_RECV' => 'curl/curl_d.stub', 'CURLPAUSE_RECV_CONT' => 'curl/curl_d.stub', 'CURLPAUSE_SEND' => 'curl/curl_d.stub', 'CURLPAUSE_SEND_CONT' => 'curl/curl_d.stub', 'CURLPIPE_HTTP1' => 'curl/curl_d.stub', 'CURLPIPE_MULTIPLEX' => 'curl/curl_d.stub', 'CURLPIPE_NOTHING' => 'curl/curl_d.stub', 'CURLPROTO_ALL' => 'curl/curl_d.stub', 'CURLPROTO_DICT' => 'curl/curl_d.stub', 'CURLPROTO_FILE' => 'curl/curl_d.stub', 'CURLPROTO_FTP' => 'curl/curl_d.stub', 'CURLPROTO_FTPS' => 'curl/curl_d.stub', 'CURLPROTO_GOPHER' => 'curl/curl_d.stub', 'CURLPROTO_HTTP' => 'curl/curl_d.stub', 'CURLPROTO_HTTPS' => 'curl/curl_d.stub', 'CURLPROTO_IMAP' => 'curl/curl_d.stub', 'CURLPROTO_IMAPS' => 'curl/curl_d.stub', 'CURLPROTO_LDAP' => 'curl/curl_d.stub', 'CURLPROTO_LDAPS' => 'curl/curl_d.stub', 'CURLPROTO_MQTT' => 'curl/curl_d.stub', 'CURLPROTO_POP3' => 'curl/curl_d.stub', 'CURLPROTO_POP3S' => 'curl/curl_d.stub', 'CURLPROTO_RTMP' => 'curl/curl_d.stub', 'CURLPROTO_RTMPE' => 'curl/curl_d.stub', 'CURLPROTO_RTMPS' => 'curl/curl_d.stub', 'CURLPROTO_RTMPT' => 'curl/curl_d.stub', 'CURLPROTO_RTMPTE' => 'curl/curl_d.stub', 'CURLPROTO_RTMPTS' => 'curl/curl_d.stub', 'CURLPROTO_RTSP' => 'curl/curl_d.stub', 'CURLPROTO_SCP' => 'curl/curl_d.stub', 'CURLPROTO_SFTP' => 'curl/curl_d.stub', 'CURLPROTO_SMB' => 'curl/curl_d.stub', 'CURLPROTO_SMBS' => 'curl/curl_d.stub', 'CURLPROTO_SMTP' => 'curl/curl_d.stub', 'CURLPROTO_SMTPS' => 'curl/curl_d.stub', 'CURLPROTO_TELNET' => 'curl/curl_d.stub', 'CURLPROTO_TFTP' => 'curl/curl_d.stub', 'CURLPROXY_HTTP' => 'curl/curl_d.stub', 'CURLPROXY_HTTPS' => 'curl/curl_d.stub', 'CURLPROXY_HTTP_1_0' => 'curl/curl_d.stub', 'CURLPROXY_SOCKS4' => 'curl/curl_d.stub', 'CURLPROXY_SOCKS4A' => 'curl/curl_d.stub', 'CURLPROXY_SOCKS5' => 'curl/curl_d.stub', 'CURLPROXY_SOCKS5_HOSTNAME' => 'curl/curl_d.stub', 'CURLPX_BAD_ADDRESS_TYPE' => 'curl/curl_d.stub', 'CURLPX_BAD_VERSION' => 'curl/curl_d.stub', 'CURLPX_CLOSED' => 'curl/curl_d.stub', 'CURLPX_GSSAPI' => 'curl/curl_d.stub', 'CURLPX_GSSAPI_PERMSG' => 'curl/curl_d.stub', 'CURLPX_GSSAPI_PROTECTION' => 'curl/curl_d.stub', 'CURLPX_IDENTD' => 'curl/curl_d.stub', 'CURLPX_IDENTD_DIFFER' => 'curl/curl_d.stub', 'CURLPX_LONG_HOSTNAME' => 'curl/curl_d.stub', 'CURLPX_LONG_PASSWD' => 'curl/curl_d.stub', 'CURLPX_LONG_USER' => 'curl/curl_d.stub', 'CURLPX_NO_AUTH' => 'curl/curl_d.stub', 'CURLPX_OK' => 'curl/curl_d.stub', 'CURLPX_RECV_ADDRESS' => 'curl/curl_d.stub', 'CURLPX_RECV_AUTH' => 'curl/curl_d.stub', 'CURLPX_RECV_CONNECT' => 'curl/curl_d.stub', 'CURLPX_RECV_REQACK' => 'curl/curl_d.stub', 'CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED' => 'curl/curl_d.stub', 'CURLPX_REPLY_COMMAND_NOT_SUPPORTED' => 'curl/curl_d.stub', 'CURLPX_REPLY_CONNECTION_REFUSED' => 'curl/curl_d.stub', 'CURLPX_REPLY_GENERAL_SERVER_FAILURE' => 'curl/curl_d.stub', 'CURLPX_REPLY_HOST_UNREACHABLE' => 'curl/curl_d.stub', 'CURLPX_REPLY_NETWORK_UNREACHABLE' => 'curl/curl_d.stub', 'CURLPX_REPLY_NOT_ALLOWED' => 'curl/curl_d.stub', 'CURLPX_REPLY_TTL_EXPIRED' => 'curl/curl_d.stub', 'CURLPX_REPLY_UNASSIGNED' => 'curl/curl_d.stub', 'CURLPX_REQUEST_FAILED' => 'curl/curl_d.stub', 'CURLPX_RESOLVE_HOST' => 'curl/curl_d.stub', 'CURLPX_SEND_AUTH' => 'curl/curl_d.stub', 'CURLPX_SEND_CONNECT' => 'curl/curl_d.stub', 'CURLPX_SEND_REQUEST' => 'curl/curl_d.stub', 'CURLPX_UNKNOWN_FAIL' => 'curl/curl_d.stub', 'CURLPX_UNKNOWN_MODE' => 'curl/curl_d.stub', 'CURLPX_USER_REJECTED' => 'curl/curl_d.stub', 'CURLSHOPT_NONE' => 'curl/curl_d.stub', 'CURLSHOPT_SHARE' => 'curl/curl_d.stub', 'CURLSHOPT_UNSHARE' => 'curl/curl_d.stub', 'CURLSSH_AUTH_AGENT' => 'curl/curl_d.stub', 'CURLSSH_AUTH_ANY' => 'curl/curl_d.stub', 'CURLSSH_AUTH_DEFAULT' => 'curl/curl_d.stub', 'CURLSSH_AUTH_GSSAPI' => 'curl/curl_d.stub', 'CURLSSH_AUTH_HOST' => 'curl/curl_d.stub', 'CURLSSH_AUTH_KEYBOARD' => 'curl/curl_d.stub', 'CURLSSH_AUTH_NONE' => 'curl/curl_d.stub', 'CURLSSH_AUTH_PASSWORD' => 'curl/curl_d.stub', 'CURLSSH_AUTH_PUBLICKEY' => 'curl/curl_d.stub', 'CURLSSLOPT_ALLOW_BEAST' => 'curl/curl_d.stub', 'CURLSSLOPT_AUTO_CLIENT_CERT' => 'curl/curl_d.stub', 'CURLSSLOPT_NATIVE_CA' => 'curl/curl_d.stub', 'CURLSSLOPT_NO_PARTIALCHAIN' => 'curl/curl_d.stub', 'CURLSSLOPT_NO_REVOKE' => 'curl/curl_d.stub', 'CURLSSLOPT_REVOKE_BEST_EFFORT' => 'curl/curl_d.stub', 'CURLUSESSL_ALL' => 'curl/curl_d.stub', 'CURLUSESSL_CONTROL' => 'curl/curl_d.stub', 'CURLUSESSL_NONE' => 'curl/curl_d.stub', 'CURLUSESSL_TRY' => 'curl/curl_d.stub', 'CURLVERSION_NOW' => 'curl/curl_d.stub', 'CURLWS_RAW_MODE' => 'curl/curl_d.stub', 'CURL_FNMATCHFUNC_FAIL' => 'curl/curl_d.stub', 'CURL_FNMATCHFUNC_MATCH' => 'curl/curl_d.stub', 'CURL_FNMATCHFUNC_NOMATCH' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_1_0' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_1_1' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_2' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_2TLS' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_2_0' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_3' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_3ONLY' => 'curl/curl_d.stub', 'CURL_HTTP_VERSION_NONE' => 'curl/curl_d.stub', 'CURL_IPRESOLVE_V4' => 'curl/curl_d.stub', 'CURL_IPRESOLVE_V6' => 'curl/curl_d.stub', 'CURL_IPRESOLVE_WHATEVER' => 'curl/curl_d.stub', 'CURL_LOCK_DATA_CONNECT' => 'curl/curl_d.stub', 'CURL_LOCK_DATA_COOKIE' => 'curl/curl_d.stub', 'CURL_LOCK_DATA_DNS' => 'curl/curl_d.stub', 'CURL_LOCK_DATA_PSL' => 'curl/curl_d.stub', 'CURL_LOCK_DATA_SSL_SESSION' => 'curl/curl_d.stub', 'CURL_MAX_READ_SIZE' => 'curl/curl_d.stub', 'CURL_NETRC_IGNORED' => 'curl/curl_d.stub', 'CURL_NETRC_OPTIONAL' => 'curl/curl_d.stub', 'CURL_NETRC_REQUIRED' => 'curl/curl_d.stub', 'CURL_PREREQFUNC_ABORT' => 'curl/curl_d.stub', 'CURL_PREREQFUNC_OK' => 'curl/curl_d.stub', 'CURL_PUSH_DENY' => 'curl/curl_d.stub', 'CURL_PUSH_OK' => 'curl/curl_d.stub', 'CURL_READFUNC_PAUSE' => 'curl/curl_d.stub', 'CURL_REDIR_POST_301' => 'curl/curl_d.stub', 'CURL_REDIR_POST_302' => 'curl/curl_d.stub', 'CURL_REDIR_POST_303' => 'curl/curl_d.stub', 'CURL_REDIR_POST_ALL' => 'curl/curl_d.stub', 'CURL_RTSPREQ_ANNOUNCE' => 'curl/curl_d.stub', 'CURL_RTSPREQ_DESCRIBE' => 'curl/curl_d.stub', 'CURL_RTSPREQ_GET_PARAMETER' => 'curl/curl_d.stub', 'CURL_RTSPREQ_OPTIONS' => 'curl/curl_d.stub', 'CURL_RTSPREQ_PAUSE' => 'curl/curl_d.stub', 'CURL_RTSPREQ_PLAY' => 'curl/curl_d.stub', 'CURL_RTSPREQ_RECEIVE' => 'curl/curl_d.stub', 'CURL_RTSPREQ_RECORD' => 'curl/curl_d.stub', 'CURL_RTSPREQ_SETUP' => 'curl/curl_d.stub', 'CURL_RTSPREQ_SET_PARAMETER' => 'curl/curl_d.stub', 'CURL_RTSPREQ_TEARDOWN' => 'curl/curl_d.stub', 'CURL_SSLVERSION_DEFAULT' => 'curl/curl_d.stub', 'CURL_SSLVERSION_MAX_DEFAULT' => 'curl/curl_d.stub', 'CURL_SSLVERSION_MAX_NONE' => 'curl/curl_d.stub', 'CURL_SSLVERSION_MAX_TLSv1_0' => 'curl/curl_d.stub', 'CURL_SSLVERSION_MAX_TLSv1_1' => 'curl/curl_d.stub', 'CURL_SSLVERSION_MAX_TLSv1_2' => 'curl/curl_d.stub', 'CURL_SSLVERSION_MAX_TLSv1_3' => 'curl/curl_d.stub', 'CURL_SSLVERSION_SSLv2' => 'curl/curl_d.stub', 'CURL_SSLVERSION_SSLv3' => 'curl/curl_d.stub', 'CURL_SSLVERSION_TLSv1' => 'curl/curl_d.stub', 'CURL_SSLVERSION_TLSv1_0' => 'curl/curl_d.stub', 'CURL_SSLVERSION_TLSv1_1' => 'curl/curl_d.stub', 'CURL_SSLVERSION_TLSv1_2' => 'curl/curl_d.stub', 'CURL_SSLVERSION_TLSv1_3' => 'curl/curl_d.stub', 'CURL_TIMECOND_IFMODSINCE' => 'curl/curl_d.stub', 'CURL_TIMECOND_IFUNMODSINCE' => 'curl/curl_d.stub', 'CURL_TIMECOND_LASTMOD' => 'curl/curl_d.stub', 'CURL_TIMECOND_NONE' => 'curl/curl_d.stub', 'CURL_TLSAUTH_SRP' => 'curl/curl_d.stub', 'CURL_VERSION_ALTSVC' => 'curl/curl_d.stub', 'CURL_VERSION_ASYNCHDNS' => 'curl/curl_d.stub', 'CURL_VERSION_BROTLI' => 'curl/curl_d.stub', 'CURL_VERSION_CONV' => 'curl/curl_d.stub', 'CURL_VERSION_CURLDEBUG' => 'curl/curl_d.stub', 'CURL_VERSION_DEBUG' => 'curl/curl_d.stub', 'CURL_VERSION_GSASL' => 'curl/curl_d.stub', 'CURL_VERSION_GSSAPI' => 'curl/curl_d.stub', 'CURL_VERSION_GSSNEGOTIATE' => 'curl/curl_d.stub', 'CURL_VERSION_HSTS' => 'curl/curl_d.stub', 'CURL_VERSION_HTTP2' => 'curl/curl_d.stub', 'CURL_VERSION_HTTP3' => 'curl/curl_d.stub', 'CURL_VERSION_HTTPS_PROXY' => 'curl/curl_d.stub', 'CURL_VERSION_IDN' => 'curl/curl_d.stub', 'CURL_VERSION_IPV6' => 'curl/curl_d.stub', 'CURL_VERSION_KERBEROS4' => 'curl/curl_d.stub', 'CURL_VERSION_KERBEROS5' => 'curl/curl_d.stub', 'CURL_VERSION_LARGEFILE' => 'curl/curl_d.stub', 'CURL_VERSION_LIBZ' => 'curl/curl_d.stub', 'CURL_VERSION_MULTI_SSL' => 'curl/curl_d.stub', 'CURL_VERSION_NTLM' => 'curl/curl_d.stub', 'CURL_VERSION_NTLM_WB' => 'curl/curl_d.stub', 'CURL_VERSION_PSL' => 'curl/curl_d.stub', 'CURL_VERSION_SPNEGO' => 'curl/curl_d.stub', 'CURL_VERSION_SSL' => 'curl/curl_d.stub', 'CURL_VERSION_SSPI' => 'curl/curl_d.stub', 'CURL_VERSION_TLSAUTH_SRP' => 'curl/curl_d.stub', 'CURL_VERSION_UNICODE' => 'curl/curl_d.stub', 'CURL_VERSION_UNIX_SOCKETS' => 'curl/curl_d.stub', 'CURL_VERSION_ZSTD' => 'curl/curl_d.stub', 'CURL_WRITEFUNC_PAUSE' => 'curl/curl_d.stub', 'CURRENCY_SYMBOL' => 'standard/standard_defines.stub', 'CYAN' => 'winbinder/winbinder.stub', 'Calendar' => 'winbinder/winbinder.stub', 'CheckBox' => 'winbinder/winbinder.stub', 'ComboBox' => 'winbinder/winbinder.stub', 'DARKBLUE' => 'winbinder/winbinder.stub', 'DARKCYAN' => 'winbinder/winbinder.stub', 'DARKGRAY' => 'winbinder/winbinder.stub', 'DARKGREEN' => 'winbinder/winbinder.stub', 'DARKMAGENTA' => 'winbinder/winbinder.stub', 'DARKRED' => 'winbinder/winbinder.stub', 'DARKYELLOW' => 'winbinder/winbinder.stub', 'DATE_ATOM' => 'date/date_d.stub', 'DATE_COOKIE' => 'date/date_d.stub', 'DATE_ISO8601' => 'date/date_d.stub', 'DATE_ISO8601_EXPANDED' => 'date/date_d.stub', 'DATE_RFC1036' => 'date/date_d.stub', 'DATE_RFC1123' => 'date/date_d.stub', 'DATE_RFC2822' => 'date/date_d.stub', 'DATE_RFC3339' => 'date/date_d.stub', 'DATE_RFC3339_EXTENDED' => 'date/date_d.stub', 'DATE_RFC7231' => 'date/date_d.stub', 'DATE_RFC822' => 'date/date_d.stub', 'DATE_RFC850' => 'date/date_d.stub', 'DATE_RSS' => 'date/date_d.stub', 'DATE_W3C' => 'date/date_d.stub', 'DAY_1' => 'standard/standard_defines.stub', 'DAY_2' => 'standard/standard_defines.stub', 'DAY_3' => 'standard/standard_defines.stub', 'DAY_4' => 'standard/standard_defines.stub', 'DAY_5' => 'standard/standard_defines.stub', 'DAY_6' => 'standard/standard_defines.stub', 'DAY_7' => 'standard/standard_defines.stub', 'DB2_AUTOCOMMIT_OFF' => 'ibm_db2/ibm_db2.stub', 'DB2_AUTOCOMMIT_ON' => 'ibm_db2/ibm_db2.stub', 'DB2_BINARY' => 'ibm_db2/ibm_db2.stub', 'DB2_CASE_LOWER' => 'ibm_db2/ibm_db2.stub', 'DB2_CASE_NATURAL' => 'ibm_db2/ibm_db2.stub', 'DB2_CASE_UPPER' => 'ibm_db2/ibm_db2.stub', 'DB2_CHAR' => 'ibm_db2/ibm_db2.stub', 'DB2_CONVERT' => 'ibm_db2/ibm_db2.stub', 'DB2_DEFERRED_PREPARE_OFF' => 'ibm_db2/ibm_db2.stub', 'DB2_DEFERRED_PREPARE_ON' => 'ibm_db2/ibm_db2.stub', 'DB2_DOUBLE' => 'ibm_db2/ibm_db2.stub', 'DB2_FORWARD_ONLY' => 'ibm_db2/ibm_db2.stub', 'DB2_LONG' => 'ibm_db2/ibm_db2.stub', 'DB2_PARAM_FILE' => 'ibm_db2/ibm_db2.stub', 'DB2_PARAM_IN' => 'ibm_db2/ibm_db2.stub', 'DB2_PARAM_INOUT' => 'ibm_db2/ibm_db2.stub', 'DB2_PARAM_OUT' => 'ibm_db2/ibm_db2.stub', 'DB2_PASSTHRU' => 'ibm_db2/ibm_db2.stub', 'DB2_SCROLLABLE' => 'ibm_db2/ibm_db2.stub', 'DB2_XML' => 'ibm_db2/ibm_db2.stub', 'DBA_LMDB_NO_SUB_DIR' => 'dba/dba.stub', 'DBA_LMDB_USE_SUB_DIR' => 'dba/dba.stub', 'DEBUG_BACKTRACE_IGNORE_ARGS' => 'Core/Core_d.stub', 'DEBUG_BACKTRACE_PROVIDE_OBJECT' => 'Core/Core_d.stub', 'DECIMAL_POINT' => 'standard/standard_defines.stub', 'DEFAULT_INCLUDE_PATH' => 'Core/Core_d.stub', 'DIRECTORY_SEPARATOR' => 'standard/standard_defines.stub', 'DISP_E_DIVBYZERO' => 'com_dotnet/com_dotnet.stub', 'DISP_E_OVERFLOW' => 'com_dotnet/com_dotnet.stub', 'DNS_A' => 'standard/standard_defines.stub', 'DNS_A6' => 'standard/standard_defines.stub', 'DNS_AAAA' => 'standard/standard_defines.stub', 'DNS_ALL' => 'standard/standard_defines.stub', 'DNS_ANY' => 'standard/standard_defines.stub', 'DNS_CAA' => 'standard/standard_defines.stub', 'DNS_CNAME' => 'standard/standard_defines.stub', 'DNS_HINFO' => 'standard/standard_defines.stub', 'DNS_MX' => 'standard/standard_defines.stub', 'DNS_NAPTR' => 'standard/standard_defines.stub', 'DNS_NS' => 'standard/standard_defines.stub', 'DNS_PTR' => 'standard/standard_defines.stub', 'DNS_SOA' => 'standard/standard_defines.stub', 'DNS_SRV' => 'standard/standard_defines.stub', 'DNS_TXT' => 'standard/standard_defines.stub', 'DOMSTRING_SIZE_ERR' => 'dom/dom.stub', 'DOM_HIERARCHY_REQUEST_ERR' => 'dom/dom.stub', 'DOM_INDEX_SIZE_ERR' => 'dom/dom.stub', 'DOM_INUSE_ATTRIBUTE_ERR' => 'dom/dom.stub', 'DOM_INVALID_ACCESS_ERR' => 'dom/dom.stub', 'DOM_INVALID_CHARACTER_ERR' => 'dom/dom.stub', 'DOM_INVALID_MODIFICATION_ERR' => 'dom/dom.stub', 'DOM_INVALID_STATE_ERR' => 'dom/dom.stub', 'DOM_NAMESPACE_ERR' => 'dom/dom.stub', 'DOM_NOT_FOUND_ERR' => 'dom/dom.stub', 'DOM_NOT_SUPPORTED_ERR' => 'dom/dom.stub', 'DOM_NO_DATA_ALLOWED_ERR' => 'dom/dom.stub', 'DOM_NO_MODIFICATION_ALLOWED_ERR' => 'dom/dom.stub', 'DOM_PHP_ERR' => 'dom/dom.stub', 'DOM_SYNTAX_ERR' => 'dom/dom.stub', 'DOM_VALIDATION_ERR' => 'dom/dom.stub', 'DOM_WRONG_DOCUMENT_ERR' => 'dom/dom.stub', 'D_FMT' => 'standard/standard_defines.stub', 'D_T_FMT' => 'standard/standard_defines.stub', 'Dom\\HIERARCHY_REQUEST_ERR' => 'dom/dom_n.stub', 'Dom\\HTML_NO_DEFAULT_NS' => 'dom/dom_n.stub', 'Dom\\INDEX_SIZE_ERR' => 'dom/dom_n.stub', 'Dom\\INUSE_ATTRIBUTE_ERR' => 'dom/dom_n.stub', 'Dom\\INVALID_CHARACTER_ERR' => 'dom/dom_n.stub', 'Dom\\INVALID_MODIFICATION_ERR' => 'dom/dom_n.stub', 'Dom\\INVALID_STATE_ERR' => 'dom/dom_n.stub', 'Dom\\NAMESPACE_ERR' => 'dom/dom_n.stub', 'Dom\\NOT_FOUND_ERR' => 'dom/dom_n.stub', 'Dom\\NOT_SUPPORTED_ERR' => 'dom/dom_n.stub', 'Dom\\NO_DATA_ALLOWED_ERR' => 'dom/dom_n.stub', 'Dom\\NO_MODIFICATION_ALLOWED_ERR' => 'dom/dom_n.stub', 'Dom\\STRING_SIZE_ERR' => 'dom/dom_n.stub', 'Dom\\SYNTAX_ERR' => 'dom/dom_n.stub', 'Dom\\VALIDATION_ERR' => 'dom/dom_n.stub', 'Dom\\WRONG_DOCUMENT_ERR' => 'dom/dom_n.stub', 'EIO_DEBUG' => 'eio/eio.stub', 'EIO_DT_BLK' => 'eio/eio.stub', 'EIO_DT_CHR' => 'eio/eio.stub', 'EIO_DT_CMP' => 'eio/eio.stub', 'EIO_DT_DIR' => 'eio/eio.stub', 'EIO_DT_DOOR' => 'eio/eio.stub', 'EIO_DT_FIFO' => 'eio/eio.stub', 'EIO_DT_LNK' => 'eio/eio.stub', 'EIO_DT_MAX' => 'eio/eio.stub', 'EIO_DT_MPB' => 'eio/eio.stub', 'EIO_DT_MPC' => 'eio/eio.stub', 'EIO_DT_NAM' => 'eio/eio.stub', 'EIO_DT_NWK' => 'eio/eio.stub', 'EIO_DT_REG' => 'eio/eio.stub', 'EIO_DT_SOCK' => 'eio/eio.stub', 'EIO_DT_UNKNOWN' => 'eio/eio.stub', 'EIO_DT_WHT' => 'eio/eio.stub', 'EIO_FALLOC_FL_KEEP_SIZE' => 'eio/eio.stub', 'EIO_O_APPEND' => 'eio/eio.stub', 'EIO_O_CREAT' => 'eio/eio.stub', 'EIO_O_EXCL' => 'eio/eio.stub', 'EIO_O_FSYNC' => 'eio/eio.stub', 'EIO_O_NONBLOCK' => 'eio/eio.stub', 'EIO_O_RDONLY' => 'eio/eio.stub', 'EIO_O_RDWR' => 'eio/eio.stub', 'EIO_O_TRUNC' => 'eio/eio.stub', 'EIO_O_WRONLY' => 'eio/eio.stub', 'EIO_PRI_DEFAULT' => 'eio/eio.stub', 'EIO_PRI_MAX' => 'eio/eio.stub', 'EIO_PRI_MIN' => 'eio/eio.stub', 'EIO_READDIR_DENTS' => 'eio/eio.stub', 'EIO_READDIR_DIRS_FIRST' => 'eio/eio.stub', 'EIO_READDIR_FOUND_UNKNOWN' => 'eio/eio.stub', 'EIO_READDIR_STAT_ORDER' => 'eio/eio.stub', 'EIO_SEEK_CUR' => 'eio/eio.stub', 'EIO_SEEK_END' => 'eio/eio.stub', 'EIO_SEEK_SET' => 'eio/eio.stub', 'EIO_SYNC_FILE_RANGE_WAIT_AFTER' => 'eio/eio.stub', 'EIO_SYNC_FILE_RANGE_WAIT_BEFORE' => 'eio/eio.stub', 'EIO_SYNC_FILE_RANGE_WRITE' => 'eio/eio.stub', 'EIO_S_IFBLK' => 'eio/eio.stub', 'EIO_S_IFCHR' => 'eio/eio.stub', 'EIO_S_IFIFO' => 'eio/eio.stub', 'EIO_S_IFREG' => 'eio/eio.stub', 'EIO_S_IFSOCK' => 'eio/eio.stub', 'EIO_S_IRGRP' => 'eio/eio.stub', 'EIO_S_IROTH' => 'eio/eio.stub', 'EIO_S_IRUSR' => 'eio/eio.stub', 'EIO_S_IWGRP' => 'eio/eio.stub', 'EIO_S_IWOTH' => 'eio/eio.stub', 'EIO_S_IWUSR' => 'eio/eio.stub', 'EIO_S_IXGRP' => 'eio/eio.stub', 'EIO_S_IXOTH' => 'eio/eio.stub', 'EIO_S_IXUSR' => 'eio/eio.stub', 'ENC7BIT' => 'imap/imap.stub', 'ENC8BIT' => 'imap/imap.stub', 'ENCBASE64' => 'imap/imap.stub', 'ENCBINARY' => 'imap/imap.stub', 'ENCHANT_ISPELL' => 'enchant/enchant.stub', 'ENCHANT_MYSPELL' => 'enchant/enchant.stub', 'ENCOTHER' => 'imap/imap.stub', 'ENCQUOTEDPRINTABLE' => 'imap/imap.stub', 'ENT_COMPAT' => 'standard/standard_defines.stub', 'ENT_DISALLOWED' => 'standard/standard_defines.stub', 'ENT_HTML401' => 'standard/standard_defines.stub', 'ENT_HTML5' => 'standard/standard_defines.stub', 'ENT_IGNORE' => 'standard/standard_defines.stub', 'ENT_NOQUOTES' => 'standard/standard_defines.stub', 'ENT_QUOTES' => 'standard/standard_defines.stub', 'ENT_SUBSTITUTE' => 'standard/standard_defines.stub', 'ENT_XHTML' => 'standard/standard_defines.stub', 'ENT_XML1' => 'standard/standard_defines.stub', 'ERA' => 'standard/standard_defines.stub', 'ERA_D_FMT' => 'standard/standard_defines.stub', 'ERA_D_T_FMT' => 'standard/standard_defines.stub', 'ERA_T_FMT' => 'standard/standard_defines.stub', 'ERA_YEAR' => 'standard/standard_defines.stub', 'EVBUFFER_EOF' => 'libevent/libevent.stub', 'EVBUFFER_ERROR' => 'libevent/libevent.stub', 'EVBUFFER_READ' => 'libevent/libevent.stub', 'EVBUFFER_TIMEOUT' => 'libevent/libevent.stub', 'EVBUFFER_WRITE' => 'libevent/libevent.stub', 'EVLOOP_NONBLOCK' => 'libevent/libevent.stub', 'EVLOOP_ONCE' => 'libevent/libevent.stub', 'EV_PERSIST' => 'libevent/libevent.stub', 'EV_READ' => 'libevent/libevent.stub', 'EV_SIGNAL' => 'libevent/libevent.stub', 'EV_TIMEOUT' => 'libevent/libevent.stub', 'EV_WRITE' => 'libevent/libevent.stub', 'EXIF_USE_MBSTRING' => 'exif/exif.stub', 'EXP_EOF' => 'expect/expect.stub', 'EXP_EXACT' => 'expect/expect.stub', 'EXP_FULLBUFFER' => 'expect/expect.stub', 'EXP_GLOB' => 'expect/expect.stub', 'EXP_REGEXP' => 'expect/expect.stub', 'EXP_TIMEOUT' => 'expect/expect.stub', 'EXTR_IF_EXISTS' => 'standard/standard_defines.stub', 'EXTR_OVERWRITE' => 'standard/standard_defines.stub', 'EXTR_PREFIX_ALL' => 'standard/standard_defines.stub', 'EXTR_PREFIX_IF_EXISTS' => 'standard/standard_defines.stub', 'EXTR_PREFIX_INVALID' => 'standard/standard_defines.stub', 'EXTR_PREFIX_SAME' => 'standard/standard_defines.stub', 'EXTR_REFS' => 'standard/standard_defines.stub', 'EXTR_SKIP' => 'standard/standard_defines.stub', 'E_ALL' => 'Core/Core_d.stub', 'E_COMPILE_ERROR' => 'Core/Core_d.stub', 'E_COMPILE_WARNING' => 'Core/Core_d.stub', 'E_CORE_ERROR' => 'Core/Core_d.stub', 'E_CORE_WARNING' => 'Core/Core_d.stub', 'E_DEPRECATED' => 'Core/Core_d.stub', 'E_ERROR' => 'Core/Core_d.stub', 'E_NOTICE' => 'Core/Core_d.stub', 'E_PARSE' => 'Core/Core_d.stub', 'E_RECOVERABLE_ERROR' => 'Core/Core_d.stub', 'E_STRICT' => 'Core/Core_d.stub', 'E_USER_DEPRECATED' => 'Core/Core_d.stub', 'E_USER_ERROR' => 'Core/Core_d.stub', 'E_USER_NOTICE' => 'Core/Core_d.stub', 'E_USER_WARNING' => 'Core/Core_d.stub', 'E_WARNING' => 'Core/Core_d.stub', 'EditBox' => 'winbinder/winbinder.stub', 'FANN_COS' => 'fann/fann.stub', 'FANN_COS_SYMMETRIC' => 'fann/fann.stub', 'FANN_ELLIOT' => 'fann/fann.stub', 'FANN_ELLIOT_SYMMETRIC' => 'fann/fann.stub', 'FANN_ERRORFUNC_LINEAR' => 'fann/fann.stub', 'FANN_ERRORFUNC_TANH' => 'fann/fann.stub', 'FANN_E_CANT_ALLOCATE_MEM' => 'fann/fann.stub', 'FANN_E_CANT_OPEN_CONFIG_R' => 'fann/fann.stub', 'FANN_E_CANT_OPEN_CONFIG_W' => 'fann/fann.stub', 'FANN_E_CANT_OPEN_TD_R' => 'fann/fann.stub', 'FANN_E_CANT_OPEN_TD_W' => 'fann/fann.stub', 'FANN_E_CANT_READ_CONFIG' => 'fann/fann.stub', 'FANN_E_CANT_READ_CONNECTIONS' => 'fann/fann.stub', 'FANN_E_CANT_READ_NEURON' => 'fann/fann.stub', 'FANN_E_CANT_READ_TD' => 'fann/fann.stub', 'FANN_E_CANT_TRAIN_ACTIVATION' => 'fann/fann.stub', 'FANN_E_CANT_USE_ACTIVATION' => 'fann/fann.stub', 'FANN_E_CANT_USE_TRAIN_ALG' => 'fann/fann.stub', 'FANN_E_INDEX_OUT_OF_BOUND' => 'fann/fann.stub', 'FANN_E_INPUT_NO_MATCH' => 'fann/fann.stub', 'FANN_E_NO_ERROR' => 'fann/fann.stub', 'FANN_E_OUTPUT_NO_MATCH' => 'fann/fann.stub', 'FANN_E_SCALE_NOT_PRESENT' => 'fann/fann.stub', 'FANN_E_TRAIN_DATA_MISMATCH' => 'fann/fann.stub', 'FANN_E_TRAIN_DATA_SUBSET' => 'fann/fann.stub', 'FANN_E_WRONG_CONFIG_VERSION' => 'fann/fann.stub', 'FANN_E_WRONG_NUM_CONNECTIONS' => 'fann/fann.stub', 'FANN_GAUSSIAN' => 'fann/fann.stub', 'FANN_GAUSSIAN_STEPWISE' => 'fann/fann.stub', 'FANN_GAUSSIAN_SYMMETRIC' => 'fann/fann.stub', 'FANN_LINEAR' => 'fann/fann.stub', 'FANN_LINEAR_PIECE' => 'fann/fann.stub', 'FANN_LINEAR_PIECE_SYMMETRIC' => 'fann/fann.stub', 'FANN_NETTYPE_LAYER' => 'fann/fann.stub', 'FANN_NETTYPE_SHORTCUT' => 'fann/fann.stub', 'FANN_SIGMOID' => 'fann/fann.stub', 'FANN_SIGMOID_STEPWISE' => 'fann/fann.stub', 'FANN_SIGMOID_SYMMETRIC' => 'fann/fann.stub', 'FANN_SIGMOID_SYMMETRIC_STEPWISE' => 'fann/fann.stub', 'FANN_SIN' => 'fann/fann.stub', 'FANN_SIN_SYMMETRIC' => 'fann/fann.stub', 'FANN_STOPFUNC_BIT' => 'fann/fann.stub', 'FANN_STOPFUNC_MSE' => 'fann/fann.stub', 'FANN_THRESHOLD' => 'fann/fann.stub', 'FANN_THRESHOLD_SYMMETRIC' => 'fann/fann.stub', 'FANN_TRAIN_BATCH' => 'fann/fann.stub', 'FANN_TRAIN_INCREMENTAL' => 'fann/fann.stub', 'FANN_TRAIN_QUICKPROP' => 'fann/fann.stub', 'FANN_TRAIN_RPROP' => 'fann/fann.stub', 'FANN_TRAIN_SARPROP' => 'fann/fann.stub', 'FANN_VERSION' => 'fann/fann.stub', 'FILEINFO_APPLE' => 'fileinfo/fileinfo.stub', 'FILEINFO_CONTINUE' => 'fileinfo/fileinfo.stub', 'FILEINFO_DEVICES' => 'fileinfo/fileinfo.stub', 'FILEINFO_EXTENSION' => 'fileinfo/fileinfo.stub', 'FILEINFO_MIME' => 'fileinfo/fileinfo.stub', 'FILEINFO_MIME_ENCODING' => 'fileinfo/fileinfo.stub', 'FILEINFO_MIME_TYPE' => 'fileinfo/fileinfo.stub', 'FILEINFO_NONE' => 'fileinfo/fileinfo.stub', 'FILEINFO_PRESERVE_ATIME' => 'fileinfo/fileinfo.stub', 'FILEINFO_RAW' => 'fileinfo/fileinfo.stub', 'FILEINFO_SYMLINK' => 'fileinfo/fileinfo.stub', 'FILE_APPEND' => 'standard/standard_defines.stub', 'FILE_BINARY' => 'standard/standard_defines.stub', 'FILE_IGNORE_NEW_LINES' => 'standard/standard_defines.stub', 'FILE_NO_DEFAULT_CONTEXT' => 'standard/standard_defines.stub', 'FILE_SKIP_EMPTY_LINES' => 'standard/standard_defines.stub', 'FILE_TEXT' => 'standard/standard_defines.stub', 'FILE_USE_INCLUDE_PATH' => 'standard/standard_defines.stub', 'FILTER_CALLBACK' => 'filter/filter.stub', 'FILTER_DEFAULT' => 'filter/filter.stub', 'FILTER_FLAG_ALLOW_FRACTION' => 'filter/filter.stub', 'FILTER_FLAG_ALLOW_HEX' => 'filter/filter.stub', 'FILTER_FLAG_ALLOW_OCTAL' => 'filter/filter.stub', 'FILTER_FLAG_ALLOW_SCIENTIFIC' => 'filter/filter.stub', 'FILTER_FLAG_ALLOW_THOUSAND' => 'filter/filter.stub', 'FILTER_FLAG_EMAIL_UNICODE' => 'filter/filter.stub', 'FILTER_FLAG_EMPTY_STRING_NULL' => 'filter/filter.stub', 'FILTER_FLAG_ENCODE_AMP' => 'filter/filter.stub', 'FILTER_FLAG_ENCODE_HIGH' => 'filter/filter.stub', 'FILTER_FLAG_ENCODE_LOW' => 'filter/filter.stub', 'FILTER_FLAG_GLOBAL_RANGE' => 'filter/filter.stub', 'FILTER_FLAG_HOSTNAME' => 'filter/filter.stub', 'FILTER_FLAG_HOST_REQUIRED' => 'filter/filter.stub', 'FILTER_FLAG_IPV4' => 'filter/filter.stub', 'FILTER_FLAG_IPV6' => 'filter/filter.stub', 'FILTER_FLAG_NONE' => 'filter/filter.stub', 'FILTER_FLAG_NO_ENCODE_QUOTES' => 'filter/filter.stub', 'FILTER_FLAG_NO_PRIV_RANGE' => 'filter/filter.stub', 'FILTER_FLAG_NO_RES_RANGE' => 'filter/filter.stub', 'FILTER_FLAG_PATH_REQUIRED' => 'filter/filter.stub', 'FILTER_FLAG_QUERY_REQUIRED' => 'filter/filter.stub', 'FILTER_FLAG_SCHEME_REQUIRED' => 'filter/filter.stub', 'FILTER_FLAG_STRIP_BACKTICK' => 'filter/filter.stub', 'FILTER_FLAG_STRIP_HIGH' => 'filter/filter.stub', 'FILTER_FLAG_STRIP_LOW' => 'filter/filter.stub', 'FILTER_FORCE_ARRAY' => 'filter/filter.stub', 'FILTER_NULL_ON_FAILURE' => 'filter/filter.stub', 'FILTER_REQUIRE_ARRAY' => 'filter/filter.stub', 'FILTER_REQUIRE_SCALAR' => 'filter/filter.stub', 'FILTER_SANITIZE_ADD_SLASHES' => 'filter/filter.stub', 'FILTER_SANITIZE_EMAIL' => 'filter/filter.stub', 'FILTER_SANITIZE_ENCODED' => 'filter/filter.stub', 'FILTER_SANITIZE_FULL_SPECIAL_CHARS' => 'filter/filter.stub', 'FILTER_SANITIZE_MAGIC_QUOTES' => 'filter/filter.stub', 'FILTER_SANITIZE_NUMBER_FLOAT' => 'filter/filter.stub', 'FILTER_SANITIZE_NUMBER_INT' => 'filter/filter.stub', 'FILTER_SANITIZE_SPECIAL_CHARS' => 'filter/filter.stub', 'FILTER_SANITIZE_STRING' => 'filter/filter.stub', 'FILTER_SANITIZE_STRIPPED' => 'filter/filter.stub', 'FILTER_SANITIZE_URL' => 'filter/filter.stub', 'FILTER_UNSAFE_RAW' => 'filter/filter.stub', 'FILTER_VALIDATE_BOOL' => 'filter/filter.stub', 'FILTER_VALIDATE_BOOLEAN' => 'filter/filter.stub', 'FILTER_VALIDATE_DOMAIN' => 'filter/filter.stub', 'FILTER_VALIDATE_EMAIL' => 'filter/filter.stub', 'FILTER_VALIDATE_FLOAT' => 'filter/filter.stub', 'FILTER_VALIDATE_INT' => 'filter/filter.stub', 'FILTER_VALIDATE_IP' => 'filter/filter.stub', 'FILTER_VALIDATE_MAC' => 'filter/filter.stub', 'FILTER_VALIDATE_REGEXP' => 'filter/filter.stub', 'FILTER_VALIDATE_URL' => 'filter/filter.stub', 'FNM_CASEFOLD' => 'standard/standard_defines.stub', 'FNM_NOESCAPE' => 'standard/standard_defines.stub', 'FNM_PATHNAME' => 'standard/standard_defines.stub', 'FNM_PERIOD' => 'standard/standard_defines.stub', 'FORCE_DEFLATE' => 'zlib/zlib.stub', 'FORCE_GZIP' => 'zlib/zlib.stub', 'FPE_FLTDIV' => 'pcntl/pcntl.stub', 'FPE_FLTINV' => 'pcntl/pcntl.stub', 'FPE_FLTOVF' => 'pcntl/pcntl.stub', 'FPE_FLTRES' => 'pcntl/pcntl.stub', 'FPE_FLTSUB' => 'pcntl/pcntl.stub', 'FPE_FLTUND' => 'pcntl/pcntl.stub', 'FPE_INTDIV' => 'pcntl/pcntl.stub', 'FPE_INTOVF' => 'pcntl/pcntl.stub', 'FRAC_DIGITS' => 'standard/standard_defines.stub', 'FTA_BOLD' => 'winbinder/winbinder.stub', 'FTA_ITALIC' => 'winbinder/winbinder.stub', 'FTA_NORMAL' => 'winbinder/winbinder.stub', 'FTA_REGULAR' => 'winbinder/winbinder.stub', 'FTA_STRIKEOUT' => 'winbinder/winbinder.stub', 'FTA_UNDERLINE' => 'winbinder/winbinder.stub', 'FTP_ASCII' => 'ftp/ftp.stub', 'FTP_AUTORESUME' => 'ftp/ftp.stub', 'FTP_AUTOSEEK' => 'ftp/ftp.stub', 'FTP_BINARY' => 'ftp/ftp.stub', 'FTP_FAILED' => 'ftp/ftp.stub', 'FTP_FINISHED' => 'ftp/ftp.stub', 'FTP_IMAGE' => 'ftp/ftp.stub', 'FTP_MOREDATA' => 'ftp/ftp.stub', 'FTP_TEXT' => 'ftp/ftp.stub', 'FTP_TIMEOUT_SEC' => 'ftp/ftp.stub', 'FTP_USEPASVADDRESS' => 'ftp/ftp.stub', 'FT_INTERNAL' => 'imap/imap.stub', 'FT_NOT' => 'imap/imap.stub', 'FT_PEEK' => 'imap/imap.stub', 'FT_PREFETCHTEXT' => 'imap/imap.stub', 'FT_UID' => 'imap/imap.stub', 'F_DUPFD' => 'dio/dio_d.stub', 'F_GETFD' => 'dio/dio_d.stub', 'F_GETFL' => 'dio/dio_d.stub', 'F_GETLK' => 'dio/dio_d.stub', 'F_GETOWN' => 'dio/dio_d.stub', 'F_RDLCK' => 'dio/dio_d.stub', 'F_SETFL' => 'dio/dio_d.stub', 'F_SETLK' => 'dio/dio_d.stub', 'F_SETLKW' => 'dio/dio_d.stub', 'F_SETOWN' => 'dio/dio_d.stub', 'F_UNLCK' => 'dio/dio_d.stub', 'F_WRLCK' => 'dio/dio_d.stub', 'Frame' => 'winbinder/winbinder.stub', 'GD_BUNDLED' => 'gd/gd.stub', 'GD_EXTRA_VERSION' => 'gd/gd.stub', 'GD_MAJOR_VERSION' => 'gd/gd.stub', 'GD_MINOR_VERSION' => 'gd/gd.stub', 'GD_RELEASE_VERSION' => 'gd/gd.stub', 'GD_VERSION' => 'gd/gd.stub', 'GEARMAN_ARGS_BUFFER_SIZE' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_ALLOCATED' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_FREE_TASKS' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_NON_BLOCKING' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_NO_NEW' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_STATE_IDLE' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_STATE_NEW' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_STATE_PACKET' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_STATE_SUBMIT' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_TASK_IN_USE' => 'gearman/gearman.stub', 'GEARMAN_CLIENT_UNBUFFERED_RESULT' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_ALL_YOURS' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_CANT_DO' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_CAN_DO' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_CAN_DO_TIMEOUT' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_ECHO_REQ' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_ECHO_RES' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_ERROR' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_GET_STATUS' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_GRAB_JOB' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_GRAB_JOB_UNIQ' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_JOB_ASSIGN' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_JOB_ASSIGN_UNIQ' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_JOB_CREATED' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_MAX' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_NOOP' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_NO_JOB' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_OPTION_REQ' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_OPTION_RES' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_PRE_SLEEP' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_RESET_ABILITIES' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SET_CLIENT_ID' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_STATUS_RES' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB_BG' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB_EPOCH' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB_HIGH' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB_HIGH_BG' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB_LOW' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB_LOW_BG' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_SUBMIT_JOB_SCHED' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_TEXT' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_UNUSED' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_WORK_COMPLETE' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_WORK_DATA' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_WORK_EXCEPTION' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_WORK_FAIL' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_WORK_STATUS' => 'gearman/gearman.stub', 'GEARMAN_COMMAND_WORK_WARNING' => 'gearman/gearman.stub', 'GEARMAN_CON_CLOSE_AFTER_FLUSH' => 'gearman/gearman.stub', 'GEARMAN_CON_EXTERNAL_FD' => 'gearman/gearman.stub', 'GEARMAN_CON_IGNORE_LOST_CONNECTION' => 'gearman/gearman.stub', 'GEARMAN_CON_PACKET_IN_USE' => 'gearman/gearman.stub', 'GEARMAN_CON_READY' => 'gearman/gearman.stub', 'GEARMAN_CON_RECV_STATE_READ_DATA' => 'gearman/gearman.stub', 'GEARMAN_CON_SEND_STATE_NONE' => 'gearman/gearman.stub', 'GEARMAN_COULD_NOT_CONNECT' => 'gearman/gearman.stub', 'GEARMAN_DATA_TOO_LARGE' => 'gearman/gearman.stub', 'GEARMAN_DEFAULT_SOCKET_RECV_SIZE' => 'gearman/gearman.stub', 'GEARMAN_DEFAULT_SOCKET_SEND_SIZE' => 'gearman/gearman.stub', 'GEARMAN_DEFAULT_SOCKET_TIMEOUT' => 'gearman/gearman.stub', 'GEARMAN_DEFAULT_TCP_HOST' => 'gearman/gearman.stub', 'GEARMAN_DEFAULT_TCP_PORT' => 'gearman/gearman.stub', 'GEARMAN_DONT_TRACK_PACKETS' => 'gearman/gearman.stub', 'GEARMAN_ECHO_DATA_CORRUPTION' => 'gearman/gearman.stub', 'GEARMAN_ERRNO' => 'gearman/gearman.stub', 'GEARMAN_EVENT' => 'gearman/gearman.stub', 'GEARMAN_FLUSH_DATA' => 'gearman/gearman.stub', 'GEARMAN_GETADDRINFO' => 'gearman/gearman.stub', 'GEARMAN_IGNORE_PACKET' => 'gearman/gearman.stub', 'GEARMAN_INVALID_COMMAND' => 'gearman/gearman.stub', 'GEARMAN_INVALID_FUNCTION_NAME' => 'gearman/gearman.stub', 'GEARMAN_INVALID_MAGIC' => 'gearman/gearman.stub', 'GEARMAN_INVALID_PACKET' => 'gearman/gearman.stub', 'GEARMAN_INVALID_WORKER_FUNCTION' => 'gearman/gearman.stub', 'GEARMAN_IO_WAIT' => 'gearman/gearman.stub', 'GEARMAN_JOB_EXISTS' => 'gearman/gearman.stub', 'GEARMAN_JOB_HANDLE_SIZE' => 'gearman/gearman.stub', 'GEARMAN_JOB_PRIORITY_HIGH' => 'gearman/gearman.stub', 'GEARMAN_JOB_PRIORITY_LOW' => 'gearman/gearman.stub', 'GEARMAN_JOB_PRIORITY_MAX' => 'gearman/gearman.stub', 'GEARMAN_JOB_PRIORITY_NORMAL' => 'gearman/gearman.stub', 'GEARMAN_JOB_QUEUE_FULL' => 'gearman/gearman.stub', 'GEARMAN_LOST_CONNECTION' => 'gearman/gearman.stub', 'GEARMAN_MAGIC_REQUEST' => 'gearman/gearman.stub', 'GEARMAN_MAGIC_RESPONSE' => 'gearman/gearman.stub', 'GEARMAN_MAGIC_TEXT' => 'gearman/gearman.stub', 'GEARMAN_MAX_COMMAND_ARGS' => 'gearman/gearman.stub', 'GEARMAN_MAX_ERROR_SIZE' => 'gearman/gearman.stub', 'GEARMAN_MAX_RETURN' => 'gearman/gearman.stub', 'GEARMAN_MEMORY_ALLOCATION_FAILURE' => 'gearman/gearman.stub', 'GEARMAN_NEED_WORKLOAD_FN' => 'gearman/gearman.stub', 'GEARMAN_NON_BLOCKING' => 'gearman/gearman.stub', 'GEARMAN_NOT_CONNECTED' => 'gearman/gearman.stub', 'GEARMAN_NOT_FLUSHING' => 'gearman/gearman.stub', 'GEARMAN_NO_ACTIVE_FDS' => 'gearman/gearman.stub', 'GEARMAN_NO_JOBS' => 'gearman/gearman.stub', 'GEARMAN_NO_REGISTERED_FUNCTIONS' => 'gearman/gearman.stub', 'GEARMAN_NO_SERVERS' => 'gearman/gearman.stub', 'GEARMAN_OPTION_SIZE' => 'gearman/gearman.stub', 'GEARMAN_PACKET_HEADER_SIZE' => 'gearman/gearman.stub', 'GEARMAN_PAUSE' => 'gearman/gearman.stub', 'GEARMAN_PIPE_EOF' => 'gearman/gearman.stub', 'GEARMAN_PTHREAD' => 'gearman/gearman.stub', 'GEARMAN_QUEUE_ERROR' => 'gearman/gearman.stub', 'GEARMAN_RECV_BUFFER_SIZE' => 'gearman/gearman.stub', 'GEARMAN_RECV_IN_PROGRESS' => 'gearman/gearman.stub', 'GEARMAN_SEND_BUFFER_SIZE' => 'gearman/gearman.stub', 'GEARMAN_SEND_BUFFER_TOO_SMALL' => 'gearman/gearman.stub', 'GEARMAN_SEND_IN_PROGRESS' => 'gearman/gearman.stub', 'GEARMAN_SERVER_ERROR' => 'gearman/gearman.stub', 'GEARMAN_SHUTDOWN' => 'gearman/gearman.stub', 'GEARMAN_SHUTDOWN_GRACEFUL' => 'gearman/gearman.stub', 'GEARMAN_SUCCESS' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_COMPLETE' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_CREATED' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_DATA' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_EXCEPTION' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_FAIL' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_FINISHED' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_NEW' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_STATUS' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_SUBMIT' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_WARNING' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_WORK' => 'gearman/gearman.stub', 'GEARMAN_TASK_STATE_WORKLOAD' => 'gearman/gearman.stub', 'GEARMAN_TIMEOUT' => 'gearman/gearman.stub', 'GEARMAN_TOO_MANY_ARGS' => 'gearman/gearman.stub', 'GEARMAN_UNEXPECTED_PACKET' => 'gearman/gearman.stub', 'GEARMAN_UNIQUE_SIZE' => 'gearman/gearman.stub', 'GEARMAN_UNKNOWN_OPTION' => 'gearman/gearman.stub', 'GEARMAN_UNKNOWN_STATE' => 'gearman/gearman.stub', 'GEARMAN_VERBOSE_CRAZY' => 'gearman/gearman.stub', 'GEARMAN_VERBOSE_DEBUG' => 'gearman/gearman.stub', 'GEARMAN_VERBOSE_ERROR' => 'gearman/gearman.stub', 'GEARMAN_VERBOSE_FATAL' => 'gearman/gearman.stub', 'GEARMAN_VERBOSE_INFO' => 'gearman/gearman.stub', 'GEARMAN_VERBOSE_MAX' => 'gearman/gearman.stub', 'GEARMAN_VERBOSE_NEVER' => 'gearman/gearman.stub', 'GEARMAN_WORKER_ALLOCATED' => 'gearman/gearman.stub', 'GEARMAN_WORKER_CHANGE' => 'gearman/gearman.stub', 'GEARMAN_WORKER_GRAB_JOB_IN_USE' => 'gearman/gearman.stub', 'GEARMAN_WORKER_GRAB_UNIQ' => 'gearman/gearman.stub', 'GEARMAN_WORKER_NON_BLOCKING' => 'gearman/gearman.stub', 'GEARMAN_WORKER_PACKET_INIT' => 'gearman/gearman.stub', 'GEARMAN_WORKER_PRE_SLEEP_IN_USE' => 'gearman/gearman.stub', 'GEARMAN_WORKER_STATE_CONNECT' => 'gearman/gearman.stub', 'GEARMAN_WORKER_STATE_FUNCTION_SEND' => 'gearman/gearman.stub', 'GEARMAN_WORKER_STATE_GRAB_JOB_RECV' => 'gearman/gearman.stub', 'GEARMAN_WORKER_STATE_GRAB_JOB_SEND' => 'gearman/gearman.stub', 'GEARMAN_WORKER_STATE_PRE_SLEEP' => 'gearman/gearman.stub', 'GEARMAN_WORKER_STATE_START' => 'gearman/gearman.stub', 'GEARMAN_WORKER_TIMEOUT_RETURN' => 'gearman/gearman.stub', 'GEARMAN_WORKER_WAIT_TIMEOUT' => 'gearman/gearman.stub', 'GEARMAN_WORKER_WORK_JOB_IN_USE' => 'gearman/gearman.stub', 'GEARMAN_WORK_DATA' => 'gearman/gearman.stub', 'GEARMAN_WORK_ERROR' => 'gearman/gearman.stub', 'GEARMAN_WORK_EXCEPTION' => 'gearman/gearman.stub', 'GEARMAN_WORK_FAIL' => 'gearman/gearman.stub', 'GEARMAN_WORK_STATUS' => 'gearman/gearman.stub', 'GEARMAN_WORK_WARNING' => 'gearman/gearman.stub', 'GEOIP_ASNUM_EDITION' => 'geoip/geoip.stub', 'GEOIP_CABLEDSL_SPEED' => 'geoip/geoip.stub', 'GEOIP_CITY_EDITION_REV0' => 'geoip/geoip.stub', 'GEOIP_CITY_EDITION_REV1' => 'geoip/geoip.stub', 'GEOIP_CORPORATE_SPEED' => 'geoip/geoip.stub', 'GEOIP_COUNTRY_EDITION' => 'geoip/geoip.stub', 'GEOIP_DIALUP_SPEED' => 'geoip/geoip.stub', 'GEOIP_DOMAIN_EDITION' => 'geoip/geoip.stub', 'GEOIP_ISP_EDITION' => 'geoip/geoip.stub', 'GEOIP_NETSPEED_EDITION' => 'geoip/geoip.stub', 'GEOIP_ORG_EDITION' => 'geoip/geoip.stub', 'GEOIP_PROXY_EDITION' => 'geoip/geoip.stub', 'GEOIP_REGION_EDITION_REV0' => 'geoip/geoip.stub', 'GEOIP_REGION_EDITION_REV1' => 'geoip/geoip.stub', 'GEOIP_UNKNOWN_SPEED' => 'geoip/geoip.stub', 'GEOSBUF_CAP_FLAT' => 'geos/geos.stub', 'GEOSBUF_CAP_ROUND' => 'geos/geos.stub', 'GEOSBUF_CAP_SQUARE' => 'geos/geos.stub', 'GEOSBUF_JOIN_BEVEL' => 'geos/geos.stub', 'GEOSBUF_JOIN_MITRE' => 'geos/geos.stub', 'GEOSBUF_JOIN_ROUND' => 'geos/geos.stub', 'GEOSRELATE_BNR_ENDPOINT' => 'geos/geos.stub', 'GEOSRELATE_BNR_MOD2' => 'geos/geos.stub', 'GEOSRELATE_BNR_MONOVALENT_ENDPOINT' => 'geos/geos.stub', 'GEOSRELATE_BNR_MULTIVALENT_ENDPOINT' => 'geos/geos.stub', 'GEOSRELATE_BNR_OGC' => 'geos/geos.stub', 'GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE' => 'geos/geos.stub', 'GEOS_GEOMETRYCOLLECTION' => 'geos/geos.stub', 'GEOS_LINEARRING' => 'geos/geos.stub', 'GEOS_LINESTRING' => 'geos/geos.stub', 'GEOS_MULTILINESTRING' => 'geos/geos.stub', 'GEOS_MULTIPOINT' => 'geos/geos.stub', 'GEOS_MULTIPOLYGON' => 'geos/geos.stub', 'GEOS_POINT' => 'geos/geos.stub', 'GEOS_POLYGON' => 'geos/geos.stub', 'GLOB_AVAILABLE_FLAGS' => 'standard/standard_defines.stub', 'GLOB_BRACE' => 'standard/standard_defines.stub', 'GLOB_ERR' => 'standard/standard_defines.stub', 'GLOB_MARK' => 'standard/standard_defines.stub', 'GLOB_NOCHECK' => 'standard/standard_defines.stub', 'GLOB_NOESCAPE' => 'standard/standard_defines.stub', 'GLOB_NOSORT' => 'standard/standard_defines.stub', 'GLOB_ONLYDIR' => 'standard/standard_defines.stub', 'GMP_BIG_ENDIAN' => 'gmp/gmp.stub', 'GMP_LITTLE_ENDIAN' => 'gmp/gmp.stub', 'GMP_LSW_FIRST' => 'gmp/gmp.stub', 'GMP_MPIR_VERSION' => 'gmp/gmp.stub', 'GMP_MSW_FIRST' => 'gmp/gmp.stub', 'GMP_NATIVE_ENDIAN' => 'gmp/gmp.stub', 'GMP_ROUND_MINUSINF' => 'gmp/gmp.stub', 'GMP_ROUND_PLUSINF' => 'gmp/gmp.stub', 'GMP_ROUND_ZERO' => 'gmp/gmp.stub', 'GMP_VERSION' => 'gmp/gmp.stub', 'GNUPG_ERROR_EXCEPTION' => 'gnupg/gnupg.stub', 'GNUPG_ERROR_SILENT' => 'gnupg/gnupg.stub', 'GNUPG_ERROR_WARNING' => 'gnupg/gnupg.stub', 'GNUPG_GPGME_VERSION' => 'gnupg/gnupg.stub', 'GNUPG_PK_DSA' => 'gnupg/gnupg.stub', 'GNUPG_PK_ECC' => 'gnupg/gnupg.stub', 'GNUPG_PK_ECDH' => 'gnupg/gnupg.stub', 'GNUPG_PK_ECDSA' => 'gnupg/gnupg.stub', 'GNUPG_PK_EDDSA' => 'gnupg/gnupg.stub', 'GNUPG_PK_ELG' => 'gnupg/gnupg.stub', 'GNUPG_PK_ELG_E' => 'gnupg/gnupg.stub', 'GNUPG_PK_RSA' => 'gnupg/gnupg.stub', 'GNUPG_PK_RSA_E' => 'gnupg/gnupg.stub', 'GNUPG_PK_RSA_S' => 'gnupg/gnupg.stub', 'GNUPG_PROTOCOL_CMS' => 'gnupg/gnupg.stub', 'GNUPG_PROTOCOL_OpenPGP' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_BAD_POLICY' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_CRL_MISSING' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_CRL_TOO_OLD' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_GREEN' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_KEY_EXPIRED' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_KEY_MISSING' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_KEY_REVOKED' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_RED' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_SIG_EXPIRED' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_SYS_ERROR' => 'gnupg/gnupg.stub', 'GNUPG_SIGSUM_VALID' => 'gnupg/gnupg.stub', 'GNUPG_SIG_MODE_CLEAR' => 'gnupg/gnupg.stub', 'GNUPG_SIG_MODE_DETACH' => 'gnupg/gnupg.stub', 'GNUPG_SIG_MODE_NORMAL' => 'gnupg/gnupg.stub', 'GNUPG_VALIDITY_FULL' => 'gnupg/gnupg.stub', 'GNUPG_VALIDITY_MARGINAL' => 'gnupg/gnupg.stub', 'GNUPG_VALIDITY_NEVER' => 'gnupg/gnupg.stub', 'GNUPG_VALIDITY_ULTIMATE' => 'gnupg/gnupg.stub', 'GNUPG_VALIDITY_UNDEFINED' => 'gnupg/gnupg.stub', 'GNUPG_VALIDITY_UNKNOWN' => 'gnupg/gnupg.stub', 'GRAPHEME_EXTR_COUNT' => 'intl/intl.stub', 'GRAPHEME_EXTR_MAXBYTES' => 'intl/intl.stub', 'GRAPHEME_EXTR_MAXCHARS' => 'intl/intl.stub', 'GREEN' => 'winbinder/winbinder.stub', 'GROUPING' => 'standard/standard_defines.stub', 'Gauge' => 'winbinder/winbinder.stub', 'Grpc\\CALL_ERROR' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_ALREADY_ACCEPTED' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_ALREADY_FINISHED' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_ALREADY_INVOKED' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_BATCH_TOO_BIG' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_INVALID_FLAGS' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_INVALID_MESSAGE' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_INVALID_METADATA' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_NOT_INVOKED' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_NOT_ON_CLIENT' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_NOT_ON_SERVER' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_PAYLOAD_TYPE_MISMATCH' => 'grpc/grpc.stub', 'Grpc\\CALL_ERROR_TOO_MANY_OPERATIONS' => 'grpc/grpc.stub', 'Grpc\\CALL_OK' => 'grpc/grpc.stub', 'Grpc\\CHANNEL_CONNECTING' => 'grpc/grpc.stub', 'Grpc\\CHANNEL_FATAL_FAILURE' => 'grpc/grpc.stub', 'Grpc\\CHANNEL_IDLE' => 'grpc/grpc.stub', 'Grpc\\CHANNEL_READY' => 'grpc/grpc.stub', 'Grpc\\CHANNEL_SHUTDOWN' => 'grpc/grpc.stub', 'Grpc\\CHANNEL_TRANSIENT_FAILURE' => 'grpc/grpc.stub', 'Grpc\\OP_RECV_CLOSE_ON_SERVER' => 'grpc/grpc.stub', 'Grpc\\OP_RECV_INITIAL_METADATA' => 'grpc/grpc.stub', 'Grpc\\OP_RECV_MESSAGE' => 'grpc/grpc.stub', 'Grpc\\OP_RECV_STATUS_ON_CLIENT' => 'grpc/grpc.stub', 'Grpc\\OP_SEND_CLOSE_FROM_CLIENT' => 'grpc/grpc.stub', 'Grpc\\OP_SEND_INITIAL_METADATA' => 'grpc/grpc.stub', 'Grpc\\OP_SEND_MESSAGE' => 'grpc/grpc.stub', 'Grpc\\OP_SEND_STATUS_FROM_SERVER' => 'grpc/grpc.stub', 'Grpc\\STATUS_ABORTED' => 'grpc/grpc.stub', 'Grpc\\STATUS_ALREADY_EXISTS' => 'grpc/grpc.stub', 'Grpc\\STATUS_CANCELLED' => 'grpc/grpc.stub', 'Grpc\\STATUS_DATA_LOSS' => 'grpc/grpc.stub', 'Grpc\\STATUS_DEADLINE_EXCEEDED' => 'grpc/grpc.stub', 'Grpc\\STATUS_FAILED_PRECONDITION' => 'grpc/grpc.stub', 'Grpc\\STATUS_INTERNAL' => 'grpc/grpc.stub', 'Grpc\\STATUS_INVALID_ARGUMENT' => 'grpc/grpc.stub', 'Grpc\\STATUS_NOT_FOUND' => 'grpc/grpc.stub', 'Grpc\\STATUS_OK' => 'grpc/grpc.stub', 'Grpc\\STATUS_OUT_OF_RANGE' => 'grpc/grpc.stub', 'Grpc\\STATUS_PERMISSION_DENIED' => 'grpc/grpc.stub', 'Grpc\\STATUS_RESOURCE_EXHAUSTED' => 'grpc/grpc.stub', 'Grpc\\STATUS_UNAUTHENTICATED' => 'grpc/grpc.stub', 'Grpc\\STATUS_UNAVAILABLE' => 'grpc/grpc.stub', 'Grpc\\STATUS_UNIMPLEMENTED' => 'grpc/grpc.stub', 'Grpc\\STATUS_UNKNOWN' => 'grpc/grpc.stub', 'Grpc\\WRITE_BUFFER_HINT' => 'grpc/grpc.stub', 'Grpc\\WRITE_NO_COMPRESS' => 'grpc/grpc.stub', 'HASH_HMAC' => 'hash/hash.stub', 'HTMLControl' => 'winbinder/winbinder.stub', 'HTML_ENTITIES' => 'standard/standard_defines.stub', 'HTML_SPECIALCHARS' => 'standard/standard_defines.stub', 'HTTP_AUTH_ANY' => 'http/http.stub', 'HTTP_AUTH_BASIC' => 'http/http.stub', 'HTTP_AUTH_DIGEST' => 'http/http.stub', 'HTTP_AUTH_GSSNEG' => 'http/http.stub', 'HTTP_AUTH_NTLM' => 'http/http.stub', 'HTTP_COOKIE_HTTPONLY' => 'http/http.stub', 'HTTP_COOKIE_PARSE_RAW' => 'http/http.stub', 'HTTP_COOKIE_SECURE' => 'http/http.stub', 'HTTP_DEFLATE_LEVEL_DEF' => 'http/http.stub', 'HTTP_DEFLATE_LEVEL_MAX' => 'http/http.stub', 'HTTP_DEFLATE_LEVEL_MIN' => 'http/http.stub', 'HTTP_DEFLATE_STRATEGY_DEF' => 'http/http.stub', 'HTTP_DEFLATE_STRATEGY_FILT' => 'http/http.stub', 'HTTP_DEFLATE_STRATEGY_FIXED' => 'http/http.stub', 'HTTP_DEFLATE_STRATEGY_HUFF' => 'http/http.stub', 'HTTP_DEFLATE_STRATEGY_RLE' => 'http/http.stub', 'HTTP_DEFLATE_TYPE_GZIP' => 'http/http.stub', 'HTTP_DEFLATE_TYPE_RAW' => 'http/http.stub', 'HTTP_DEFLATE_TYPE_ZLIB' => 'http/http.stub', 'HTTP_ENCODING_STREAM_FLUSH_FULL' => 'http/http.stub', 'HTTP_ENCODING_STREAM_FLUSH_NONE' => 'http/http.stub', 'HTTP_ENCODING_STREAM_FLUSH_SYNC' => 'http/http.stub', 'HTTP_E_ENCODING' => 'http/http.stub', 'HTTP_E_HEADER' => 'http/http.stub', 'HTTP_E_INVALID_PARAM' => 'http/http.stub', 'HTTP_E_MALFORMED_HEADERS' => 'http/http.stub', 'HTTP_E_MESSAGE_TYPE' => 'http/http.stub', 'HTTP_E_QUERYSTRING' => 'http/http.stub', 'HTTP_E_REQUEST' => 'http/http.stub', 'HTTP_E_REQUEST_METHOD' => 'http/http.stub', 'HTTP_E_REQUEST_POOL' => 'http/http.stub', 'HTTP_E_RESPONSE' => 'http/http.stub', 'HTTP_E_RUNTIME' => 'http/http.stub', 'HTTP_E_SOCKET' => 'http/http.stub', 'HTTP_E_URL' => 'http/http.stub', 'HTTP_IPRESOLVE_ANY' => 'http/http.stub', 'HTTP_IPRESOLVE_V4' => 'http/http.stub', 'HTTP_IPRESOLVE_V6' => 'http/http.stub', 'HTTP_METH_ACL' => 'http/http.stub', 'HTTP_METH_BASELINE_CONTROL' => 'http/http.stub', 'HTTP_METH_CHECKIN' => 'http/http.stub', 'HTTP_METH_CHECKOUT' => 'http/http.stub', 'HTTP_METH_CONNECT' => 'http/http.stub', 'HTTP_METH_COPY' => 'http/http.stub', 'HTTP_METH_DELETE' => 'http/http.stub', 'HTTP_METH_GET' => 'http/http.stub', 'HTTP_METH_HEAD' => 'http/http.stub', 'HTTP_METH_LABEL' => 'http/http.stub', 'HTTP_METH_LOCK' => 'http/http.stub', 'HTTP_METH_MERGE' => 'http/http.stub', 'HTTP_METH_MKACTIVITY' => 'http/http.stub', 'HTTP_METH_MKCOL' => 'http/http.stub', 'HTTP_METH_MKWORKSPACE' => 'http/http.stub', 'HTTP_METH_MOVE' => 'http/http.stub', 'HTTP_METH_OPTIONS' => 'http/http.stub', 'HTTP_METH_POST' => 'http/http.stub', 'HTTP_METH_PROPFIND' => 'http/http.stub', 'HTTP_METH_PROPPATCH' => 'http/http.stub', 'HTTP_METH_PUT' => 'http/http.stub', 'HTTP_METH_REPORT' => 'http/http.stub', 'HTTP_METH_TRACE' => 'http/http.stub', 'HTTP_METH_UNCHECKOUT' => 'http/http.stub', 'HTTP_METH_UNLOCK' => 'http/http.stub', 'HTTP_METH_UPDATE' => 'http/http.stub', 'HTTP_METH_VERSION_CONTROL' => 'http/http.stub', 'HTTP_MSG_NONE' => 'http/http.stub', 'HTTP_MSG_REQUEST' => 'http/http.stub', 'HTTP_MSG_RESPONSE' => 'http/http.stub', 'HTTP_PARAMS_ALLOW_COMMA' => 'http/http.stub', 'HTTP_PARAMS_ALLOW_FAILURE' => 'http/http.stub', 'HTTP_PARAMS_DEFAULT' => 'http/http.stub', 'HTTP_PARAMS_RAISE_ERROR' => 'http/http.stub', 'HTTP_PROXY_HTTP' => 'http/http.stub', 'HTTP_PROXY_SOCKS4' => 'http/http.stub', 'HTTP_PROXY_SOCKS5' => 'http/http.stub', 'HTTP_QUERYSTRING_TYPE_ARRAY' => 'http/http.stub', 'HTTP_QUERYSTRING_TYPE_BOOL' => 'http/http.stub', 'HTTP_QUERYSTRING_TYPE_FLOAT' => 'http/http.stub', 'HTTP_QUERYSTRING_TYPE_INT' => 'http/http.stub', 'HTTP_QUERYSTRING_TYPE_OBJECT' => 'http/http.stub', 'HTTP_QUERYSTRING_TYPE_STRING' => 'http/http.stub', 'HTTP_REDIRECT' => 'http/http.stub', 'HTTP_REDIRECT_FOUND' => 'http/http.stub', 'HTTP_REDIRECT_PERM' => 'http/http.stub', 'HTTP_REDIRECT_POST' => 'http/http.stub', 'HTTP_REDIRECT_PROXY' => 'http/http.stub', 'HTTP_REDIRECT_TEMP' => 'http/http.stub', 'HTTP_SSL_VERSION_ANY' => 'http/http.stub', 'HTTP_SSL_VERSION_SSLv2' => 'http/http.stub', 'HTTP_SSL_VERSION_SSLv3' => 'http/http.stub', 'HTTP_SSL_VERSION_TLSv1' => 'http/http.stub', 'HTTP_SUPPORT' => 'http/http.stub', 'HTTP_SUPPORT_ENCODINGS' => 'http/http.stub', 'HTTP_SUPPORT_EVENTS' => 'http/http.stub', 'HTTP_SUPPORT_MAGICMIME' => 'http/http.stub', 'HTTP_SUPPORT_REQUESTS' => 'http/http.stub', 'HTTP_SUPPORT_SSLREQUESTS' => 'http/http.stub', 'HTTP_URL_FROM_ENV' => 'http/http.stub', 'HTTP_URL_JOIN_PATH' => 'http/http.stub', 'HTTP_URL_JOIN_QUERY' => 'http/http.stub', 'HTTP_URL_REPLACE' => 'http/http.stub', 'HTTP_URL_STRIP_ALL' => 'http/http.stub', 'HTTP_URL_STRIP_AUTH' => 'http/http.stub', 'HTTP_URL_STRIP_FRAGMENT' => 'http/http.stub', 'HTTP_URL_STRIP_PASS' => 'http/http.stub', 'HTTP_URL_STRIP_PATH' => 'http/http.stub', 'HTTP_URL_STRIP_PORT' => 'http/http.stub', 'HTTP_URL_STRIP_QUERY' => 'http/http.stub', 'HTTP_URL_STRIP_USER' => 'http/http.stub', 'HTTP_VERSION_1_0' => 'http/http.stub', 'HTTP_VERSION_1_1' => 'http/http.stub', 'HTTP_VERSION_ANY' => 'http/http.stub', 'HTTP_VERSION_NONE' => 'http/http.stub', 'HyperLink' => 'winbinder/winbinder.stub', 'IBASE_BKP_CONVERT' => 'interbase/interbase.stub', 'IBASE_BKP_IGNORE_CHECKSUMS' => 'interbase/interbase.stub', 'IBASE_BKP_IGNORE_LIMBO' => 'interbase/interbase.stub', 'IBASE_BKP_METADATA_ONLY' => 'interbase/interbase.stub', 'IBASE_BKP_NON_TRANSPORTABLE' => 'interbase/interbase.stub', 'IBASE_BKP_NO_GARBAGE_COLLECT' => 'interbase/interbase.stub', 'IBASE_BKP_OLD_DESCRIPTIONS' => 'interbase/interbase.stub', 'IBASE_COMMITTED' => 'interbase/interbase.stub', 'IBASE_CONCURRENCY' => 'interbase/interbase.stub', 'IBASE_CONSISTENCY' => 'interbase/interbase.stub', 'IBASE_CREATE' => 'interbase/interbase.stub', 'IBASE_DEFAULT' => 'interbase/interbase.stub', 'IBASE_FETCH_ARRAYS' => 'interbase/interbase.stub', 'IBASE_FETCH_BLOBS' => 'interbase/interbase.stub', 'IBASE_NOWAIT' => 'interbase/interbase.stub', 'IBASE_PRP_ACCESS_MODE' => 'interbase/interbase.stub', 'IBASE_PRP_ACTIVATE' => 'interbase/interbase.stub', 'IBASE_PRP_AM_READONLY' => 'interbase/interbase.stub', 'IBASE_PRP_AM_READWRITE' => 'interbase/interbase.stub', 'IBASE_PRP_DB_ONLINE' => 'interbase/interbase.stub', 'IBASE_PRP_DENY_NEW_ATTACHMENTS' => 'interbase/interbase.stub', 'IBASE_PRP_DENY_NEW_TRANSACTIONS' => 'interbase/interbase.stub', 'IBASE_PRP_PAGE_BUFFERS' => 'interbase/interbase.stub', 'IBASE_PRP_RES' => 'interbase/interbase.stub', 'IBASE_PRP_RESERVE_SPACE' => 'interbase/interbase.stub', 'IBASE_PRP_RES_USE_FULL' => 'interbase/interbase.stub', 'IBASE_PRP_SET_SQL_DIALECT' => 'interbase/interbase.stub', 'IBASE_PRP_SHUTDOWN_DB' => 'interbase/interbase.stub', 'IBASE_PRP_SWEEP_INTERVAL' => 'interbase/interbase.stub', 'IBASE_PRP_WM_ASYNC' => 'interbase/interbase.stub', 'IBASE_PRP_WM_SYNC' => 'interbase/interbase.stub', 'IBASE_PRP_WRITE_MODE' => 'interbase/interbase.stub', 'IBASE_READ' => 'interbase/interbase.stub', 'IBASE_REC_NO_VERSION' => 'interbase/interbase.stub', 'IBASE_REC_VERSION' => 'interbase/interbase.stub', 'IBASE_RES_CREATE' => 'interbase/interbase.stub', 'IBASE_RES_DEACTIVATE_IDX' => 'interbase/interbase.stub', 'IBASE_RES_NO_SHADOW' => 'interbase/interbase.stub', 'IBASE_RES_NO_VALIDITY' => 'interbase/interbase.stub', 'IBASE_RES_ONE_AT_A_TIME' => 'interbase/interbase.stub', 'IBASE_RES_REPLACE' => 'interbase/interbase.stub', 'IBASE_RES_USE_ALL_SPACE' => 'interbase/interbase.stub', 'IBASE_RPR_CHECK_DB' => 'interbase/interbase.stub', 'IBASE_RPR_FULL' => 'interbase/interbase.stub', 'IBASE_RPR_IGNORE_CHECKSUM' => 'interbase/interbase.stub', 'IBASE_RPR_KILL_SHADOWS' => 'interbase/interbase.stub', 'IBASE_RPR_MEND_DB' => 'interbase/interbase.stub', 'IBASE_RPR_SWEEP_DB' => 'interbase/interbase.stub', 'IBASE_RPR_VALIDATE_DB' => 'interbase/interbase.stub', 'IBASE_STS_DATA_PAGES' => 'interbase/interbase.stub', 'IBASE_STS_DB_LOG' => 'interbase/interbase.stub', 'IBASE_STS_HDR_PAGES' => 'interbase/interbase.stub', 'IBASE_STS_IDX_PAGES' => 'interbase/interbase.stub', 'IBASE_STS_SYS_RELATIONS' => 'interbase/interbase.stub', 'IBASE_SVC_GET_ENV' => 'interbase/interbase.stub', 'IBASE_SVC_GET_ENV_LOCK' => 'interbase/interbase.stub', 'IBASE_SVC_GET_ENV_MSG' => 'interbase/interbase.stub', 'IBASE_SVC_GET_USERS' => 'interbase/interbase.stub', 'IBASE_SVC_IMPLEMENTATION' => 'interbase/interbase.stub', 'IBASE_SVC_SERVER_VERSION' => 'interbase/interbase.stub', 'IBASE_SVC_SVR_DB_INFO' => 'interbase/interbase.stub', 'IBASE_SVC_USER_DBPATH' => 'interbase/interbase.stub', 'IBASE_TEXT' => 'interbase/interbase.stub', 'IBASE_UNIXTIME' => 'interbase/interbase.stub', 'IBASE_WAIT' => 'interbase/interbase.stub', 'IBASE_WRITE' => 'interbase/interbase.stub', 'ICONV_IMPL' => 'iconv/iconv.stub', 'ICONV_MIME_DECODE_CONTINUE_ON_ERROR' => 'iconv/iconv.stub', 'ICONV_MIME_DECODE_STRICT' => 'iconv/iconv.stub', 'ICONV_VERSION' => 'iconv/iconv.stub', 'IDABORT' => 'winbinder/winbinder.stub', 'IDCANCEL' => 'winbinder/winbinder.stub', 'IDCLOSE' => 'winbinder/winbinder.stub', 'IDDEFAULT' => 'winbinder/winbinder.stub', 'IDHELP' => 'winbinder/winbinder.stub', 'IDIGNORE' => 'winbinder/winbinder.stub', 'IDNA_ALLOW_UNASSIGNED' => 'intl/intl.stub', 'IDNA_CHECK_BIDI' => 'intl/intl.stub', 'IDNA_CHECK_CONTEXTJ' => 'intl/intl.stub', 'IDNA_DEFAULT' => 'intl/intl.stub', 'IDNA_ERROR_BIDI' => 'intl/intl.stub', 'IDNA_ERROR_CONTEXTJ' => 'intl/intl.stub', 'IDNA_ERROR_DISALLOWED' => 'intl/intl.stub', 'IDNA_ERROR_DOMAIN_NAME_TOO_LONG' => 'intl/intl.stub', 'IDNA_ERROR_EMPTY_LABEL' => 'intl/intl.stub', 'IDNA_ERROR_HYPHEN_3_4' => 'intl/intl.stub', 'IDNA_ERROR_INVALID_ACE_LABEL' => 'intl/intl.stub', 'IDNA_ERROR_LABEL_HAS_DOT' => 'intl/intl.stub', 'IDNA_ERROR_LABEL_TOO_LONG' => 'intl/intl.stub', 'IDNA_ERROR_LEADING_COMBINING_MARK' => 'intl/intl.stub', 'IDNA_ERROR_LEADING_HYPHEN' => 'intl/intl.stub', 'IDNA_ERROR_PUNYCODE' => 'intl/intl.stub', 'IDNA_ERROR_TRAILING_HYPHEN' => 'intl/intl.stub', 'IDNA_NONTRANSITIONAL_TO_ASCII' => 'intl/intl.stub', 'IDNA_NONTRANSITIONAL_TO_UNICODE' => 'intl/intl.stub', 'IDNA_USE_STD3_RULES' => 'intl/intl.stub', 'IDNO' => 'winbinder/winbinder.stub', 'IDOK' => 'winbinder/winbinder.stub', 'IDRETRY' => 'winbinder/winbinder.stub', 'IDYES' => 'winbinder/winbinder.stub', 'ILL_BADSTK' => 'pcntl/pcntl.stub', 'ILL_COPROC' => 'pcntl/pcntl.stub', 'ILL_ILLADR' => 'pcntl/pcntl.stub', 'ILL_ILLOPC' => 'pcntl/pcntl.stub', 'ILL_ILLOPN' => 'pcntl/pcntl.stub', 'ILL_ILLTRP' => 'pcntl/pcntl.stub', 'ILL_PRVOPC' => 'pcntl/pcntl.stub', 'ILL_PRVREG' => 'pcntl/pcntl.stub', 'IMAGETYPE_AVIF' => 'standard/standard_defines.stub', 'IMAGETYPE_BMP' => 'standard/standard_defines.stub', 'IMAGETYPE_COUNT' => 'standard/standard_defines.stub', 'IMAGETYPE_GIF' => 'standard/standard_defines.stub', 'IMAGETYPE_ICO' => 'standard/standard_defines.stub', 'IMAGETYPE_IFF' => 'standard/standard_defines.stub', 'IMAGETYPE_JB2' => 'standard/standard_defines.stub', 'IMAGETYPE_JP2' => 'standard/standard_defines.stub', 'IMAGETYPE_JPC' => 'standard/standard_defines.stub', 'IMAGETYPE_JPEG' => 'standard/standard_defines.stub', 'IMAGETYPE_JPEG2000' => 'standard/standard_defines.stub', 'IMAGETYPE_JPX' => 'standard/standard_defines.stub', 'IMAGETYPE_PNG' => 'standard/standard_defines.stub', 'IMAGETYPE_PSD' => 'standard/standard_defines.stub', 'IMAGETYPE_SWC' => 'standard/standard_defines.stub', 'IMAGETYPE_SWF' => 'standard/standard_defines.stub', 'IMAGETYPE_TIFF_II' => 'standard/standard_defines.stub', 'IMAGETYPE_TIFF_MM' => 'standard/standard_defines.stub', 'IMAGETYPE_UNKNOWN' => 'standard/standard_defines.stub', 'IMAGETYPE_WBMP' => 'standard/standard_defines.stub', 'IMAGETYPE_WEBP' => 'standard/standard_defines.stub', 'IMAGETYPE_XBM' => 'standard/standard_defines.stub', 'IMAP_CLOSETIMEOUT' => 'imap/imap.stub', 'IMAP_GC_ELT' => 'imap/imap.stub', 'IMAP_GC_ENV' => 'imap/imap.stub', 'IMAP_GC_TEXTS' => 'imap/imap.stub', 'IMAP_OPENTIMEOUT' => 'imap/imap.stub', 'IMAP_READTIMEOUT' => 'imap/imap.stub', 'IMAP_WRITETIMEOUT' => 'imap/imap.stub', 'IMG_AFFINE_ROTATE' => 'gd/gd.stub', 'IMG_AFFINE_SCALE' => 'gd/gd.stub', 'IMG_AFFINE_SHEAR_HORIZONTAL' => 'gd/gd.stub', 'IMG_AFFINE_SHEAR_VERTICAL' => 'gd/gd.stub', 'IMG_AFFINE_TRANSLATE' => 'gd/gd.stub', 'IMG_ARC_CHORD' => 'gd/gd.stub', 'IMG_ARC_EDGED' => 'gd/gd.stub', 'IMG_ARC_NOFILL' => 'gd/gd.stub', 'IMG_ARC_PIE' => 'gd/gd.stub', 'IMG_ARC_ROUNDED' => 'gd/gd.stub', 'IMG_AVIF' => 'gd/gd.stub', 'IMG_BELL' => 'gd/gd.stub', 'IMG_BESSEL' => 'gd/gd.stub', 'IMG_BICUBIC' => 'gd/gd.stub', 'IMG_BICUBIC_FIXED' => 'gd/gd.stub', 'IMG_BILINEAR_FIXED' => 'gd/gd.stub', 'IMG_BLACKMAN' => 'gd/gd.stub', 'IMG_BMP' => 'gd/gd.stub', 'IMG_BOX' => 'gd/gd.stub', 'IMG_BSPLINE' => 'gd/gd.stub', 'IMG_CATMULLROM' => 'gd/gd.stub', 'IMG_COLOR_BRUSHED' => 'gd/gd.stub', 'IMG_COLOR_STYLED' => 'gd/gd.stub', 'IMG_COLOR_STYLEDBRUSHED' => 'gd/gd.stub', 'IMG_COLOR_TILED' => 'gd/gd.stub', 'IMG_COLOR_TRANSPARENT' => 'gd/gd.stub', 'IMG_CROP_BLACK' => 'gd/gd.stub', 'IMG_CROP_DEFAULT' => 'gd/gd.stub', 'IMG_CROP_SIDES' => 'gd/gd.stub', 'IMG_CROP_THRESHOLD' => 'gd/gd.stub', 'IMG_CROP_TRANSPARENT' => 'gd/gd.stub', 'IMG_CROP_WHITE' => 'gd/gd.stub', 'IMG_EFFECT_ALPHABLEND' => 'gd/gd.stub', 'IMG_EFFECT_MULTIPLY' => 'gd/gd.stub', 'IMG_EFFECT_NORMAL' => 'gd/gd.stub', 'IMG_EFFECT_OVERLAY' => 'gd/gd.stub', 'IMG_EFFECT_REPLACE' => 'gd/gd.stub', 'IMG_FILTER_BRIGHTNESS' => 'gd/gd.stub', 'IMG_FILTER_COLORIZE' => 'gd/gd.stub', 'IMG_FILTER_CONTRAST' => 'gd/gd.stub', 'IMG_FILTER_EDGEDETECT' => 'gd/gd.stub', 'IMG_FILTER_EMBOSS' => 'gd/gd.stub', 'IMG_FILTER_GAUSSIAN_BLUR' => 'gd/gd.stub', 'IMG_FILTER_GRAYSCALE' => 'gd/gd.stub', 'IMG_FILTER_MEAN_REMOVAL' => 'gd/gd.stub', 'IMG_FILTER_NEGATE' => 'gd/gd.stub', 'IMG_FILTER_PIXELATE' => 'gd/gd.stub', 'IMG_FILTER_SCATTER' => 'gd/gd.stub', 'IMG_FILTER_SELECTIVE_BLUR' => 'gd/gd.stub', 'IMG_FILTER_SMOOTH' => 'gd/gd.stub', 'IMG_FLIP_BOTH' => 'gd/gd.stub', 'IMG_FLIP_HORIZONTAL' => 'gd/gd.stub', 'IMG_FLIP_VERTICAL' => 'gd/gd.stub', 'IMG_GAUSSIAN' => 'gd/gd.stub', 'IMG_GD2_COMPRESSED' => 'gd/gd.stub', 'IMG_GD2_RAW' => 'gd/gd.stub', 'IMG_GENERALIZED_CUBIC' => 'gd/gd.stub', 'IMG_GIF' => 'gd/gd.stub', 'IMG_HAMMING' => 'gd/gd.stub', 'IMG_HANNING' => 'gd/gd.stub', 'IMG_HERMITE' => 'gd/gd.stub', 'IMG_JPEG' => 'gd/gd.stub', 'IMG_JPG' => 'gd/gd.stub', 'IMG_MITCHELL' => 'gd/gd.stub', 'IMG_NEAREST_NEIGHBOUR' => 'gd/gd.stub', 'IMG_PNG' => 'gd/gd.stub', 'IMG_POWER' => 'gd/gd.stub', 'IMG_QUADRATIC' => 'gd/gd.stub', 'IMG_SINC' => 'gd/gd.stub', 'IMG_TGA' => 'gd/gd.stub', 'IMG_TRIANGLE' => 'gd/gd.stub', 'IMG_WBMP' => 'gd/gd.stub', 'IMG_WEBP' => 'gd/gd.stub', 'IMG_WEBP_LOSSLESS' => 'gd/gd.stub', 'IMG_WEIGHTED4' => 'gd/gd.stub', 'IMG_XPM' => 'gd/gd.stub', 'INF' => 'standard/standard_defines.stub', 'INFO_ALL' => 'standard/standard_defines.stub', 'INFO_CONFIGURATION' => 'standard/standard_defines.stub', 'INFO_CREDITS' => 'standard/standard_defines.stub', 'INFO_ENVIRONMENT' => 'standard/standard_defines.stub', 'INFO_GENERAL' => 'standard/standard_defines.stub', 'INFO_LICENSE' => 'standard/standard_defines.stub', 'INFO_MODULES' => 'standard/standard_defines.stub', 'INFO_VARIABLES' => 'standard/standard_defines.stub', 'INI_ALL' => 'standard/standard_defines.stub', 'INI_PERDIR' => 'standard/standard_defines.stub', 'INI_SCANNER_NORMAL' => 'standard/standard_defines.stub', 'INI_SCANNER_RAW' => 'standard/standard_defines.stub', 'INI_SCANNER_TYPED' => 'standard/standard_defines.stub', 'INI_SYSTEM' => 'standard/standard_defines.stub', 'INI_USER' => 'standard/standard_defines.stub', 'INPUT_COOKIE' => 'filter/filter.stub', 'INPUT_ENV' => 'filter/filter.stub', 'INPUT_GET' => 'filter/filter.stub', 'INPUT_POST' => 'filter/filter.stub', 'INPUT_REQUEST' => 'filter/filter.stub', 'INPUT_SERVER' => 'filter/filter.stub', 'INPUT_SESSION' => 'filter/filter.stub', 'INTL_ICU_DATA_VERSION' => 'intl/intl.stub', 'INTL_ICU_VERSION' => 'intl/intl.stub', 'INTL_IDNA_VARIANT_2003' => 'intl/intl.stub', 'INTL_IDNA_VARIANT_UTS46' => 'intl/intl.stub', 'INTL_MAX_LOCALE_LEN' => 'intl/intl.stub', 'INT_CURR_SYMBOL' => 'standard/standard_defines.stub', 'INT_FRAC_DIGITS' => 'standard/standard_defines.stub', 'IN_ACCESS' => 'inotify/inotify.stub', 'IN_ALL_EVENTS' => 'inotify/inotify.stub', 'IN_ATTRIB' => 'inotify/inotify.stub', 'IN_CLOSE' => 'inotify/inotify.stub', 'IN_CLOSE_NOWRITE' => 'inotify/inotify.stub', 'IN_CLOSE_WRITE' => 'inotify/inotify.stub', 'IN_CREATE' => 'inotify/inotify.stub', 'IN_DELETE' => 'inotify/inotify.stub', 'IN_DELETE_SELF' => 'inotify/inotify.stub', 'IN_DONT_FOLLOW' => 'inotify/inotify.stub', 'IN_IGNORED' => 'inotify/inotify.stub', 'IN_ISDIR' => 'inotify/inotify.stub', 'IN_MASK_ADD' => 'inotify/inotify.stub', 'IN_MODIFY' => 'inotify/inotify.stub', 'IN_MOVE' => 'inotify/inotify.stub', 'IN_MOVED_FROM' => 'inotify/inotify.stub', 'IN_MOVED_TO' => 'inotify/inotify.stub', 'IN_MOVE_SELF' => 'inotify/inotify.stub', 'IN_ONESHOT' => 'inotify/inotify.stub', 'IN_ONLYDIR' => 'inotify/inotify.stub', 'IN_OPEN' => 'inotify/inotify.stub', 'IN_Q_OVERFLOW' => 'inotify/inotify.stub', 'IN_UNMOUNT' => 'inotify/inotify.stub', 'IPPROTO_IP' => 'sockets/sockets.stub', 'IPPROTO_IPV6' => 'sockets/sockets.stub', 'IPV6_HOPLIMIT' => 'sockets/sockets.stub', 'IPV6_MULTICAST_HOPS' => 'sockets/sockets.stub', 'IPV6_MULTICAST_IF' => 'sockets/sockets.stub', 'IPV6_MULTICAST_LOOP' => 'sockets/sockets.stub', 'IPV6_PKTINFO' => 'sockets/sockets.stub', 'IPV6_RECVHOPLIMIT' => 'sockets/sockets.stub', 'IPV6_RECVPKTINFO' => 'sockets/sockets.stub', 'IPV6_RECVTCLASS' => 'sockets/sockets.stub', 'IPV6_TCLASS' => 'sockets/sockets.stub', 'IPV6_UNICAST_HOPS' => 'sockets/sockets.stub', 'IPV6_V6ONLY' => 'sockets/sockets.stub', 'IP_BIND_ADDRESS_NO_PORT' => 'sockets/sockets.stub', 'IP_MTU_DISCOVER' => 'sockets/sockets.stub', 'IP_MULTICAST_IF' => 'sockets/sockets.stub', 'IP_MULTICAST_LOOP' => 'sockets/sockets.stub', 'IP_MULTICAST_TTL' => 'sockets/sockets.stub', 'IP_PMTUDISC_DO' => 'sockets/sockets.stub', 'IP_PMTUDISC_DONT' => 'sockets/sockets.stub', 'IP_PMTUDISC_INTERFACE' => 'sockets/sockets.stub', 'IP_PMTUDISC_OMIT' => 'sockets/sockets.stub', 'IP_PMTUDISC_PROBE' => 'sockets/sockets.stub', 'IP_PMTUDISC_WANT' => 'sockets/sockets.stub', 'ImageButton' => 'winbinder/winbinder.stub', 'InvisibleArea' => 'winbinder/winbinder.stub', 'JOB_QUEUE_PRIORITY_HIGH' => 'zend/zend_d.stub', 'JOB_QUEUE_PRIORITY_LOW' => 'zend/zend_d.stub', 'JOB_QUEUE_PRIORITY_NORMAL' => 'zend/zend_d.stub', 'JOB_QUEUE_PRIORITY_URGENT' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_COOKIE' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_ENV' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_FILES' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_GET' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_POST' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_RAW_POST' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_SERVER' => 'zend/zend_d.stub', 'JOB_QUEUE_SAVE_SESSION' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_EXECUTION_FAILED' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_IN_PROCESS' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_LOGICALLY_FAILED' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_SCHEDULED' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_SUCCESS' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_SUSPENDED' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_WAITING' => 'zend/zend_d.stub', 'JOB_QUEUE_STATUS_WAITING_PREDECESSOR' => 'zend/zend_d.stub', 'JSON_BIGINT_AS_STRING' => 'json/json.stub', 'JSON_ERROR_CTRL_CHAR' => 'json/json.stub', 'JSON_ERROR_DEPTH' => 'json/json.stub', 'JSON_ERROR_INF_OR_NAN' => 'json/json.stub', 'JSON_ERROR_INVALID_PROPERTY_NAME' => 'json/json.stub', 'JSON_ERROR_NONE' => 'json/json.stub', 'JSON_ERROR_NON_BACKED_ENUM' => 'json/json.stub', 'JSON_ERROR_RECURSION' => 'json/json.stub', 'JSON_ERROR_STATE_MISMATCH' => 'json/json.stub', 'JSON_ERROR_SYNTAX' => 'json/json.stub', 'JSON_ERROR_UNSUPPORTED_TYPE' => 'json/json.stub', 'JSON_ERROR_UTF16' => 'json/json.stub', 'JSON_ERROR_UTF8' => 'json/json.stub', 'JSON_FORCE_OBJECT' => 'json/json.stub', 'JSON_HEX_AMP' => 'json/json.stub', 'JSON_HEX_APOS' => 'json/json.stub', 'JSON_HEX_QUOT' => 'json/json.stub', 'JSON_HEX_TAG' => 'json/json.stub', 'JSON_INVALID_UTF8_IGNORE' => 'json/json.stub', 'JSON_INVALID_UTF8_SUBSTITUTE' => 'json/json.stub', 'JSON_NUMERIC_CHECK' => 'json/json.stub', 'JSON_OBJECT_AS_ARRAY' => 'json/json.stub', 'JSON_PARSER_NOTSTRICT' => 'json/json.stub', 'JSON_PARTIAL_OUTPUT_ON_ERROR' => 'json/json.stub', 'JSON_PRESERVE_ZERO_FRACTION' => 'json/json.stub', 'JSON_PRETTY_PRINT' => 'json/json.stub', 'JSON_THROW_ON_ERROR' => 'json/json.stub', 'JSON_UNESCAPED_LINE_TERMINATORS' => 'json/json.stub', 'JSON_UNESCAPED_SLASHES' => 'json/json.stub', 'JSON_UNESCAPED_UNICODE' => 'json/json.stub', 'LATT_HASCHILDREN' => 'imap/imap.stub', 'LATT_HASNOCHILDREN' => 'imap/imap.stub', 'LATT_MARKED' => 'imap/imap.stub', 'LATT_NOINFERIORS' => 'imap/imap.stub', 'LATT_NOSELECT' => 'imap/imap.stub', 'LATT_REFERRAL' => 'imap/imap.stub', 'LATT_UNMARKED' => 'imap/imap.stub', 'LC_ALL' => 'standard/standard_defines.stub', 'LC_COLLATE' => 'standard/standard_defines.stub', 'LC_CTYPE' => 'standard/standard_defines.stub', 'LC_MESSAGES' => 'standard/standard_defines.stub', 'LC_MONETARY' => 'standard/standard_defines.stub', 'LC_NUMERIC' => 'standard/standard_defines.stub', 'LC_TIME' => 'standard/standard_defines.stub', 'LDAP_CONTROL_ASSERT' => 'ldap/ldap.stub', 'LDAP_CONTROL_AUTHZID_REQUEST' => 'ldap/ldap.stub', 'LDAP_CONTROL_AUTHZID_RESPONSE' => 'ldap/ldap.stub', 'LDAP_CONTROL_DONTUSECOPY' => 'ldap/ldap.stub', 'LDAP_CONTROL_MANAGEDSAIT' => 'ldap/ldap.stub', 'LDAP_CONTROL_PAGEDRESULTS' => 'ldap/ldap.stub', 'LDAP_CONTROL_PASSWORDPOLICYREQUEST' => 'ldap/ldap.stub', 'LDAP_CONTROL_PASSWORDPOLICYRESPONSE' => 'ldap/ldap.stub', 'LDAP_CONTROL_POST_READ' => 'ldap/ldap.stub', 'LDAP_CONTROL_PRE_READ' => 'ldap/ldap.stub', 'LDAP_CONTROL_PROXY_AUTHZ' => 'ldap/ldap.stub', 'LDAP_CONTROL_SORTREQUEST' => 'ldap/ldap.stub', 'LDAP_CONTROL_SORTRESPONSE' => 'ldap/ldap.stub', 'LDAP_CONTROL_SUBENTRIES' => 'ldap/ldap.stub', 'LDAP_CONTROL_SYNC' => 'ldap/ldap.stub', 'LDAP_CONTROL_SYNC_DONE' => 'ldap/ldap.stub', 'LDAP_CONTROL_SYNC_STATE' => 'ldap/ldap.stub', 'LDAP_CONTROL_VALUESRETURNFILTER' => 'ldap/ldap.stub', 'LDAP_CONTROL_VLVREQUEST' => 'ldap/ldap.stub', 'LDAP_CONTROL_VLVRESPONSE' => 'ldap/ldap.stub', 'LDAP_CONTROL_X_DOMAIN_SCOPE' => 'ldap/ldap.stub', 'LDAP_CONTROL_X_EXTENDED_DN' => 'ldap/ldap.stub', 'LDAP_CONTROL_X_INCREMENTAL_VALUES' => 'ldap/ldap.stub', 'LDAP_CONTROL_X_PERMISSIVE_MODIFY' => 'ldap/ldap.stub', 'LDAP_CONTROL_X_SEARCH_OPTIONS' => 'ldap/ldap.stub', 'LDAP_CONTROL_X_TREE_DELETE' => 'ldap/ldap.stub', 'LDAP_DEREF_ALWAYS' => 'ldap/ldap.stub', 'LDAP_DEREF_FINDING' => 'ldap/ldap.stub', 'LDAP_DEREF_NEVER' => 'ldap/ldap.stub', 'LDAP_DEREF_SEARCHING' => 'ldap/ldap.stub', 'LDAP_ESCAPE_DN' => 'ldap/ldap.stub', 'LDAP_ESCAPE_FILTER' => 'ldap/ldap.stub', 'LDAP_EXOP_MODIFY_PASSWD' => 'ldap/ldap.stub', 'LDAP_EXOP_REFRESH' => 'ldap/ldap.stub', 'LDAP_EXOP_START_TLS' => 'ldap/ldap.stub', 'LDAP_EXOP_TURN' => 'ldap/ldap.stub', 'LDAP_EXOP_WHO_AM_I' => 'ldap/ldap.stub', 'LDAP_MODIFY_BATCH_ADD' => 'ldap/ldap.stub', 'LDAP_MODIFY_BATCH_ATTRIB' => 'ldap/ldap.stub', 'LDAP_MODIFY_BATCH_MODTYPE' => 'ldap/ldap.stub', 'LDAP_MODIFY_BATCH_REMOVE' => 'ldap/ldap.stub', 'LDAP_MODIFY_BATCH_REMOVE_ALL' => 'ldap/ldap.stub', 'LDAP_MODIFY_BATCH_REPLACE' => 'ldap/ldap.stub', 'LDAP_MODIFY_BATCH_VALUES' => 'ldap/ldap.stub', 'LDAP_OPT_CLIENT_CONTROLS' => 'ldap/ldap.stub', 'LDAP_OPT_DEBUG_LEVEL' => 'ldap/ldap.stub', 'LDAP_OPT_DEREF' => 'ldap/ldap.stub', 'LDAP_OPT_DIAGNOSTIC_MESSAGE' => 'ldap/ldap.stub', 'LDAP_OPT_ERROR_NUMBER' => 'ldap/ldap.stub', 'LDAP_OPT_ERROR_STRING' => 'ldap/ldap.stub', 'LDAP_OPT_HOST_NAME' => 'ldap/ldap.stub', 'LDAP_OPT_MATCHED_DN' => 'ldap/ldap.stub', 'LDAP_OPT_NETWORK_TIMEOUT' => 'ldap/ldap.stub', 'LDAP_OPT_PROTOCOL_VERSION' => 'ldap/ldap.stub', 'LDAP_OPT_REFERRALS' => 'ldap/ldap.stub', 'LDAP_OPT_RESTART' => 'ldap/ldap.stub', 'LDAP_OPT_SERVER_CONTROLS' => 'ldap/ldap.stub', 'LDAP_OPT_SIZELIMIT' => 'ldap/ldap.stub', 'LDAP_OPT_TIMELIMIT' => 'ldap/ldap.stub', 'LDAP_OPT_TIMEOUT' => 'ldap/ldap.stub', 'LDAP_OPT_X_KEEPALIVE_IDLE' => 'ldap/ldap.stub', 'LDAP_OPT_X_KEEPALIVE_INTERVAL' => 'ldap/ldap.stub', 'LDAP_OPT_X_KEEPALIVE_PROBES' => 'ldap/ldap.stub', 'LDAP_OPT_X_SASL_AUTHCID' => 'ldap/ldap.stub', 'LDAP_OPT_X_SASL_AUTHZID' => 'ldap/ldap.stub', 'LDAP_OPT_X_SASL_MECH' => 'ldap/ldap.stub', 'LDAP_OPT_X_SASL_NOCANON' => 'ldap/ldap.stub', 'LDAP_OPT_X_SASL_REALM' => 'ldap/ldap.stub', 'LDAP_OPT_X_SASL_USERNAME' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_ALLOW' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CACERTDIR' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CACERTFILE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CERTFILE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CIPHER_SUITE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CRLCHECK' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CRLFILE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CRL_ALL' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CRL_NONE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_CRL_PEER' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_DEMAND' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_DHFILE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_HARD' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_KEYFILE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_NEVER' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PACKAGE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_MAX' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_MIN' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_SSL2' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_SSL3' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_TLS1_0' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_TLS1_1' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_TLS1_2' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_PROTOCOL_TLS1_3' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_RANDOM_FILE' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_REQUIRE_CERT' => 'ldap/ldap.stub', 'LDAP_OPT_X_TLS_TRY' => 'ldap/ldap.stub', 'LEVELDB_NO_COMPRESSION' => 'leveldb/LevelDB.stub', 'LEVELDB_SNAPPY_COMPRESSION' => 'leveldb/LevelDB.stub', 'LIBEXSLT_DOTTED_VERSION' => 'xsl/xsl.stub', 'LIBEXSLT_VERSION' => 'xsl/xsl.stub', 'LIBXML_BIGLINES' => 'libxml/libxml.stub', 'LIBXML_COMPACT' => 'libxml/libxml.stub', 'LIBXML_DOTTED_VERSION' => 'libxml/libxml.stub', 'LIBXML_DTDATTR' => 'libxml/libxml.stub', 'LIBXML_DTDLOAD' => 'libxml/libxml.stub', 'LIBXML_DTDVALID' => 'libxml/libxml.stub', 'LIBXML_ERR_ERROR' => 'libxml/libxml.stub', 'LIBXML_ERR_FATAL' => 'libxml/libxml.stub', 'LIBXML_ERR_NONE' => 'libxml/libxml.stub', 'LIBXML_ERR_WARNING' => 'libxml/libxml.stub', 'LIBXML_HTML_NODEFDTD' => 'libxml/libxml.stub', 'LIBXML_HTML_NOIMPLIED' => 'libxml/libxml.stub', 'LIBXML_LOADED_VERSION' => 'libxml/libxml.stub', 'LIBXML_NOBLANKS' => 'libxml/libxml.stub', 'LIBXML_NOCDATA' => 'libxml/libxml.stub', 'LIBXML_NOEMPTYTAG' => 'libxml/libxml.stub', 'LIBXML_NOENT' => 'libxml/libxml.stub', 'LIBXML_NOERROR' => 'libxml/libxml.stub', 'LIBXML_NONET' => 'libxml/libxml.stub', 'LIBXML_NOWARNING' => 'libxml/libxml.stub', 'LIBXML_NOXMLDECL' => 'libxml/libxml.stub', 'LIBXML_NSCLEAN' => 'libxml/libxml.stub', 'LIBXML_PARSEHUGE' => 'libxml/libxml.stub', 'LIBXML_PEDANTIC' => 'libxml/libxml.stub', 'LIBXML_RECOVER' => 'libxml/libxml.stub', 'LIBXML_SCHEMA_CREATE' => 'libxml/libxml.stub', 'LIBXML_VERSION' => 'libxml/libxml.stub', 'LIBXML_XINCLUDE' => 'libxml/libxml.stub', 'LIBXSLT_DOTTED_VERSION' => 'xsl/xsl.stub', 'LIBXSLT_VERSION' => 'xsl/xsl.stub', 'LIBZSTD_VERSION_NUMBER' => 'zstd/zstd.stub', 'LIBZSTD_VERSION_STRING' => 'zstd/zstd.stub', 'LIGHTGRAY' => 'winbinder/winbinder.stub', 'LOCK_EX' => 'standard/standard_defines.stub', 'LOCK_NB' => 'standard/standard_defines.stub', 'LOCK_SH' => 'standard/standard_defines.stub', 'LOCK_UN' => 'standard/standard_defines.stub', 'LOG_ALERT' => 'standard/standard_defines.stub', 'LOG_AUTH' => 'standard/standard_defines.stub', 'LOG_AUTHPRIV' => 'standard/standard_defines.stub', 'LOG_CONS' => 'standard/standard_defines.stub', 'LOG_CRIT' => 'standard/standard_defines.stub', 'LOG_CRON' => 'standard/standard_defines.stub', 'LOG_DAEMON' => 'standard/standard_defines.stub', 'LOG_DEBUG' => 'standard/standard_defines.stub', 'LOG_EMERG' => 'standard/standard_defines.stub', 'LOG_ERR' => 'standard/standard_defines.stub', 'LOG_INFO' => 'standard/standard_defines.stub', 'LOG_KERN' => 'standard/standard_defines.stub', 'LOG_LOCAL0' => 'standard/standard_defines.stub', 'LOG_LOCAL1' => 'standard/standard_defines.stub', 'LOG_LOCAL2' => 'standard/standard_defines.stub', 'LOG_LOCAL3' => 'standard/standard_defines.stub', 'LOG_LOCAL4' => 'standard/standard_defines.stub', 'LOG_LOCAL5' => 'standard/standard_defines.stub', 'LOG_LOCAL6' => 'standard/standard_defines.stub', 'LOG_LOCAL7' => 'standard/standard_defines.stub', 'LOG_LPR' => 'standard/standard_defines.stub', 'LOG_MAIL' => 'standard/standard_defines.stub', 'LOG_NDELAY' => 'standard/standard_defines.stub', 'LOG_NEWS' => 'standard/standard_defines.stub', 'LOG_NOTICE' => 'standard/standard_defines.stub', 'LOG_NOWAIT' => 'standard/standard_defines.stub', 'LOG_ODELAY' => 'standard/standard_defines.stub', 'LOG_PERROR' => 'standard/standard_defines.stub', 'LOG_PID' => 'standard/standard_defines.stub', 'LOG_SYSLOG' => 'standard/standard_defines.stub', 'LOG_USER' => 'standard/standard_defines.stub', 'LOG_UUCP' => 'standard/standard_defines.stub', 'LOG_WARNING' => 'standard/standard_defines.stub', 'Label' => 'winbinder/winbinder.stub', 'ListBox' => 'winbinder/winbinder.stub', 'ListView' => 'winbinder/winbinder.stub', 'MAGENTA' => 'winbinder/winbinder.stub', 'MAILPARSE_EXTRACT_OUTPUT' => 'mailparse/mailparse.stub', 'MAILPARSE_EXTRACT_RETURN' => 'mailparse/mailparse.stub', 'MAILPARSE_EXTRACT_STREAM' => 'mailparse/mailparse.stub', 'MB_CASE_FOLD' => 'mbstring/mbstring.stub', 'MB_CASE_FOLD_SIMPLE' => 'mbstring/mbstring.stub', 'MB_CASE_LOWER' => 'mbstring/mbstring.stub', 'MB_CASE_LOWER_SIMPLE' => 'mbstring/mbstring.stub', 'MB_CASE_TITLE' => 'mbstring/mbstring.stub', 'MB_CASE_TITLE_SIMPLE' => 'mbstring/mbstring.stub', 'MB_CASE_UPPER' => 'mbstring/mbstring.stub', 'MB_CASE_UPPER_SIMPLE' => 'mbstring/mbstring.stub', 'MB_ONIGURUMA_VERSION' => 'mbstring/mbstring.stub', 'MB_OVERLOAD_MAIL' => 'mbstring/mbstring.stub', 'MB_OVERLOAD_REGEX' => 'mbstring/mbstring.stub', 'MB_OVERLOAD_STRING' => 'mbstring/mbstring.stub', 'MCAST_BLOCK_SOURCE' => 'sockets/sockets.stub', 'MCAST_JOIN_GROUP' => 'sockets/sockets.stub', 'MCAST_JOIN_SOURCE_GROUP' => 'sockets/sockets.stub', 'MCAST_LEAVE_GROUP' => 'sockets/sockets.stub', 'MCAST_LEAVE_SOURCE_GROUP' => 'sockets/sockets.stub', 'MCAST_UNBLOCK_SOURCE' => 'sockets/sockets.stub', 'MCRYPT_3DES' => 'mcrypt/mcrypt.stub', 'MCRYPT_ARCFOUR' => 'mcrypt/mcrypt.stub', 'MCRYPT_ARCFOUR_IV' => 'mcrypt/mcrypt.stub', 'MCRYPT_BLOWFISH' => 'mcrypt/mcrypt.stub', 'MCRYPT_BLOWFISH_COMPAT' => 'mcrypt/mcrypt.stub', 'MCRYPT_CAST_128' => 'mcrypt/mcrypt.stub', 'MCRYPT_CAST_256' => 'mcrypt/mcrypt.stub', 'MCRYPT_CRYPT' => 'mcrypt/mcrypt.stub', 'MCRYPT_DECRYPT' => 'mcrypt/mcrypt.stub', 'MCRYPT_DES' => 'mcrypt/mcrypt.stub', 'MCRYPT_DES_COMPAT' => 'mcrypt/mcrypt.stub', 'MCRYPT_DEV_RANDOM' => 'mcrypt/mcrypt.stub', 'MCRYPT_DEV_URANDOM' => 'mcrypt/mcrypt.stub', 'MCRYPT_ENCRYPT' => 'mcrypt/mcrypt.stub', 'MCRYPT_ENIGNA' => 'mcrypt/mcrypt.stub', 'MCRYPT_GOST' => 'mcrypt/mcrypt.stub', 'MCRYPT_IDEA' => 'mcrypt/mcrypt.stub', 'MCRYPT_LOKI97' => 'mcrypt/mcrypt.stub', 'MCRYPT_MARS' => 'mcrypt/mcrypt.stub', 'MCRYPT_MODE_CBC' => 'mcrypt/mcrypt.stub', 'MCRYPT_MODE_CFB' => 'mcrypt/mcrypt.stub', 'MCRYPT_MODE_ECB' => 'mcrypt/mcrypt.stub', 'MCRYPT_MODE_NOFB' => 'mcrypt/mcrypt.stub', 'MCRYPT_MODE_OFB' => 'mcrypt/mcrypt.stub', 'MCRYPT_MODE_STREAM' => 'mcrypt/mcrypt.stub', 'MCRYPT_PANAMA' => 'mcrypt/mcrypt.stub', 'MCRYPT_RAND' => 'mcrypt/mcrypt.stub', 'MCRYPT_RC2' => 'mcrypt/mcrypt.stub', 'MCRYPT_RC4' => 'mcrypt/mcrypt.stub', 'MCRYPT_RC6' => 'mcrypt/mcrypt.stub', 'MCRYPT_RC6_128' => 'mcrypt/mcrypt.stub', 'MCRYPT_RC6_192' => 'mcrypt/mcrypt.stub', 'MCRYPT_RC6_256' => 'mcrypt/mcrypt.stub', 'MCRYPT_RIJNDAEL_128' => 'mcrypt/mcrypt.stub', 'MCRYPT_RIJNDAEL_192' => 'mcrypt/mcrypt.stub', 'MCRYPT_RIJNDAEL_256' => 'mcrypt/mcrypt.stub', 'MCRYPT_SAFER128' => 'mcrypt/mcrypt.stub', 'MCRYPT_SAFER64' => 'mcrypt/mcrypt.stub', 'MCRYPT_SAFERPLUS' => 'mcrypt/mcrypt.stub', 'MCRYPT_SERPENT' => 'mcrypt/mcrypt.stub', 'MCRYPT_SERPENT_128' => 'mcrypt/mcrypt.stub', 'MCRYPT_SERPENT_192' => 'mcrypt/mcrypt.stub', 'MCRYPT_SERPENT_256' => 'mcrypt/mcrypt.stub', 'MCRYPT_SKIPJACK' => 'mcrypt/mcrypt.stub', 'MCRYPT_THREEWAY' => 'mcrypt/mcrypt.stub', 'MCRYPT_TRIPLEDES' => 'mcrypt/mcrypt.stub', 'MCRYPT_TWOFISH' => 'mcrypt/mcrypt.stub', 'MCRYPT_WAKE' => 'mcrypt/mcrypt.stub', 'MCRYPT_XTEA' => 'mcrypt/mcrypt.stub', 'MEMCACHE_COMPRESSED' => 'memcache/memcache.stub', 'MEMCACHE_HAVE_SESSION' => 'memcache/memcache.stub', 'MEMCACHE_USER1' => 'memcache/memcache.stub', 'MEMCACHE_USER2' => 'memcache/memcache.stub', 'MEMCACHE_USER3' => 'memcache/memcache.stub', 'MEMCACHE_USER4' => 'memcache/memcache.stub', 'MESSAGEPACK_OPT_PHPONLY' => 'msgpack/msgpack.stub', 'MHASH_ADLER32' => 'hash/hash.stub', 'MHASH_CRC32' => 'hash/hash.stub', 'MHASH_CRC32B' => 'hash/hash.stub', 'MHASH_CRC32C' => 'hash/hash.stub', 'MHASH_FNV132' => 'hash/hash.stub', 'MHASH_FNV164' => 'hash/hash.stub', 'MHASH_FNV1A32' => 'hash/hash.stub', 'MHASH_FNV1A64' => 'hash/hash.stub', 'MHASH_GOST' => 'hash/hash.stub', 'MHASH_HAVAL128' => 'hash/hash.stub', 'MHASH_HAVAL160' => 'hash/hash.stub', 'MHASH_HAVAL192' => 'hash/hash.stub', 'MHASH_HAVAL224' => 'hash/hash.stub', 'MHASH_HAVAL256' => 'hash/hash.stub', 'MHASH_JOAAT' => 'hash/hash.stub', 'MHASH_MD2' => 'hash/hash.stub', 'MHASH_MD4' => 'hash/hash.stub', 'MHASH_MD5' => 'hash/hash.stub', 'MHASH_MURMUR3A' => 'hash/hash.stub', 'MHASH_MURMUR3C' => 'hash/hash.stub', 'MHASH_MURMUR3F' => 'hash/hash.stub', 'MHASH_RIPEMD128' => 'hash/hash.stub', 'MHASH_RIPEMD160' => 'hash/hash.stub', 'MHASH_RIPEMD256' => 'hash/hash.stub', 'MHASH_RIPEMD320' => 'hash/hash.stub', 'MHASH_SHA1' => 'hash/hash.stub', 'MHASH_SHA224' => 'hash/hash.stub', 'MHASH_SHA256' => 'hash/hash.stub', 'MHASH_SHA384' => 'hash/hash.stub', 'MHASH_SHA512' => 'hash/hash.stub', 'MHASH_SNEFRU256' => 'hash/hash.stub', 'MHASH_TIGER' => 'hash/hash.stub', 'MHASH_TIGER128' => 'hash/hash.stub', 'MHASH_TIGER160' => 'hash/hash.stub', 'MHASH_WHIRLPOOL' => 'hash/hash.stub', 'MHASH_XXH128' => 'hash/hash.stub', 'MHASH_XXH3' => 'hash/hash.stub', 'MHASH_XXH32' => 'hash/hash.stub', 'MHASH_XXH64' => 'hash/hash.stub', 'MING_NEW' => 'ming/ming.stub', 'MING_ZLIB' => 'ming/ming.stub', 'MK_E_UNAVAILABLE' => 'com_dotnet/com_dotnet.stub', 'MONGODB_STABILITY' => 'mongodb/mongodb.stub', 'MONGODB_VERSION' => 'mongodb/mongodb.stub', 'MON_1' => 'standard/standard_defines.stub', 'MON_10' => 'standard/standard_defines.stub', 'MON_11' => 'standard/standard_defines.stub', 'MON_12' => 'standard/standard_defines.stub', 'MON_2' => 'standard/standard_defines.stub', 'MON_3' => 'standard/standard_defines.stub', 'MON_4' => 'standard/standard_defines.stub', 'MON_5' => 'standard/standard_defines.stub', 'MON_6' => 'standard/standard_defines.stub', 'MON_7' => 'standard/standard_defines.stub', 'MON_8' => 'standard/standard_defines.stub', 'MON_9' => 'standard/standard_defines.stub', 'MON_DECIMAL_POINT' => 'standard/standard_defines.stub', 'MON_GROUPING' => 'standard/standard_defines.stub', 'MON_THOUSANDS_SEP' => 'standard/standard_defines.stub', 'MQSERIES_MQACT_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_AIX' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_BATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_BROKER' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_CHANNEL_INITIATOR' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_CICS' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_CICS_BRIDGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_CICS_VSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_DEFAULT' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_DOS' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_DQM' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_GUARDIAN' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_IMS' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_IMS_BRIDGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_JAVA' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_MCAST_PUBLISH' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_MVS' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_NOTES_AGENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_NO_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_NSK' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_OPEN_TP1' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_OS2' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_OS390' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_OS400' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_QMGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_QMGR_PUBLISH' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_RRS_BATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_SIB' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_SYSTEM_EXTENSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_TPF' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_UNIX' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_UNKNOWN' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_USER' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_USER_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_USER_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_VM' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_VMS' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_VOS' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_WINDOWS' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_WINDOWS_NT' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_WLM' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_XCF' => 'mqseries/mqseries.stub', 'MQSERIES_MQAT_ZOS' => 'mqseries/mqseries.stub', 'MQSERIES_MQBO_CURRENT_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQBO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQBO_VERSION_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_ADMIN_TOPIC_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_ALTERATION_DATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_ALTERATION_TIME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_APPL_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_AUTH_INFO_CONN_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_AUTH_INFO_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_AUTH_INFO_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_AUTH_INFO_OCSP_URL' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_AUTO_REORG_CATALOG' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_AUTO_REORG_START_TIME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_BACKOUT_REQ_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_BASE_OBJECT_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_BASE_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_BATCH_INTERFACE_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CF_STRUC_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CF_STRUC_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CHANNEL_AUTO_DEF_EXIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CHILD' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CHINIT_SERVICE_PARM' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CHLAUTH_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CICS_FILE_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUSTER_DATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUSTER_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUSTER_NAMELIST' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUSTER_Q_MGR_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUSTER_TIME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUSTER_WORKLOAD_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUSTER_WORKLOAD_EXIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CLUS_CHL_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_COMMAND_INPUT_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_COMMAND_REPLY_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_COMM_INFO_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_COMM_INFO_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CREATION_DATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CREATION_TIME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_CUSTOM' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_DEAD_LETTER_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_DEF_XMIT_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_DNS_GROUP' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_ENV_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_IGQ_USER_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_INITIATION_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_INSTALLATION_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_INSTALLATION_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_INSTALLATION_PATH' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_LAST_USED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_LDAP_PASSWORD' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_LDAP_USER_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_LU62_ARM_SUFFIX' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_LU_GROUP_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_LU_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_MODEL_DURABLE_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_MODEL_NON_DURABLE_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_MONITOR_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_NAMELIST_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_NAMELIST_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_NAMES' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_PARENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_PASS_TICKET_APPL' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_POLICY_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_PROCESS_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_PROCESS_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_QSG_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_Q_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_Q_MGR_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_Q_MGR_IDENTIFIER' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_Q_MGR_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_RECIPIENT_DN' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_REMOTE_Q_MGR_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_REMOTE_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_REPOSITORY_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_REPOSITORY_NAMELIST' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_RESUME_DATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_RESUME_TIME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SERVICE_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SERVICE_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SERVICE_START_ARGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SERVICE_START_COMMAND' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SERVICE_STOP_ARGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SERVICE_STOP_COMMAND' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SIGNER_DN' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SSL_CRL_NAMELIST' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SSL_CRYPTO_HARDWARE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SSL_KEY_LIBRARY' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SSL_KEY_MEMBER' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SSL_KEY_REPOSITORY' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_STDERR_DESTINATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_STDOUT_DESTINATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_STORAGE_CLASS' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_STORAGE_CLASS_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_SYSTEM_LOG_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TCP_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TOPIC_DESC' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TOPIC_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TOPIC_STRING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TOPIC_STRING_FILTER' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TPIPE_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TRIGGER_CHANNEL_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TRIGGER_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TRIGGER_PROGRAM_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TRIGGER_TERM_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_TRIGGER_TRANS_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_USER_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_USER_LIST' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_XCF_GROUP_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_XCF_MEMBER_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_XMIT_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_XR_SSL_CIPHER_SUITES' => 'mqseries/mqseries.stub', 'MQSERIES_MQCA_XR_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQCCSI_APPL' => 'mqseries/mqseries.stub', 'MQSERIES_MQCCSI_AS_PUBLISHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCCSI_DEFAULT' => 'mqseries/mqseries.stub', 'MQSERIES_MQCCSI_EMBEDDED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCCSI_INHERIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQCCSI_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQCCSI_UNDEFINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCC_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCC_OK' => 'mqseries/mqseries.stub', 'MQSERIES_MQCC_UNKNOWN' => 'mqseries/mqseries.stub', 'MQSERIES_MQCC_WARNING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCI_NEW_SESSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQCI_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ACCOUNTING_MQI_DISABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ACCOUNTING_MQI_ENABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ACCOUNTING_Q_DISABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ACCOUNTING_Q_ENABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ACTIVITY_TRACE_DISABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ACTIVITY_TRACE_ENABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ALL_CONVS_SHARE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_CD_FOR_OUTPUT_ONLY' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_CLIENT_BINDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_CURRENT_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_FASTPATH_BINDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_HANDLE_SHARE_BLOCK' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_HANDLE_SHARE_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_HANDLE_SHARE_NO_BLOCK' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_ISOLATED_BINDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_LOCAL_BINDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_NO_CONV_SHARING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_RECONNECT' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_RECONNECT_AS_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_RECONNECT_DISABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_RECONNECT_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_RESTRICT_CONN_TAG_QSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_RESTRICT_CONN_TAG_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_SERIALIZE_CONN_TAG_QSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_SERIALIZE_CONN_TAG_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_SHARED_BINDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_STANDARD_BINDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_USE_CD_SELECTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_VERSION_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_VERSION_2' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_VERSION_3' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_VERSION_4' => 'mqseries/mqseries.stub', 'MQSERIES_MQCNO_VERSION_5' => 'mqseries/mqseries.stub', 'MQSERIES_MQCO_DELETE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCO_DELETE_PURGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCO_IMMEDIATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCO_KEEP_SUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQCO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCO_QUIESCE' => 'mqseries/mqseries.stub', 'MQSERIES_MQCO_REMOVE_SUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQEC_CONNECTION_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQEC_MSG_ARRIVED' => 'mqseries/mqseries.stub', 'MQSERIES_MQEC_Q_MGR_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQEC_WAIT_CANCELED' => 'mqseries/mqseries.stub', 'MQSERIES_MQEC_WAIT_INTERVAL_EXPIRED' => 'mqseries/mqseries.stub', 'MQSERIES_MQEI_UNLIMITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_AS_PUBLISHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_DECIMAL_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_DECIMAL_NORMAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_DECIMAL_REVERSED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_DECIMAL_UNDEFINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_FLOAT_IEEE_NORMAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_FLOAT_IEEE_REVERSED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_FLOAT_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_FLOAT_S390' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_FLOAT_TNS' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_FLOAT_UNDEFINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_INTEGER_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_INTEGER_NORMAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_INTEGER_REVERSED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_INTEGER_UNDEFINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_NATIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_NORMAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_RESERVED_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_REVERSED' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_S390' => 'mqseries/mqseries.stub', 'MQSERIES_MQENC_TNS' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_ACTIVITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_APPL_CANNOT_BE_STARTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_APPL_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_APPL_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_APPL_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_BIND_OPEN_CLUSRCVR_DEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_BUFFER_OVERFLOW' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CHANNEL_COMPLETED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CHANNEL_FAIL' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CHANNEL_FAIL_RETRY' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_APPL_ABENDED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_APPL_NOT_STARTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_BRIDGE_FAILURE' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_CCSID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_CIH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_COMMAREA_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_CORREL_ID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_DLQ_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_ENCODING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_INTERNAL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_NOT_AUTHORIZED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_UOW_BACKED_OUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_CICS_UOW_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_COA' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_COD' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_DATA_LENGTH_NEGATIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_DATA_LENGTH_TOO_BIG' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_DATA_LENGTH_ZERO' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_EXPIRATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_IIH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_IMS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_IMS_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_IMS_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_IMS_NACK_1A_REASON_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_IMS_NACK_1A_REASON_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_LENGTH_OFF_BY_ONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_MAX_ACTIVITIES' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_MSG_SCOPE_MISMATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_NAN' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_NOT_AUTHORIZED_FOR_IMS' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_NOT_A_GROUPUR_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_NOT_A_REPOSITORY_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_NOT_DELIVERED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_NOT_FORWARDED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_PAN' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_PUBLICATIONS_ON_REQUEST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_QUIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_SELECTOR_MISMATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_STOPPED_BY_CHAD_EXIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_STOPPED_BY_MSG_EXIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_STOPPED_BY_PUBSUB_EXIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_SUBSCRIBER_IS_PUBLISHER' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_SYSTEM_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_SYSTEM_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_TM_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_UNSUPPORTED_DELIVERY' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_UNSUPPORTED_FORWARDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQFB_XMIT_Q_MSG_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_ADMIN' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_CHANNEL_COMPLETED' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_CICS' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_COMMAND_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_COMMAND_2' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_DEAD_LETTER_HEADER' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_DIST_HEADER' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_EMBEDDED_PCF' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_IMS' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_IMS_VAR_STRING' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_MD_EXTENSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_PCF' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_REF_MSG_HEADER' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_RF_HEADER' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_RF_HEADER_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_RF_HEADER_2' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_STRING' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_TRIGGER' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_WORK_INFO_HEADER' => 'mqseries/mqseries.stub', 'MQSERIES_MQFMT_XMIT_Q_HEADER' => 'mqseries/mqseries.stub', 'MQSERIES_MQGI_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_ACCEPT_TRUNCATED_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_ALL_MSGS_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_ALL_SEGMENTS_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_BROWSE_CO_OP' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_BROWSE_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_BROWSE_HANDLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_BROWSE_MSG_UNDER_CURSOR' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_BROWSE_NEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_COMPLETE_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_CONVERT' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_CURRENT_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_FAIL_IF_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_LOCK' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_LOGICAL_ORDER' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_MARK_BROWSE_CO_OP' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_MARK_BROWSE_HANDLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_MARK_SKIP_BACKOUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_MSG_UNDER_CURSOR' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_NO_PROPERTIES' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_NO_SYNCPOINT' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_NO_WAIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_PROPERTIES_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_PROPERTIES_COMPATIBILITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_PROPERTIES_FORCE_MQRFH2' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_PROPERTIES_IN_HANDLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_SET_SIGNAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_SYNCPOINT' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_SYNCPOINT_IF_PERSISTENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_UNLOCK' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_UNMARKED_BROWSE_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_UNMARK_BROWSE_CO_OP' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_UNMARK_BROWSE_HANDLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_VERSION_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_VERSION_2' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_VERSION_3' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_VERSION_4' => 'mqseries/mqseries.stub', 'MQSERIES_MQGMO_WAIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACCOUNTING_CONN_OVERRIDE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACCOUNTING_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACCOUNTING_MQI' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACCOUNTING_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACTIVE_CHANNELS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACTIVITY_CONN_OVERRIDE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACTIVITY_RECORDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ACTIVITY_TRACE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ADOPTNEWMCA_CHECK' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ADOPTNEWMCA_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ADOPTNEWMCA_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_APPL_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ARCHIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_AUTHORITY_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_AUTH_INFO_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_AUTO_REORGANIZATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_AUTO_REORG_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_BACKOUT_THRESHOLD' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_BASE_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_BATCH_INTERFACE_AUTO' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_BRIDGE_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CERT_VAL_POLICY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_CFCONLOS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_LEVEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_OFFLDUSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_OFFLOAD' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_OFFLOAD_THRESHOLD1' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_OFFLOAD_THRESHOLD2' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_OFFLOAD_THRESHOLD3' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_RECAUTO' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_RECOVER' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CF_SMDS_BUFFERS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHANNEL_AUTO_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHANNEL_AUTO_DEF_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHANNEL_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHINIT_ADAPTERS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHINIT_CONTROL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHINIT_DISPATCHERS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHINIT_TRACE_AUTO_START' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHINIT_TRACE_TABLE_SIZE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CHLAUTH_RECORDS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CLUSTER_Q_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CLUSTER_WORKLOAD_LENGTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CLWL_MRU_CHANNELS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CLWL_Q_PRIORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CLWL_Q_RANK' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CLWL_USEQ' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CMD_SERVER_AUTO' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CMD_SERVER_CONTROL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CMD_SERVER_CONVERT_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CMD_SERVER_DLQ_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CODED_CHAR_SET_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_COMMAND_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_COMMAND_LEVEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_COMM_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_COMM_INFO_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CONFIGURATION_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CPI_LEVEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_CURRENT_Q_DEPTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEFINITION_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEF_BIND' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEF_CLUSTER_XMIT_Q_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEF_INPUT_OPEN_OPTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEF_PERSISTENCE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEF_PRIORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEF_PUT_RESPONSE_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DEF_READ_AHEAD' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DIST_LISTS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DNS_WLM' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_DURABLE_SUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_ENCRYPTION_ALGORITHM' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_EXPIRY_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_GROUP_UR' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_HARDEN_GET_BACKOUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_HIGH_Q_DEPTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_IGQ_PUT_AUTHORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_INDEX_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_INHIBIT_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_INHIBIT_GET' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_INHIBIT_PUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_INHIBIT_PUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_INHIBIT_SUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_INTRA_GROUP_QUEUING' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_IP_ADDRESS_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_LISTENER_PORT_NUMBER' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_LISTENER_TIMER' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_LOCAL_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_LOGGER_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_LU62_CHANNELS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MASTER_ADMIN' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_CHANNELS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_CLIENTS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_GLOBAL_LOCKS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_HANDLES' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_LOCAL_LOCKS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_MSG_LENGTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_OPEN_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_PRIORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_PROPERTIES_LENGTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_Q_DEPTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_Q_TRIGGERS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_RECOVERY_TASKS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_RESPONSES' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MAX_UNCOMMITTED_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MCAST_BRIDGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MONITORING_AUTO_CLUSSDR' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MONITORING_CHANNEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MONITORING_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MONITOR_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MSG_DELIVERY_SEQUENCE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MSG_DEQ_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MSG_ENQ_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MSG_MARK_BROWSE_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_MULTICAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_NAMELIST_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_NAME_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_NPM_CLASS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_NPM_DELIVERY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_OPEN_INPUT_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_OPEN_OUTPUT_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_OUTBOUND_PORT_MAX' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_OUTBOUND_PORT_MIN' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PAGESET_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PERFORMANCE_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PLATFORM' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PM_DELIVERY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_POLICY_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PROPERTY_CONTROL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PROT_POLICY_CAPABILITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PROXY_SUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUBSUB_CLUSTER' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUBSUB_MAXMSG_RETRY_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUBSUB_MODE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUBSUB_NP_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUBSUB_NP_RESP' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUBSUB_SYNC_PT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUB_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_PUB_SCOPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMGR_CFCONLOS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CONS_COMMS_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CONS_CRITICAL_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CONS_ERROR_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CONS_INFO_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CONS_REORG_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CONS_SYSTEM_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CONS_WARNING_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_CSMT_ON_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_INTERNAL_DUMP' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_LOG_COMMS_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_LOG_CRITICAL_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_LOG_ERROR_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_LOG_INFO_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_LOG_REORG_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_LOG_SYSTEM_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_LOG_WARNING_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_TRACE_COMMS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_TRACE_CONVERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_TRACE_MQI_CALLS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_TRACE_REORG' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QMOPT_TRACE_SYSTEM' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_QSG_DISP' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_DEPTH_HIGH_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_DEPTH_HIGH_LIMIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_DEPTH_LOW_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_DEPTH_LOW_LIMIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_DEPTH_MAX_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_SERVICE_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_SERVICE_INTERVAL_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_Q_USERS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_READ_AHEAD' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_RECEIVE_TIMEOUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_RECEIVE_TIMEOUT_MIN' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_RECEIVE_TIMEOUT_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_REMOTE_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_RESPONSE_RESTART_POINT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_RETENTION_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SCOPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SECURITY_CASE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SERVICE_CONTROL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SERVICE_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SHAREABILITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SHARED_Q_Q_MGR_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SIGNATURE_ALGORITHM' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SSL_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SSL_FIPS_REQUIRED' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SSL_RESET_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SSL_TASKS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_START_STOP_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_STATISTICS_AUTO_CLUSSDR' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_STATISTICS_CHANNEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_STATISTICS_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_STATISTICS_MQI' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_STATISTICS_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SUB_CONFIGURATION_EVENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SUB_COUNT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SUB_SCOPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SUITE_B_STRENGTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_SYNCPOINT' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TCP_CHANNELS' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TCP_KEEP_ALIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TCP_STACK_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TIME_SINCE_RESET' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TOLERATE_UNPROTECTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TOPIC_DEF_PERSISTENCE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TOPIC_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TRACE_ROUTE_RECORDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TREE_LIFE_TIME' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TRIGGER_CONTROL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TRIGGER_DEPTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TRIGGER_INTERVAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TRIGGER_MSG_PRIORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TRIGGER_RESTART' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_TRIGGER_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_UR_DISP' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_USAGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_USER_LIST' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_USE_DEAD_LETTER_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_WILDCARD_OPERATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQIA_XR_CAPABILITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQMD_CURRENT_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQMD_VERSION_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQMD_VERSION_2' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_ACCEPT_UNSUP_IF_XMIT_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_ACCEPT_UNSUP_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_LAST_MSG_IN_GROUP' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_LAST_SEGMENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_MSG_IN_GROUP' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_REJECT_UNSUP_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_SEGMENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_SEGMENTATION_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQMF_SEGMENTATION_INHIBITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQMI_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQMO_MATCH_CORREL_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQMO_MATCH_GROUP_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQMO_MATCH_MSG_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQMO_MATCH_MSG_SEQ_NUMBER' => 'mqseries/mqseries.stub', 'MQSERIES_MQMO_MATCH_MSG_TOKEN' => 'mqseries/mqseries.stub', 'MQSERIES_MQMO_MATCH_OFFSET' => 'mqseries/mqseries.stub', 'MQSERIES_MQMO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQMTOK_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_APPL_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_APPL_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_DATAGRAM' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_MQE_FIELDS' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_MQE_FIELDS_FROM_MQE' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_REPLY' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_REPORT' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_REQUEST' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_SYSTEM_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQMT_SYSTEM_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQOD_CURRENT_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQOD_VERSION_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQOD_VERSION_2' => 'mqseries/mqseries.stub', 'MQSERIES_MQOD_VERSION_3' => 'mqseries/mqseries.stub', 'MQSERIES_MQOD_VERSION_4' => 'mqseries/mqseries.stub', 'MQSERIES_MQOL_UNDEFINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_ALTERNATE_USER_AUTHORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_BIND_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_BIND_NOT_FIXED' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_BIND_ON_GROUP' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_BIND_ON_OPEN' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_BROWSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_CO_OP' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_FAIL_IF_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_INPUT_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_INPUT_EXCLUSIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_INPUT_SHARED' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_INQUIRE' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_NO_MULTICAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_NO_READ_AHEAD' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_OUTPUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_PASS_ALL_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_PASS_IDENTITY_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_READ_AHEAD' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_READ_AHEAD_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_RESOLVE_LOCAL_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_RESOLVE_LOCAL_TOPIC' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_SAVE_ALL_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_SET' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_SET_ALL_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQOO_SET_IDENTITY_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_AUTH_INFO' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_CF_STRUC' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_CHANNEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_COMM_INFO' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_LISTENER' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_NAMELIST' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_PROCESS' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_RESERVED_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_SERVICE' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_STORAGE_CLASS' => 'mqseries/mqseries.stub', 'MQSERIES_MQOT_TOPIC' => 'mqseries/mqseries.stub', 'MQSERIES_MQPER_NOT_PERSISTENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPER_PERSISTENCE_AS_PARENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPER_PERSISTENCE_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQPER_PERSISTENCE_AS_TOPIC_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQPER_PERSISTENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_ALTERNATE_USER_AUTHORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_ASYNC_RESPONSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_CURRENT_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_DEFAULT_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_FAIL_IF_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_LOGICAL_ORDER' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_MD_FOR_OUTPUT_ONLY' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_NEW_CORREL_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_NEW_MSG_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_NOT_OWN_SUBS' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_NO_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_NO_SYNCPOINT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_PASS_ALL_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_PASS_IDENTITY_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_RESOLVE_LOCAL_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_RESPONSE_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_RESPONSE_AS_TOPIC_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_RETAIN' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_SCOPE_QMGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_SET_ALL_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_SET_IDENTITY_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_SUPPRESS_REPLYTO' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_SYNCPOINT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_SYNC_RESPONSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_VERSION_1' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_VERSION_2' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_VERSION_3' => 'mqseries/mqseries.stub', 'MQSERIES_MQPMO_WARN_IF_NO_SUBS_MATCHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQPRI_PRIORITY_AS_PARENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPRI_PRIORITY_AS_PUBLISHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQPRI_PRIORITY_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQPRI_PRIORITY_AS_TOPIC_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQPRT_ASYNC_RESPONSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQPRT_RESPONSE_AS_PARENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQPRT_SYNC_RESPONSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ACTION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_CONN_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_CONV_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_DEFS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_DEFS_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_DISC_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_SERV_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ADAPTER_STORAGE_SHORTAGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_AIR_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ALIAS_BASE_Q_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ALIAS_TARGTYPE_CHANGED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ALREADY_CONNECTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ALREADY_JOINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ALTER_SUB_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ANOTHER_Q_MGR_CONNECTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_API_EXIT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_API_EXIT_INIT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_API_EXIT_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_API_EXIT_NOT_FOUND' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_API_EXIT_TERM_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_APPL_FIRST' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_APPL_LAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ASID_MISMATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ASYNC_UOW_CONFLICT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ASYNC_XA_CONFLICT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ATTRIBUTE_LOCKED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_AUTH_INFO_CONN_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_AUTH_INFO_REC_COUNT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_AUTH_INFO_REC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_AUTH_INFO_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BACKED_OUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BACKOUT_THRESHOLD_REACHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BAG_CONVERSION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BAG_WRONG_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BINARY_DATA_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BMHO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BRIDGE_STARTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BRIDGE_STOPPED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BUFFER_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BUFFER_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_BUFFER_NOT_AUTOMATIC' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CALLBACK_LINK_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CALLBACK_NOT_REGISTERED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CALLBACK_ROUTINE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CALLBACK_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CALL_INTERRUPTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CALL_IN_PROGRESS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CBD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CBD_OPTIONS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CD_ARRAY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CERT_VAL_POLICY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFBF_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFBS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFGR_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFIF_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFIL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFIN_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFSF_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFSL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CFST_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CF_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CF_STRUC_AUTH_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CF_STRUC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CF_STRUC_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CF_STRUC_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CF_STRUC_LIST_HDR_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_ACTIVATED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_AUTO_DEF_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_AUTO_DEF_OK' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_BLOCKED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_BLOCKED_WARNING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_CONFIG_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_CONV_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_NOT_ACTIVATED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_SSL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_SSL_WARNING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_STARTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_STOPPED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHANNEL_STOPPED_BY_USER' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHAR_ATTRS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHAR_ATTRS_TOO_SHORT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHAR_ATTR_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CHAR_CONVERSION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CICS_BRIDGE_RESTRICTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CICS_WAIT_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CIPHER_SPEC_NOT_SUITE_B' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLIENT_CHANNEL_CONFLICT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLIENT_CONN_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLIENT_EXIT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLIENT_EXIT_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLUSTER_EXIT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLUSTER_EXIT_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLUSTER_PUT_INHIBITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLUSTER_RESOLUTION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CLUSTER_RESOURCE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CMD_SERVER_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CMHO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CNO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CODED_CHAR_SET_ID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_COD_NOT_VALID_FOR_XCF_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_COMMAND_MQSC' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_COMMAND_PCF' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_COMMAND_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_COMMINFO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONFIG_CHANGE_OBJECT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONFIG_CREATE_OBJECT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONFIG_DELETE_OBJECT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONFIG_REFRESH_OBJECT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_BROKEN' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_NOT_AUTHORIZED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_STOPPED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_STOPPING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONNECTION_SUSPENDED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONN_ID_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONN_TAG_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONN_TAG_NOT_RELEASED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONN_TAG_NOT_USABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONTENT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONTEXT_HANDLE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONTEXT_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONTEXT_OBJECT_NOT_VALID' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONTEXT_OPEN_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONVERTED_MSG_TOO_BIG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CONVERTED_STRING_TOO_BIG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CORREL_ID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CRYPTO_HARDWARE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CTLO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CURRENT_RECORD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_CURSOR_NOT_VALID' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DATA_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DATA_SET_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DATA_TRUNCATED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DB2_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DBCS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DEF_SYNCPOINT_INHIBITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DEF_XMIT_Q_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DEF_XMIT_Q_USAGE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DEST_CLASS_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DEST_ENV_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DEST_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DISTRIBUTION_LIST_EMPTY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DLH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DMHO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DMPO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DUPLICATE_GROUP_SUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DUPLICATE_RECOV_COORD' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DURABILITY_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DURABILITY_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_DYNAMIC_Q_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ENCODING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ENCODING_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ENVIRONMENT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_EPH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_EXIT_PROPS_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_EXIT_REASON_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_EXPIRY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FASTPATH_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FEEDBACK_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FILE_NOT_AUDITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FILE_SYSTEM_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FILTER_OPERATOR_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FORMAT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FORMAT_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FUNCTION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_FUNCTION_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GET_ENABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GET_INHIBITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GLOBAL_UOW_CONFLICT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GMO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GROUPING_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GROUPING_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GROUP_ADDRESS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_GROUP_ID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HANDLE_IN_USE_FOR_UOW' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HANDLE_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HBAG_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HCONFIG_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HCONN_ASYNC_ACTIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HCONN_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HEADER_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HMSG_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HMSG_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HOBJ_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HOBJ_QUIESCED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HOBJ_QUIESCED_NO_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_HOST_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_IDENTITY_MISMATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_IIH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_IMPO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCOMPLETE_GROUP' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCOMPLETE_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_BROWSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_CCSIDS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_ENCODINGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_FORMAT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_ITEM_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_OBJECT_STATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_OPEN_OPTIONS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_PERSISTENCE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INCONSISTENT_UOW' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INDEX_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INDEX_NOT_PRESENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INHIBIT_VALUE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INITIALIZATION_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INQUIRY_COMMAND_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INSTALLATION_MISMATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INSTALLATION_MISSING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INSUFFICIENT_BUFFER' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INSUFFICIENT_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INT_ATTRS_ARRAY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INT_ATTR_COUNT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INT_ATTR_COUNT_TOO_SMALL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INVALID_DESTINATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INVALID_MSG_UNDER_CURSOR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_INVALID_SUBSCRIPTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ITEM_COUNT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ITEM_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ITEM_VALUE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_JMS_FORMAT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_JSSE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_KEY_REPOSITORY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_LDAP_PASSWORD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_LDAP_USER_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_LDAP_USER_NAME_LENGTH_ERR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_LOCAL_UOW_CONFLICT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_LOGGER_STATUS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_LOOPING_PUBLICATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MATCH_OPTIONS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MAX_CONNS_LIMIT_REACHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MAX_MSG_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MCAST_PUB_STATUS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MCAST_SUB_STATUS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MDE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MHBO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MISSING_REPLY_TO_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MISSING_WIH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MIXED_CONTENT_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MODULE_ENTRY_NOT_FOUND' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MODULE_INVALID' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MODULE_NOT_FOUND' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_FLAGS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_HANDLE_COPY_FAILURE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_HANDLE_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_ID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_MARKED_BROWSE_CO_OP' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_NOT_ALLOWED_IN_GROUP' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_NOT_MATCHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_SEQ_NUMBER_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_TOKEN_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_TOO_BIG_FOR_CHANNEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_TOO_BIG_FOR_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_TOO_BIG_FOR_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MSG_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MULTICAST_CONFIG_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MULTICAST_INTERFACE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MULTICAST_INTERNAL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MULTICAST_ONLY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MULTICAST_SEND_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MULTIPLE_INSTANCE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_MULTIPLE_REASONS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NAME_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NAME_NOT_VALID_FOR_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NEGATIVE_LENGTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NEGATIVE_OFFSET' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NESTED_BAG_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NESTED_SELECTOR_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NEXT_OFFSET_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NEXT_RECORD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_AUTHORIZED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_CONNECTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_CONVERTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_BROWSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_INPUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_INQUIRE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_OUTPUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_PASS_ALL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_PASS_IDENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_SET' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_SET_ALL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_OPEN_FOR_SET_IDENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NOT_PRIVILEGED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_BUFFER' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_CALLBACKS_ACTIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_CONNECTION_REFERENCE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_DATA_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_DESTINATIONS_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_EXTERNAL_PARTICIPANTS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_MSG_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_MSG_LOCKED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_MSG_UNDER_CURSOR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_RECORD_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_RETAINED_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_SUBSCRIPTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NO_SUBS_MATCHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_NULL_POINTER' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_ALREADY_EXISTS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_CHANGED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_DAMAGED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_LEVEL_INCOMPATIBLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_NOT_UNIQUE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_Q_MGR_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_RECORDS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_STRING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OBJECT_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OCSP_URL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OFFSET_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OPEN_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OPERATION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OPERATION_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OPTIONS_CHANGED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OPTIONS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OPTION_ENVIRONMENT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OPTION_NOT_VALID_FOR_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ORIGINAL_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OUTCOME_MIXED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OUTCOME_PENDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_OUT_SELECTOR_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PAGESET_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PAGESET_FULL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PARAMETER_MISSING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PARTIALLY_CONVERTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PARTICIPANT_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PARTICIPANT_NOT_DEFINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PCF_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PERSISTENCE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PERSISTENT_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PMO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PMO_RECORD_FLAGS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PRECONN_EXIT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PRECONN_EXIT_LOAD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PRECONN_EXIT_NOT_FOUND' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PRIORITY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PRIORITY_EXCEEDS_MAXIMUM' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTIES_DISABLED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTIES_TOO_BIG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTY_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTY_NAME_LENGTH_ERR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTY_NAME_TOO_BIG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTY_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTY_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROPERTY_VALUE_TOO_BIG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROP_CONV_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROP_NAME_NOT_CONVERTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROP_NUMBER_FORMAT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROP_TYPE_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PROP_VALUE_NOT_CONVERTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PUBLICATION_FAILURE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PUBLISH_EXIT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PUBSUB_INHIBITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PUT_INHIBITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PUT_MSG_RECORDS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_PUT_NOT_RETAINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_ALREADY_EXISTS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_DELETED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_DEPTH_HIGH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_DEPTH_LOW' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_FULL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_INDEX_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_MGR_ACTIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_MGR_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_MGR_NOT_ACTIVE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_MGR_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_MGR_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_MGR_STOPPING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_NOT_EMPTY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_SERVICE_INTERVAL_HIGH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_SERVICE_INTERVAL_OK' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_SPACE_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_Q_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RAS_PROPERTY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_READ_AHEAD_MSGS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECONNECTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECONNECTING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECONNECT_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECONNECT_INCOMPATIBLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECONNECT_QMID_MISMATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECONNECT_Q_MGR_REQD' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECONNECT_TIMED_OUT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RECS_PRESENT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_REFERENCE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_REMOTE_Q_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_REOPEN_EXCL_INPUT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_REOPEN_INQUIRE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_REOPEN_SAVED_CONTEXT_ERR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_REOPEN_TEMPORARY_Q_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_REPORT_OPTIONS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RESERVED_VALUE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RESOURCE_PROBLEM' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RESPONSE_RECORDS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RES_OBJECT_STRING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RETAINED_MSG_Q_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RETAINED_NOT_DELIVERED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_COMMAND_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_DUPLICATE_PARM' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_FORMAT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_HEADER_FIELD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_PARM_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_PARM_MISSING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_RESTRICTED_FORMAT_ERR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RFH_STRING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_RMH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SCO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SD_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SECOND_MARK_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SECURITY_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SEGMENTATION_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SEGMENTS_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SEGMENT_LENGTH_ZERO' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTION_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTION_STRING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_ALWAYS_FALSE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_COUNT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_INVALID_FOR_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_LIMIT_EXCEEDED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_NOT_FOR_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_NOT_PRESENT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_NOT_UNIQUE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_OUT_OF_RANGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_SYNTAX_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SELECTOR_WRONG_TYPE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SERVICE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SERVICE_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SIGNAL1_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SIGNAL_OUTSTANDING' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SIGNAL_REQUEST_ACCEPTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SMPO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOAP_AXIS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOAP_DOTNET_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOAP_URL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOURCE_BUFFER_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOURCE_CCSID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOURCE_DECIMAL_ENC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOURCE_FLOAT_ENC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOURCE_INTEGER_ENC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SOURCE_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SRC_ENV_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SRC_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SRO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_ALREADY_INITIALIZED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_ALT_PROVIDER_REQUIRED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_CERTIFICATE_REVOKED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_CERT_STORE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_CONFIG_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_INITIALIZATION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_KEY_RESET_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_PEER_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SSL_PEER_NAME_MISMATCH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STANDBY_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STAT_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STOPPED_BY_CLUSTER_EXIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STORAGE_CLASS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STORAGE_MEDIUM_FULL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STORAGE_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STRING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STRING_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STRING_TRUNCATED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STRUC_ID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STRUC_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_STS_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUBLEVEL_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUBSCRIPTION_CHANGE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUBSCRIPTION_CREATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUBSCRIPTION_DELETE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUBSCRIPTION_IN_USE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUBSCRIPTION_REFRESH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUB_ALREADY_EXISTS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUB_INHIBITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUB_NAME_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUB_USER_DATA_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUITE_B_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SUPPRESSED_BY_EXIT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SYNCPOINT_LIMIT_REACHED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SYNCPOINT_NOT_ALLOWED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SYNCPOINT_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SYSTEM_BAG_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SYSTEM_BAG_NOT_DELETABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SYSTEM_ITEM_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_SYSTEM_ITEM_NOT_DELETABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TARGET_BUFFER_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TARGET_CCSID_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TARGET_DECIMAL_ENC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TARGET_FLOAT_ENC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TARGET_INTEGER_ENC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TARGET_LENGTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TERMINATION_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TMC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TM_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TOPIC_NOT_ALTERABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TOPIC_STRING_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TRIGGER_CONTROL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TRIGGER_DEPTH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TRIGGER_MSG_PRIORITY_ERR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TRIGGER_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TRUNCATED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TRUNCATED_MSG_ACCEPTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_TRUNCATED_MSG_FAILED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UCS2_CONVERSION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNEXPECTED_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNIT_OF_WORK_NOT_STARTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_ALIAS_BASE_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_AUTH_ENTITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_CHANNEL_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_COMPONENT_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_DEF_XMIT_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_ENTITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_OBJECT_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_OBJECT_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_Q_NAME' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_REF_OBJECT' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_REMOTE_Q_MGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_REPORT_OPTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNKNOWN_XMIT_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNSUPPORTED_CIPHER_SUITE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UNSUPPORTED_PROPERTY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UOW_CANCELED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UOW_COMMITTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UOW_ENLISTMENT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UOW_IN_PROGRESS' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UOW_MIX_NOT_SUPPORTED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_UOW_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_USER_ID_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_WAIT_INTERVAL_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_WIH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_WRONG_CF_LEVEL' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_WRONG_GMO_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_WRONG_MD_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_WRONG_VERSION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_WXP_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_XEPO_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_XMIT_Q_TYPE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_XMIT_Q_USAGE_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_XQH_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_XR_NOT_AVAILABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_XWAIT_CANCELED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_XWAIT_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQRC_ZERO_LENGTH' => 'mqseries/mqseries.stub', 'MQSERIES_MQRL_UNDEFINED' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_ACCEPT_UNSUP_IF_XMIT_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_ACCEPT_UNSUP_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_ACTIVITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_COA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_COA_WITH_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_COA_WITH_FULL_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_COD' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_COD_WITH_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_COD_WITH_FULL_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_COPY_MSG_ID_TO_CORREL_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_DEAD_LETTER_Q' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_DISCARD_MSG' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_EXCEPTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_EXCEPTION_WITH_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_EXCEPTION_WITH_FULL_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_EXPIRATION' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_EXPIRATION_WITH_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_EXPIRATION_WITH_FULL_DATA' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_NAN' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_NEW_MSG_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_PAN' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_PASS_CORREL_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_PASS_DISCARD_AND_EXPIRY' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_PASS_MSG_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQRO_REJECT_UNSUP_MASK' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_ALTER' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_ALTERNATE_USER_AUTHORITY' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_ANY_USERID' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_CREATE' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_DURABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_FAIL_IF_QUIESCING' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_FIXED_USERID' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_GROUP_SUB' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_MANAGED' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_NEW_PUBLICATIONS_ONLY' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_NONE' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_NON_DURABLE' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_NO_MULTICAST' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_NO_READ_AHEAD' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_PUBLICATIONS_ON_REQUEST' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_READ_AHEAD' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_READ_AHEAD_AS_Q_DEF' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_RESUME' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_SCOPE_QMGR' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_SET_CORREL_ID' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_SET_IDENTITY_CONTEXT' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_WILDCARD_CHAR' => 'mqseries/mqseries.stub', 'MQSERIES_MQSO_WILDCARD_TOPIC' => 'mqseries/mqseries.stub', 'MQSERIES_MQSTAT_TYPE_ASYNC_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQSTAT_TYPE_RECONNECTION' => 'mqseries/mqseries.stub', 'MQSERIES_MQSTAT_TYPE_RECONNECTION_ERROR' => 'mqseries/mqseries.stub', 'MQSERIES_MQWI_UNLIMITED' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_ALL' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_DECNET' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_LOCAL' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_LU62' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_NETBIOS' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_SPX' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_TCP' => 'mqseries/mqseries.stub', 'MQSERIES_MQXPT_UDP' => 'mqseries/mqseries.stub', 'MSG_CMSG_CLOEXEC' => 'sockets/sockets.stub', 'MSG_CONFIRM' => 'sockets/sockets.stub', 'MSG_CTRUNC' => 'sockets/sockets.stub', 'MSG_DONTROUTE' => 'sockets/sockets.stub', 'MSG_DONTWAIT' => 'sockets/sockets.stub', 'MSG_EAGAIN' => 'sysvmsg/sysvmsg.stub', 'MSG_ENOMSG' => 'sysvmsg/sysvmsg.stub', 'MSG_EOF' => 'sockets/sockets.stub', 'MSG_EOR' => 'sockets/sockets.stub', 'MSG_ERRQUEUE' => 'sockets/sockets.stub', 'MSG_EXCEPT' => 'sysvmsg/sysvmsg.stub', 'MSG_IPC_NOWAIT' => 'sysvmsg/sysvmsg.stub', 'MSG_MORE' => 'sockets/sockets.stub', 'MSG_NOERROR' => 'sysvmsg/sysvmsg.stub', 'MSG_NOSIGNAL' => 'sockets/sockets.stub', 'MSG_OOB' => 'sockets/sockets.stub', 'MSG_PEEK' => 'sockets/sockets.stub', 'MSG_TRUNC' => 'sockets/sockets.stub', 'MSG_WAITALL' => 'sockets/sockets.stub', 'MSG_WAITFORONE' => 'sockets/sockets.stub', 'MSG_ZEROCOPY' => 'sockets/sockets.stub', 'MSSQL_ASSOC' => 'mssql/mssql.stub', 'MSSQL_BOTH' => 'mssql/mssql.stub', 'MSSQL_NUM' => 'mssql/mssql.stub', 'MS_ALIGN_CENTER' => 'mapscript/mapscript.stub', 'MS_ALIGN_LEFT' => 'mapscript/mapscript.stub', 'MS_ALIGN_RIGHT' => 'mapscript/mapscript.stub', 'MS_AUTO' => 'mapscript/mapscript.stub', 'MS_AUTO2' => 'mapscript/mapscript.stub', 'MS_CC' => 'mapscript/mapscript.stub', 'MS_CGIERR' => 'mapscript/mapscript.stub', 'MS_CL' => 'mapscript/mapscript.stub', 'MS_CR' => 'mapscript/mapscript.stub', 'MS_DBFERR' => 'mapscript/mapscript.stub', 'MS_DD' => 'mapscript/mapscript.stub', 'MS_DEFAULT' => 'mapscript/mapscript.stub', 'MS_DELETE' => 'mapscript/mapscript.stub', 'MS_EMBED' => 'mapscript/mapscript.stub', 'MS_EOFERR' => 'mapscript/mapscript.stub', 'MS_FALSE' => 'mapscript/mapscript.stub', 'MS_FEET' => 'mapscript/mapscript.stub', 'MS_FOLLOW' => 'mapscript/mapscript.stub', 'MS_GDERR' => 'mapscript/mapscript.stub', 'MS_GD_ALPHA' => 'mapscript/mapscript.stub', 'MS_GET_REQUEST' => 'mapscript/mapscript.stub', 'MS_GIANT' => 'mapscript/mapscript.stub', 'MS_GRATICULE' => 'mapscript/mapscript.stub', 'MS_HASHERR' => 'mapscript/mapscript.stub', 'MS_HILITE' => 'mapscript/mapscript.stub', 'MS_HTTPERR' => 'mapscript/mapscript.stub', 'MS_IDENTERR' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_BYTE' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_FEATURE' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_FLOAT32' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_INT16' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_NULL' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_PC256' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_RGB' => 'mapscript/mapscript.stub', 'MS_IMAGEMODE_RGBA' => 'mapscript/mapscript.stub', 'MS_IMGERR' => 'mapscript/mapscript.stub', 'MS_INCHES' => 'mapscript/mapscript.stub', 'MS_INLINE' => 'mapscript/mapscript.stub', 'MS_IOERR' => 'mapscript/mapscript.stub', 'MS_JOINERR' => 'mapscript/mapscript.stub', 'MS_KILOMETERS' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_ANGLE' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_COLOR' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_FONT' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_OUTLINECOLOR' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_POSITION' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_PRIORITY' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_SHADOWSIZEX' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_SHADOWSIZEY' => 'mapscript/mapscript.stub', 'MS_LABEL_BINDING_SIZE' => 'mapscript/mapscript.stub', 'MS_LARGE' => 'mapscript/mapscript.stub', 'MS_LAYER_ANNOTATION' => 'mapscript/mapscript.stub', 'MS_LAYER_CHART' => 'mapscript/mapscript.stub', 'MS_LAYER_CIRCLE' => 'mapscript/mapscript.stub', 'MS_LAYER_LINE' => 'mapscript/mapscript.stub', 'MS_LAYER_POINT' => 'mapscript/mapscript.stub', 'MS_LAYER_POLYGON' => 'mapscript/mapscript.stub', 'MS_LAYER_QUERY' => 'mapscript/mapscript.stub', 'MS_LAYER_RASTER' => 'mapscript/mapscript.stub', 'MS_LAYER_TILEINDEX' => 'mapscript/mapscript.stub', 'MS_LC' => 'mapscript/mapscript.stub', 'MS_LL' => 'mapscript/mapscript.stub', 'MS_LR' => 'mapscript/mapscript.stub', 'MS_MAPCONTEXTERR' => 'mapscript/mapscript.stub', 'MS_MEDIUM' => 'mapscript/mapscript.stub', 'MS_MEMERR' => 'mapscript/mapscript.stub', 'MS_METERS' => 'mapscript/mapscript.stub', 'MS_MILES' => 'mapscript/mapscript.stub', 'MS_MISCERR' => 'mapscript/mapscript.stub', 'MS_MULTIPLE' => 'mapscript/mapscript.stub', 'MS_NAUTICALMILES' => 'mapscript/mapscript.stub', 'MS_NO' => 'mapscript/mapscript.stub', 'MS_NOERR' => 'mapscript/mapscript.stub', 'MS_NONE' => 'mapscript/mapscript.stub', 'MS_NORMAL' => 'mapscript/mapscript.stub', 'MS_NOTFOUND' => 'mapscript/mapscript.stub', 'MS_OFF' => 'mapscript/mapscript.stub', 'MS_OGR' => 'mapscript/mapscript.stub', 'MS_OGRERR' => 'mapscript/mapscript.stub', 'MS_ON' => 'mapscript/mapscript.stub', 'MS_ORACLESPATIAL' => 'mapscript/mapscript.stub', 'MS_ORACLESPATIALERR' => 'mapscript/mapscript.stub', 'MS_PARSEERR' => 'mapscript/mapscript.stub', 'MS_PIXELS' => 'mapscript/mapscript.stub', 'MS_PLUGIN' => 'mapscript/mapscript.stub', 'MS_POSTGIS' => 'mapscript/mapscript.stub', 'MS_POST_REQUEST' => 'mapscript/mapscript.stub', 'MS_PROJERR' => 'mapscript/mapscript.stub', 'MS_QUERYERR' => 'mapscript/mapscript.stub', 'MS_RASTER' => 'mapscript/mapscript.stub', 'MS_REGEXERR' => 'mapscript/mapscript.stub', 'MS_SDE' => 'mapscript/mapscript.stub', 'MS_SDEERR' => 'mapscript/mapscript.stub', 'MS_SELECTED' => 'mapscript/mapscript.stub', 'MS_SHAPEFILE' => 'mapscript/mapscript.stub', 'MS_SHAPE_LINE' => 'mapscript/mapscript.stub', 'MS_SHAPE_NULL' => 'mapscript/mapscript.stub', 'MS_SHAPE_POINT' => 'mapscript/mapscript.stub', 'MS_SHAPE_POLYGON' => 'mapscript/mapscript.stub', 'MS_SHPERR' => 'mapscript/mapscript.stub', 'MS_SHP_ARC' => 'mapscript/mapscript.stub', 'MS_SHP_MULTIPOINT' => 'mapscript/mapscript.stub', 'MS_SHP_POINT' => 'mapscript/mapscript.stub', 'MS_SHP_POLYGON' => 'mapscript/mapscript.stub', 'MS_SINGLE' => 'mapscript/mapscript.stub', 'MS_SMALL' => 'mapscript/mapscript.stub', 'MS_STYLE_BINDING_ANGLE' => 'mapscript/mapscript.stub', 'MS_STYLE_BINDING_COLOR' => 'mapscript/mapscript.stub', 'MS_STYLE_BINDING_OUTLINECOLOR' => 'mapscript/mapscript.stub', 'MS_STYLE_BINDING_SIZE' => 'mapscript/mapscript.stub', 'MS_STYLE_BINDING_SYMBOL' => 'mapscript/mapscript.stub', 'MS_STYLE_BINDING_WIDTH' => 'mapscript/mapscript.stub', 'MS_SYMBOL_ELLIPSE' => 'mapscript/mapscript.stub', 'MS_SYMBOL_PIXMAP' => 'mapscript/mapscript.stub', 'MS_SYMBOL_SIMPLE' => 'mapscript/mapscript.stub', 'MS_SYMBOL_TRUETYPE' => 'mapscript/mapscript.stub', 'MS_SYMBOL_VECTOR' => 'mapscript/mapscript.stub', 'MS_SYMERR' => 'mapscript/mapscript.stub', 'MS_TILED_OGR' => 'mapscript/mapscript.stub', 'MS_TILED_SHAPEFILE' => 'mapscript/mapscript.stub', 'MS_TINY' => 'mapscript/mapscript.stub', 'MS_TRUE' => 'mapscript/mapscript.stub', 'MS_TTFERR' => 'mapscript/mapscript.stub', 'MS_TYPEERR' => 'mapscript/mapscript.stub', 'MS_UC' => 'mapscript/mapscript.stub', 'MS_UL' => 'mapscript/mapscript.stub', 'MS_UNION' => 'mapscript/mapscript.stub', 'MS_UR' => 'mapscript/mapscript.stub', 'MS_WCSERR' => 'mapscript/mapscript.stub', 'MS_WEBERR' => 'mapscript/mapscript.stub', 'MS_WFS' => 'mapscript/mapscript.stub', 'MS_WFSCONNERR' => 'mapscript/mapscript.stub', 'MS_WFSERR' => 'mapscript/mapscript.stub', 'MS_WMS' => 'mapscript/mapscript.stub', 'MS_WMSCONNERR' => 'mapscript/mapscript.stub', 'MS_WMSERR' => 'mapscript/mapscript.stub', 'MS_XY' => 'mapscript/mapscript.stub', 'MS_YES' => 'mapscript/mapscript.stub', 'MT_RAND_MT19937' => 'standard/standard_defines.stub', 'MT_RAND_PHP' => 'standard/standard_defines.stub', 'MYSQLI_ASSOC' => 'mysqli/mysqli.stub', 'MYSQLI_ASYNC' => 'mysqli/mysqli.stub', 'MYSQLI_AUTO_INCREMENT_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_BINARY_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_BLOB_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_BOTH' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_COMPRESS' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_FOUND_ROWS' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_IGNORE_SPACE' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_INTERACTIVE' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_NO_SCHEMA' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_SSL' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_SSL_DONT_VERIFY_SERVER_CERT' => 'mysqli/mysqli.stub', 'MYSQLI_CLIENT_SSL_VERIFY_SERVER_CERT' => 'mysqli/mysqli.stub', 'MYSQLI_CURSOR_TYPE_FOR_UPDATE' => 'mysqli/mysqli.stub', 'MYSQLI_CURSOR_TYPE_NO_CURSOR' => 'mysqli/mysqli.stub', 'MYSQLI_CURSOR_TYPE_READ_ONLY' => 'mysqli/mysqli.stub', 'MYSQLI_CURSOR_TYPE_SCROLLABLE' => 'mysqli/mysqli.stub', 'MYSQLI_DATA_TRUNCATED' => 'mysqli/mysqli.stub', 'MYSQLI_DEBUG_TRACE_ENABLED' => 'mysqli/mysqli.stub', 'MYSQLI_ENUM_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_GROUP_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_INIT_COMMAND' => 'mysqli/mysqli.stub', 'MYSQLI_IS_MARIADB' => 'mysqli/mysqli.stub', 'MYSQLI_MULTIPLE_KEY_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_NOT_NULL_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_NO_DATA' => 'mysqli/mysqli.stub', 'MYSQLI_NO_DEFAULT_VALUE_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_NUM' => 'mysqli/mysqli.stub', 'MYSQLI_NUM_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_ON_UPDATE_NOW_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_CAN_HANDLE_EXPIRED_PASSWORDS' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_CONNECT_TIMEOUT' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_INT_AND_FLOAT_NATIVE' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_LOAD_DATA_LOCAL_DIR' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_LOCAL_INFILE' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_NET_CMD_BUFFER_SIZE' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_NET_READ_BUFFER_SIZE' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_READ_TIMEOUT' => 'mysqli/mysqli.stub', 'MYSQLI_OPT_SSL_VERIFY_SERVER_CERT' => 'mysqli/mysqli.stub', 'MYSQLI_PART_KEY_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_PRI_KEY_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_READ_DEFAULT_FILE' => 'mysqli/mysqli.stub', 'MYSQLI_READ_DEFAULT_GROUP' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_BACKUP_LOG' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_GRANT' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_HOSTS' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_LOG' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_MASTER' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_REPLICA' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_SLAVE' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_STATUS' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_TABLES' => 'mysqli/mysqli.stub', 'MYSQLI_REFRESH_THREADS' => 'mysqli/mysqli.stub', 'MYSQLI_REPORT_ALL' => 'mysqli/mysqli.stub', 'MYSQLI_REPORT_ERROR' => 'mysqli/mysqli.stub', 'MYSQLI_REPORT_INDEX' => 'mysqli/mysqli.stub', 'MYSQLI_REPORT_OFF' => 'mysqli/mysqli.stub', 'MYSQLI_REPORT_STRICT' => 'mysqli/mysqli.stub', 'MYSQLI_SERVER_PS_OUT_PARAMS' => 'mysqli/mysqli.stub', 'MYSQLI_SERVER_PUBLIC_KEY' => 'mysqli/mysqli.stub', 'MYSQLI_SERVER_QUERY_NO_GOOD_INDEX_USED' => 'mysqli/mysqli.stub', 'MYSQLI_SERVER_QUERY_NO_INDEX_USED' => 'mysqli/mysqli.stub', 'MYSQLI_SERVER_QUERY_WAS_SLOW' => 'mysqli/mysqli.stub', 'MYSQLI_SET_CHARSET_DIR' => 'mysqli/mysqli.stub', 'MYSQLI_SET_CHARSET_NAME' => 'mysqli/mysqli.stub', 'MYSQLI_SET_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_STMT_ATTR_CURSOR_TYPE' => 'mysqli/mysqli.stub', 'MYSQLI_STMT_ATTR_PREFETCH_ROWS' => 'mysqli/mysqli.stub', 'MYSQLI_STMT_ATTR_UPDATE_MAX_LENGTH' => 'mysqli/mysqli.stub', 'MYSQLI_STORE_RESULT' => 'mysqli/mysqli.stub', 'MYSQLI_STORE_RESULT_COPY_DATA' => 'mysqli/mysqli.stub', 'MYSQLI_TIMESTAMP_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_TRANS_COR_AND_CHAIN' => 'mysqli/mysqli.stub', 'MYSQLI_TRANS_COR_AND_NO_CHAIN' => 'mysqli/mysqli.stub', 'MYSQLI_TRANS_COR_NO_RELEASE' => 'mysqli/mysqli.stub', 'MYSQLI_TRANS_COR_RELEASE' => 'mysqli/mysqli.stub', 'MYSQLI_TRANS_START_READ_ONLY' => 'mysqli/mysqli.stub', 'MYSQLI_TRANS_START_READ_WRITE' => 'mysqli/mysqli.stub', 'MYSQLI_TRANS_START_WITH_CONSISTENT_SNAPSHOT' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_BIT' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_BLOB' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_CHAR' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_DATE' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_DATETIME' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_DECIMAL' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_DOUBLE' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_ENUM' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_FLOAT' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_GEOMETRY' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_INT24' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_INTERVAL' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_JSON' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_LONG' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_LONGLONG' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_LONG_BLOB' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_MEDIUM_BLOB' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_NEWDATE' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_NEWDECIMAL' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_NULL' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_SET' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_SHORT' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_STRING' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_TIME' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_TIMESTAMP' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_TINY' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_TINY_BLOB' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_VAR_STRING' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_VECTOR' => 'mysqli/mysqli.stub', 'MYSQLI_TYPE_YEAR' => 'mysqli/mysqli.stub', 'MYSQLI_UNIQUE_KEY_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_UNSIGNED_FLAG' => 'mysqli/mysqli.stub', 'MYSQLI_USE_RESULT' => 'mysqli/mysqli.stub', 'MYSQLI_ZEROFILL_FLAG' => 'mysqli/mysqli.stub', 'MYSQLX_LOCK_DEFAULT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_LOCK_NOWAIT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_LOCK_SKIP_LOCKED' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_BIGINT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_BIT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_BLOB' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_BYTES' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_CHAR' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_DATE' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_DATETIME' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_DECIMAL' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_DOUBLE' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_ENUM' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_FLOAT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_GEOMETRY' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_INT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_INT24' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_INTERVAL' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_JSON' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_LONG' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_LONGLONG' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_LONG_BLOB' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_MEDIUMINT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_MEDIUM_BLOB' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_NEWDATE' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_NEWDECIMAL' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_NULL' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_SET' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_SHORT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_SMALLINT' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_STRING' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_TIME' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_TIMESTAMP' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_TINY' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_TINY_BLOB' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_VAR_STRING' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQLX_TYPE_YEAR' => 'mysql_xdevapi/mysql_xdevapi.stub', 'MYSQL_ASSOC' => 'mysql/mysql.stub', 'MYSQL_BOTH' => 'mysql/mysql.stub', 'MYSQL_CLIENT_COMPRESS' => 'mysql/mysql.stub', 'MYSQL_CLIENT_IGNORE_SPACE' => 'mysql/mysql.stub', 'MYSQL_CLIENT_INTERACTIVE' => 'mysql/mysql.stub', 'MYSQL_CLIENT_SSL' => 'mysql/mysql.stub', 'MYSQL_NUM' => 'mysql/mysql.stub', 'M_1_PI' => 'standard/standard_defines.stub', 'M_2_PI' => 'standard/standard_defines.stub', 'M_2_SQRTPI' => 'standard/standard_defines.stub', 'M_E' => 'standard/standard_defines.stub', 'M_EULER' => 'standard/standard_defines.stub', 'M_LN10' => 'standard/standard_defines.stub', 'M_LN2' => 'standard/standard_defines.stub', 'M_LNPI' => 'standard/standard_defines.stub', 'M_LOG10E' => 'standard/standard_defines.stub', 'M_LOG2E' => 'standard/standard_defines.stub', 'M_PI' => 'standard/standard_defines.stub', 'M_PI_2' => 'standard/standard_defines.stub', 'M_PI_4' => 'standard/standard_defines.stub', 'M_SQRT1_2' => 'standard/standard_defines.stub', 'M_SQRT2' => 'standard/standard_defines.stub', 'M_SQRT3' => 'standard/standard_defines.stub', 'M_SQRTPI' => 'standard/standard_defines.stub', 'Menu' => 'winbinder/winbinder.stub', 'ModalDialog' => 'winbinder/winbinder.stub', 'ModelessDialog' => 'winbinder/winbinder.stub', 'NAN' => 'standard/standard_defines.stub', 'NCURSES_ALL_MOUSE_EVENTS' => 'ncurses/ncurses.stub', 'NCURSES_A_ALTCHARSET' => 'ncurses/ncurses.stub', 'NCURSES_A_BLINK' => 'ncurses/ncurses.stub', 'NCURSES_A_BOLD' => 'ncurses/ncurses.stub', 'NCURSES_A_CHARTEXT' => 'ncurses/ncurses.stub', 'NCURSES_A_DIM' => 'ncurses/ncurses.stub', 'NCURSES_A_INVIS' => 'ncurses/ncurses.stub', 'NCURSES_A_NORMAL' => 'ncurses/ncurses.stub', 'NCURSES_A_PROTECT' => 'ncurses/ncurses.stub', 'NCURSES_A_REVERSE' => 'ncurses/ncurses.stub', 'NCURSES_A_STANDOUT' => 'ncurses/ncurses.stub', 'NCURSES_A_UNDERLINE' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON1_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON1_DOUBLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON1_PRESSED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON1_RELEASED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON1_TRIPLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON2_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON2_DOUBLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON2_PRESSED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON2_RELEASED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON2_TRIPLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON3_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON3_DOUBLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON3_PRESSED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON3_RELEASED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON3_TRIPLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON4_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON4_DOUBLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON4_PRESSED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON4_RELEASED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON4_TRIPLE_CLICKED' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON_ALT' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON_CTRL' => 'ncurses/ncurses.stub', 'NCURSES_BUTTON_SHIFT' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_BLACK' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_BLUE' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_CYAN' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_GREEN' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_MAGENTA' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_RED' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_WHITE' => 'ncurses/ncurses.stub', 'NCURSES_COLOR_YELLOW' => 'ncurses/ncurses.stub', 'NCURSES_KEY_A1' => 'ncurses/ncurses.stub', 'NCURSES_KEY_A3' => 'ncurses/ncurses.stub', 'NCURSES_KEY_B2' => 'ncurses/ncurses.stub', 'NCURSES_KEY_BACKSPACE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_BEG' => 'ncurses/ncurses.stub', 'NCURSES_KEY_BTAB' => 'ncurses/ncurses.stub', 'NCURSES_KEY_C1' => 'ncurses/ncurses.stub', 'NCURSES_KEY_C3' => 'ncurses/ncurses.stub', 'NCURSES_KEY_CANCEL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_CATAB' => 'ncurses/ncurses.stub', 'NCURSES_KEY_CLEAR' => 'ncurses/ncurses.stub', 'NCURSES_KEY_CLOSE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_COMMAND' => 'ncurses/ncurses.stub', 'NCURSES_KEY_COPY' => 'ncurses/ncurses.stub', 'NCURSES_KEY_CREATE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_CTAB' => 'ncurses/ncurses.stub', 'NCURSES_KEY_DC' => 'ncurses/ncurses.stub', 'NCURSES_KEY_DL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_DOWN' => 'ncurses/ncurses.stub', 'NCURSES_KEY_EIC' => 'ncurses/ncurses.stub', 'NCURSES_KEY_END' => 'ncurses/ncurses.stub', 'NCURSES_KEY_ENTER' => 'ncurses/ncurses.stub', 'NCURSES_KEY_EOL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_EOS' => 'ncurses/ncurses.stub', 'NCURSES_KEY_EXIT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F0' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F1' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F10' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F11' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F12' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F2' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F3' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F4' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F5' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F6' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F7' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F8' => 'ncurses/ncurses.stub', 'NCURSES_KEY_F9' => 'ncurses/ncurses.stub', 'NCURSES_KEY_FIND' => 'ncurses/ncurses.stub', 'NCURSES_KEY_HELP' => 'ncurses/ncurses.stub', 'NCURSES_KEY_HOME' => 'ncurses/ncurses.stub', 'NCURSES_KEY_IC' => 'ncurses/ncurses.stub', 'NCURSES_KEY_IL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_LEFT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_LL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_MARK' => 'ncurses/ncurses.stub', 'NCURSES_KEY_MESSAGE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_MOUSE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_MOVE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_NEXT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_NPAGE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_OPEN' => 'ncurses/ncurses.stub', 'NCURSES_KEY_OPTIONS' => 'ncurses/ncurses.stub', 'NCURSES_KEY_PPAGE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_PREVIOUS' => 'ncurses/ncurses.stub', 'NCURSES_KEY_PRINT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_REDO' => 'ncurses/ncurses.stub', 'NCURSES_KEY_REFERENCE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_REFRESH' => 'ncurses/ncurses.stub', 'NCURSES_KEY_REPLACE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_RESET' => 'ncurses/ncurses.stub', 'NCURSES_KEY_RESIZE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_RESTART' => 'ncurses/ncurses.stub', 'NCURSES_KEY_RESUME' => 'ncurses/ncurses.stub', 'NCURSES_KEY_RIGHT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SAVE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SBEG' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SCANCEL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SCOMMAND' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SCOPY' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SCREATE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SDC' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SDL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SELECT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SEND' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SEOL' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SEXIT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SF' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SFIND' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SHELP' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SHOME' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SIC' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SLEFT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SMESSAGE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SMOVE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SNEXT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SOPTIONS' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SPREVIOUS' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SPRINT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SR' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SREDO' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SREPLACE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SRESET' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SRIGHT' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SRSUME' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SSAVE' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SSUSPEND' => 'ncurses/ncurses.stub', 'NCURSES_KEY_STAB' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SUNDO' => 'ncurses/ncurses.stub', 'NCURSES_KEY_SUSPEND' => 'ncurses/ncurses.stub', 'NCURSES_KEY_UNDO' => 'ncurses/ncurses.stub', 'NCURSES_KEY_UP' => 'ncurses/ncurses.stub', 'NCURSES_REPORT_MOUSE_POSITION' => 'ncurses/ncurses.stub', 'NEGATIVE_SIGN' => 'standard/standard_defines.stub', 'NIL' => 'imap/imap.stub', 'NOCOLOR' => 'winbinder/winbinder.stub', 'NOEXPR' => 'standard/standard_defines.stub', 'NORM_IGNORECASE' => 'com_dotnet/com_dotnet.stub', 'NORM_IGNOREKANATYPE' => 'com_dotnet/com_dotnet.stub', 'NORM_IGNOREKASHIDA' => 'com_dotnet/com_dotnet.stub', 'NORM_IGNORENONSPACE' => 'com_dotnet/com_dotnet.stub', 'NORM_IGNORESYMBOLS' => 'com_dotnet/com_dotnet.stub', 'NORM_IGNOREWIDTH' => 'com_dotnet/com_dotnet.stub', 'NOSTR' => 'standard/standard_defines.stub', 'N_CS_PRECEDES' => 'standard/standard_defines.stub', 'N_SEP_BY_SPACE' => 'standard/standard_defines.stub', 'N_SIGN_POSN' => 'standard/standard_defines.stub', 'NakedWindow' => 'winbinder/winbinder.stub', 'OAUTH_AUTH_TYPE_AUTHORIZATION' => 'oauth/oauth.stub', 'OAUTH_AUTH_TYPE_FORM' => 'oauth/oauth.stub', 'OAUTH_AUTH_TYPE_NONE' => 'oauth/oauth.stub', 'OAUTH_AUTH_TYPE_URI' => 'oauth/oauth.stub', 'OAUTH_BAD_NONCE' => 'oauth/oauth.stub', 'OAUTH_BAD_TIMESTAMP' => 'oauth/oauth.stub', 'OAUTH_CONSUMER_KEY_REFUSED' => 'oauth/oauth.stub', 'OAUTH_CONSUMER_KEY_UNKNOWN' => 'oauth/oauth.stub', 'OAUTH_HTTP_METHOD_DELETE' => 'oauth/oauth.stub', 'OAUTH_HTTP_METHOD_GET' => 'oauth/oauth.stub', 'OAUTH_HTTP_METHOD_HEAD' => 'oauth/oauth.stub', 'OAUTH_HTTP_METHOD_POST' => 'oauth/oauth.stub', 'OAUTH_HTTP_METHOD_PUT' => 'oauth/oauth.stub', 'OAUTH_INVALID_SIGNATURE' => 'oauth/oauth.stub', 'OAUTH_OK' => 'oauth/oauth.stub', 'OAUTH_PARAMETER_ABSENT' => 'oauth/oauth.stub', 'OAUTH_REQENGINE_CURL' => 'oauth/oauth.stub', 'OAUTH_REQENGINE_STREAMS' => 'oauth/oauth.stub', 'OAUTH_SIGNATURE_METHOD_REJECTED' => 'oauth/oauth.stub', 'OAUTH_SIG_METHOD_HMACSHA1' => 'oauth/oauth.stub', 'OAUTH_SIG_METHOD_HMACSHA256' => 'oauth/oauth.stub', 'OAUTH_SIG_METHOD_RSASHA1' => 'oauth/oauth.stub', 'OAUTH_TOKEN_EXPIRED' => 'oauth/oauth.stub', 'OAUTH_TOKEN_REJECTED' => 'oauth/oauth.stub', 'OAUTH_TOKEN_USED' => 'oauth/oauth.stub', 'OAUTH_VERIFIER_INVALID' => 'oauth/oauth.stub', 'OCI_ASSOC' => 'oci8/oci8.stub', 'OCI_BOTH' => 'oci8/oci8.stub', 'OCI_B_BFILE' => 'oci8/oci8.stub', 'OCI_B_BIN' => 'oci8/oci8.stub', 'OCI_B_BLOB' => 'oci8/oci8.stub', 'OCI_B_BOL' => 'oci8/oci8.stub', 'OCI_B_CFILEE' => 'oci8/oci8.stub', 'OCI_B_CLOB' => 'oci8/oci8.stub', 'OCI_B_CURSOR' => 'oci8/oci8.stub', 'OCI_B_INT' => 'oci8/oci8.stub', 'OCI_B_NTY' => 'oci8/oci8.stub', 'OCI_B_NUM' => 'oci8/oci8.stub', 'OCI_B_ROWID' => 'oci8/oci8.stub', 'OCI_COMMIT_ON_SUCCESS' => 'oci8/oci8.stub', 'OCI_CRED_EXT' => 'oci8/oci8.stub', 'OCI_DEFAULT' => 'oci8/oci8.stub', 'OCI_DESCRIBE_ONLY' => 'oci8/oci8.stub', 'OCI_DTYPE_FILE' => 'oci8/oci8.stub', 'OCI_DTYPE_LOB' => 'oci8/oci8.stub', 'OCI_DTYPE_ROWID' => 'oci8/oci8.stub', 'OCI_D_FILE' => 'oci8/oci8.stub', 'OCI_D_LOB' => 'oci8/oci8.stub', 'OCI_D_ROWID' => 'oci8/oci8.stub', 'OCI_EXACT_FETCH' => 'oci8/oci8.stub', 'OCI_FETCHSTATEMENT_BY_COLUMN' => 'oci8/oci8.stub', 'OCI_FETCHSTATEMENT_BY_ROW' => 'oci8/oci8.stub', 'OCI_LOB_BUFFER_FREE' => 'oci8/oci8.stub', 'OCI_NO_AUTO_COMMIT' => 'oci8/oci8.stub', 'OCI_NUM' => 'oci8/oci8.stub', 'OCI_RETURN_LOBS' => 'oci8/oci8.stub', 'OCI_RETURN_NULLS' => 'oci8/oci8.stub', 'OCI_SEEK_CUR' => 'oci8/oci8.stub', 'OCI_SEEK_END' => 'oci8/oci8.stub', 'OCI_SEEK_SET' => 'oci8/oci8.stub', 'OCI_SYSDATE' => 'oci8/oci8.stub', 'OCI_SYSDBA' => 'oci8/oci8.stub', 'OCI_SYSOPER' => 'oci8/oci8.stub', 'OCI_TEMP_BLOB' => 'oci8/oci8.stub', 'OCI_TEMP_CLOB' => 'oci8/oci8.stub', 'ODBC_BINMODE_CONVERT' => 'odbc/odbc.stub', 'ODBC_BINMODE_PASSTHRU' => 'odbc/odbc.stub', 'ODBC_BINMODE_RETURN' => 'odbc/odbc.stub', 'ODBC_TYPE' => 'odbc/odbc.stub', 'OPENSSL_ALGO_DSS1' => 'openssl/openssl.stub', 'OPENSSL_ALGO_MD2' => 'openssl/openssl.stub', 'OPENSSL_ALGO_MD4' => 'openssl/openssl.stub', 'OPENSSL_ALGO_MD5' => 'openssl/openssl.stub', 'OPENSSL_ALGO_RMD160' => 'openssl/openssl.stub', 'OPENSSL_ALGO_SHA1' => 'openssl/openssl.stub', 'OPENSSL_ALGO_SHA224' => 'openssl/openssl.stub', 'OPENSSL_ALGO_SHA256' => 'openssl/openssl.stub', 'OPENSSL_ALGO_SHA384' => 'openssl/openssl.stub', 'OPENSSL_ALGO_SHA512' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_3DES' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_AES_128_CBC' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_AES_192_CBC' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_AES_256_CBC' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_DES' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_RC2_128' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_RC2_40' => 'openssl/openssl.stub', 'OPENSSL_CIPHER_RC2_64' => 'openssl/openssl.stub', 'OPENSSL_CMS_BINARY' => 'openssl/openssl.stub', 'OPENSSL_CMS_DETACHED' => 'openssl/openssl.stub', 'OPENSSL_CMS_NOATTR' => 'openssl/openssl.stub', 'OPENSSL_CMS_NOCERTS' => 'openssl/openssl.stub', 'OPENSSL_CMS_NOINTERN' => 'openssl/openssl.stub', 'OPENSSL_CMS_NOSIGS' => 'openssl/openssl.stub', 'OPENSSL_CMS_NOVERIFY' => 'openssl/openssl.stub', 'OPENSSL_CMS_OLDMIMETYPE' => 'openssl/openssl.stub', 'OPENSSL_CMS_TEXT' => 'openssl/openssl.stub', 'OPENSSL_DEFAULT_STREAM_CIPHERS' => 'openssl/openssl.stub', 'OPENSSL_DONT_ZERO_PAD_KEY' => 'openssl/openssl.stub', 'OPENSSL_ENCODING_DER' => 'openssl/openssl.stub', 'OPENSSL_ENCODING_PEM' => 'openssl/openssl.stub', 'OPENSSL_ENCODING_SMIME' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_DH' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_DSA' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_EC' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_ED25519' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_ED448' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_RSA' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_X25519' => 'openssl/openssl.stub', 'OPENSSL_KEYTYPE_X448' => 'openssl/openssl.stub', 'OPENSSL_NO_PADDING' => 'openssl/openssl.stub', 'OPENSSL_PKCS1_OAEP_PADDING' => 'openssl/openssl.stub', 'OPENSSL_PKCS1_PADDING' => 'openssl/openssl.stub', 'OPENSSL_RAW_DATA' => 'openssl/openssl.stub', 'OPENSSL_SSLV23_PADDING' => 'openssl/openssl.stub', 'OPENSSL_TLSEXT_SERVER_NAME' => 'openssl/openssl.stub', 'OPENSSL_VERSION_NUMBER' => 'openssl/openssl.stub', 'OPENSSL_VERSION_TEXT' => 'openssl/openssl.stub', 'OPENSSL_ZERO_PADDING' => 'openssl/openssl.stub', 'OP_ANONYMOUS' => 'imap/imap.stub', 'OP_DEBUG' => 'imap/imap.stub', 'OP_EXPUNGE' => 'imap/imap.stub', 'OP_HALFOPEN' => 'imap/imap.stub', 'OP_PROTOTYPE' => 'imap/imap.stub', 'OP_READONLY' => 'imap/imap.stub', 'OP_SECURE' => 'imap/imap.stub', 'OP_SHORTCACHE' => 'imap/imap.stub', 'OP_SILENT' => 'imap/imap.stub', 'O_APPEND' => 'dio/dio_d.stub', 'O_ASYNC' => 'dio/dio_d.stub', 'O_CREAT' => 'dio/dio_d.stub', 'O_EXCL' => 'dio/dio_d.stub', 'O_NDELAY' => 'dio/dio_d.stub', 'O_NOCTTY' => 'dio/dio_d.stub', 'O_NONBLOCK' => 'dio/dio_d.stub', 'O_RDONLY' => 'dio/dio_d.stub', 'O_RDWR' => 'dio/dio_d.stub', 'O_SYNC' => 'dio/dio_d.stub', 'O_TRUNC' => 'dio/dio_d.stub', 'O_WRONLY' => 'dio/dio_d.stub', 'PASSWORD_ARGON2I' => 'standard/password.stub', 'PASSWORD_ARGON2ID' => 'standard/password.stub', 'PASSWORD_ARGON2_DEFAULT_MEMORY_COST' => 'standard/password.stub', 'PASSWORD_ARGON2_DEFAULT_THREADS' => 'standard/password.stub', 'PASSWORD_ARGON2_DEFAULT_TIME_COST' => 'standard/password.stub', 'PASSWORD_ARGON2_PROVIDER' => 'standard/password.stub', 'PASSWORD_BCRYPT' => 'standard/password.stub', 'PASSWORD_BCRYPT_DEFAULT_COST' => 'standard/password.stub', 'PASSWORD_DEFAULT' => 'standard/password.stub', 'PATHINFO_ALL' => 'standard/standard_defines.stub', 'PATHINFO_BASENAME' => 'standard/standard_defines.stub', 'PATHINFO_DIRNAME' => 'standard/standard_defines.stub', 'PATHINFO_EXTENSION' => 'standard/standard_defines.stub', 'PATHINFO_FILENAME' => 'standard/standard_defines.stub', 'PATH_SEPARATOR' => 'standard/standard_defines.stub', 'PCNTL_E2BIG' => 'pcntl/pcntl.stub', 'PCNTL_EACCES' => 'pcntl/pcntl.stub', 'PCNTL_EAGAIN' => 'pcntl/pcntl.stub', 'PCNTL_ECHILD' => 'pcntl/pcntl.stub', 'PCNTL_EFAULT' => 'pcntl/pcntl.stub', 'PCNTL_EINTR' => 'pcntl/pcntl.stub', 'PCNTL_EINVAL' => 'pcntl/pcntl.stub', 'PCNTL_EIO' => 'pcntl/pcntl.stub', 'PCNTL_EISDIR' => 'pcntl/pcntl.stub', 'PCNTL_ELIBBAD' => 'pcntl/pcntl.stub', 'PCNTL_ELOOP' => 'pcntl/pcntl.stub', 'PCNTL_EMFILE' => 'pcntl/pcntl.stub', 'PCNTL_ENAMETOOLONG' => 'pcntl/pcntl.stub', 'PCNTL_ENFILE' => 'pcntl/pcntl.stub', 'PCNTL_ENOENT' => 'pcntl/pcntl.stub', 'PCNTL_ENOEXEC' => 'pcntl/pcntl.stub', 'PCNTL_ENOMEM' => 'pcntl/pcntl.stub', 'PCNTL_ENOSPC' => 'pcntl/pcntl.stub', 'PCNTL_ENOTDIR' => 'pcntl/pcntl.stub', 'PCNTL_EPERM' => 'pcntl/pcntl.stub', 'PCNTL_ESRCH' => 'pcntl/pcntl.stub', 'PCNTL_ETXTBSY' => 'pcntl/pcntl.stub', 'PCNTL_EUSERS' => 'pcntl/pcntl.stub', 'PCRE_JIT_SUPPORT' => 'pcre/pcre.stub', 'PCRE_VERSION' => 'pcre/pcre.stub', 'PCRE_VERSION_MAJOR' => 'pcre/pcre.stub', 'PCRE_VERSION_MINOR' => 'pcre/pcre.stub', 'PEAR_EXTENSION_DIR' => 'Core/Core_d.stub', 'PEAR_INSTALL_DIR' => 'Core/Core_d.stub', 'PGSQL_ASSOC' => 'pgsql/pgsql.stub', 'PGSQL_BAD_RESPONSE' => 'pgsql/pgsql.stub', 'PGSQL_BOTH' => 'pgsql/pgsql.stub', 'PGSQL_COMMAND_OK' => 'pgsql/pgsql.stub', 'PGSQL_CONNECTION_AUTH_OK' => 'pgsql/pgsql.stub', 'PGSQL_CONNECTION_AWAITING_RESPONSE' => 'pgsql/pgsql.stub', 'PGSQL_CONNECTION_BAD' => 'pgsql/pgsql.stub', 'PGSQL_CONNECTION_MADE' => 'pgsql/pgsql.stub', 'PGSQL_CONNECTION_OK' => 'pgsql/pgsql.stub', 'PGSQL_CONNECTION_SETENV' => 'pgsql/pgsql.stub', 'PGSQL_CONNECTION_STARTED' => 'pgsql/pgsql.stub', 'PGSQL_CONNECT_ASYNC' => 'pgsql/pgsql.stub', 'PGSQL_CONNECT_FORCE_NEW' => 'pgsql/pgsql.stub', 'PGSQL_CONV_FORCE_NULL' => 'pgsql/pgsql.stub', 'PGSQL_CONV_IGNORE_DEFAULT' => 'pgsql/pgsql.stub', 'PGSQL_CONV_IGNORE_NOT_NULL' => 'pgsql/pgsql.stub', 'PGSQL_COPY_IN' => 'pgsql/pgsql.stub', 'PGSQL_COPY_OUT' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_COLUMN_NAME' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_CONSTRAINT_NAME' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_CONTEXT' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_DATATYPE_NAME' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_INTERNAL_POSITION' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_INTERNAL_QUERY' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_MESSAGE_DETAIL' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_MESSAGE_HINT' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_MESSAGE_PRIMARY' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_SCHEMA_NAME' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_SEVERITY' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_SEVERITY_NONLOCALIZED' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_SOURCE_FILE' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_SOURCE_FUNCTION' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_SOURCE_LINE' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_SQLSTATE' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_STATEMENT_POSITION' => 'pgsql/pgsql.stub', 'PGSQL_DIAG_TABLE_NAME' => 'pgsql/pgsql.stub', 'PGSQL_DML_ASYNC' => 'pgsql/pgsql.stub', 'PGSQL_DML_ESCAPE' => 'pgsql/pgsql.stub', 'PGSQL_DML_EXEC' => 'pgsql/pgsql.stub', 'PGSQL_DML_NO_CONV' => 'pgsql/pgsql.stub', 'PGSQL_DML_STRING' => 'pgsql/pgsql.stub', 'PGSQL_EMPTY_QUERY' => 'pgsql/pgsql.stub', 'PGSQL_ERRORS_DEFAULT' => 'pgsql/pgsql.stub', 'PGSQL_ERRORS_SQLSTATE' => 'pgsql/pgsql.stub', 'PGSQL_ERRORS_TERSE' => 'pgsql/pgsql.stub', 'PGSQL_ERRORS_VERBOSE' => 'pgsql/pgsql.stub', 'PGSQL_FATAL_ERROR' => 'pgsql/pgsql.stub', 'PGSQL_LIBPQ_VERSION' => 'pgsql/pgsql.stub', 'PGSQL_LIBPQ_VERSION_STR' => 'pgsql/pgsql.stub', 'PGSQL_NONFATAL_ERROR' => 'pgsql/pgsql.stub', 'PGSQL_NOTICE_ALL' => 'pgsql/pgsql.stub', 'PGSQL_NOTICE_CLEAR' => 'pgsql/pgsql.stub', 'PGSQL_NOTICE_LAST' => 'pgsql/pgsql.stub', 'PGSQL_NUM' => 'pgsql/pgsql.stub', 'PGSQL_PIPELINE_ABORTED' => 'pgsql/pgsql.stub', 'PGSQL_PIPELINE_OFF' => 'pgsql/pgsql.stub', 'PGSQL_PIPELINE_ON' => 'pgsql/pgsql.stub', 'PGSQL_PIPELINE_SYNC' => 'pgsql/pgsql.stub', 'PGSQL_POLLING_ACTIVE' => 'pgsql/pgsql.stub', 'PGSQL_POLLING_FAILED' => 'pgsql/pgsql.stub', 'PGSQL_POLLING_OK' => 'pgsql/pgsql.stub', 'PGSQL_POLLING_READING' => 'pgsql/pgsql.stub', 'PGSQL_POLLING_WRITING' => 'pgsql/pgsql.stub', 'PGSQL_SEEK_CUR' => 'pgsql/pgsql.stub', 'PGSQL_SEEK_END' => 'pgsql/pgsql.stub', 'PGSQL_SEEK_SET' => 'pgsql/pgsql.stub', 'PGSQL_SHOW_CONTEXT_ALWAYS' => 'pgsql/pgsql.stub', 'PGSQL_SHOW_CONTEXT_ERRORS' => 'pgsql/pgsql.stub', 'PGSQL_SHOW_CONTEXT_NEVER' => 'pgsql/pgsql.stub', 'PGSQL_STATUS_LONG' => 'pgsql/pgsql.stub', 'PGSQL_STATUS_STRING' => 'pgsql/pgsql.stub', 'PGSQL_TRACE_REGRESS_MODE' => 'pgsql/pgsql.stub', 'PGSQL_TRANSACTION_ACTIVE' => 'pgsql/pgsql.stub', 'PGSQL_TRANSACTION_IDLE' => 'pgsql/pgsql.stub', 'PGSQL_TRANSACTION_INERROR' => 'pgsql/pgsql.stub', 'PGSQL_TRANSACTION_INTRANS' => 'pgsql/pgsql.stub', 'PGSQL_TRANSACTION_UNKNOWN' => 'pgsql/pgsql.stub', 'PGSQL_TUPLES_OK' => 'pgsql/pgsql.stub', 'PHP_AMQP_MAX_CHANNELS' => 'amqp/amqp.stub', 'PHP_BINARY' => 'Core/Core_d.stub', 'PHP_BINARY_READ' => 'sockets/sockets.stub', 'PHP_BINDIR' => 'Core/Core_d.stub', 'PHP_CLI_PROCESS_TITLE' => 'Core/Core_d.stub', 'PHP_CONFIG_FILE_PATH' => 'Core/Core_d.stub', 'PHP_CONFIG_FILE_SCAN_DIR' => 'Core/Core_d.stub', 'PHP_DATADIR' => 'Core/Core_d.stub', 'PHP_DEBUG' => 'Core/Core_d.stub', 'PHP_EOL' => 'Core/Core_d.stub', 'PHP_EXTENSION_DIR' => 'Core/Core_d.stub', 'PHP_EXTRA_VERSION' => 'Core/Core_d.stub', 'PHP_FD_SETSIZE' => 'Core/Core_d.stub', 'PHP_FLOAT_DIG' => 'Core/Core_d.stub', 'PHP_FLOAT_EPSILON' => 'Core/Core_d.stub', 'PHP_FLOAT_MAX' => 'Core/Core_d.stub', 'PHP_FLOAT_MIN' => 'Core/Core_d.stub', 'PHP_INT_MAX' => 'Core/Core_d.stub', 'PHP_INT_MIN' => 'Core/Core_d.stub', 'PHP_INT_SIZE' => 'Core/Core_d.stub', 'PHP_LIBDIR' => 'Core/Core_d.stub', 'PHP_LOCALSTATEDIR' => 'Core/Core_d.stub', 'PHP_MAJOR_VERSION' => 'Core/Core_d.stub', 'PHP_MANDIR' => 'Core/Core_d.stub', 'PHP_MAXPATHLEN' => 'Core/Core_d.stub', 'PHP_MINOR_VERSION' => 'Core/Core_d.stub', 'PHP_NORMAL_READ' => 'sockets/sockets.stub', 'PHP_OS' => 'Core/Core_d.stub', 'PHP_OS_FAMILY' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_CLEAN' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_CLEANABLE' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_CONT' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_DISABLED' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_END' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_FINAL' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_FLUSH' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_FLUSHABLE' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_PROCESSED' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_REMOVABLE' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_START' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_STARTED' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_STDFLAGS' => 'Core/Core_d.stub', 'PHP_OUTPUT_HANDLER_WRITE' => 'Core/Core_d.stub', 'PHP_PREFIX' => 'Core/Core_d.stub', 'PHP_QUERY_RFC1738' => 'standard/standard_defines.stub', 'PHP_QUERY_RFC3986' => 'standard/standard_defines.stub', 'PHP_RELEASE_VERSION' => 'Core/Core_d.stub', 'PHP_ROUND_HALF_DOWN' => 'standard/standard_defines.stub', 'PHP_ROUND_HALF_EVEN' => 'standard/standard_defines.stub', 'PHP_ROUND_HALF_ODD' => 'standard/standard_defines.stub', 'PHP_ROUND_HALF_UP' => 'standard/standard_defines.stub', 'PHP_SAPI' => 'Core/Core_d.stub', 'PHP_SBINDIR' => 'Core/Core_d.stub', 'PHP_SESSION_ACTIVE' => 'standard/standard_defines.stub', 'PHP_SESSION_DISABLED' => 'standard/standard_defines.stub', 'PHP_SESSION_NONE' => 'standard/standard_defines.stub', 'PHP_SHLIB_SUFFIX' => 'Core/Core_d.stub', 'PHP_SVN_AUTH_PARAM_IGNORE_SSL_VERIFY_ERRORS' => 'svn/svn.stub', 'PHP_SYSCONFDIR' => 'Core/Core_d.stub', 'PHP_URL_FRAGMENT' => 'standard/standard_defines.stub', 'PHP_URL_HOST' => 'standard/standard_defines.stub', 'PHP_URL_PASS' => 'standard/standard_defines.stub', 'PHP_URL_PATH' => 'standard/standard_defines.stub', 'PHP_URL_PORT' => 'standard/standard_defines.stub', 'PHP_URL_QUERY' => 'standard/standard_defines.stub', 'PHP_URL_SCHEME' => 'standard/standard_defines.stub', 'PHP_URL_USER' => 'standard/standard_defines.stub', 'PHP_VERSION' => 'Core/Core_d.stub', 'PHP_VERSION_ID' => 'Core/Core_d.stub', 'PHP_WINDOWS_EVENT_CTRL_BREAK' => 'Core/Core_d.stub', 'PHP_WINDOWS_EVENT_CTRL_C' => 'Core/Core_d.stub', 'PHP_WINDOWS_NT_DOMAIN_CONTROLLER' => 'Core/Core_d.stub', 'PHP_WINDOWS_NT_SERVER' => 'Core/Core_d.stub', 'PHP_WINDOWS_NT_WORKSTATION' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_BUILD' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_MAJOR' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_MINOR' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_PLATFORM' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_PRODUCTTYPE' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_SP_MAJOR' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_SP_MINOR' => 'Core/Core_d.stub', 'PHP_WINDOWS_VERSION_SUITEMASK' => 'Core/Core_d.stub', 'PHP_ZTS' => 'Core/Core_d.stub', 'PKCS7_BINARY' => 'openssl/openssl.stub', 'PKCS7_DETACHED' => 'openssl/openssl.stub', 'PKCS7_NOATTR' => 'openssl/openssl.stub', 'PKCS7_NOCERTS' => 'openssl/openssl.stub', 'PKCS7_NOCHAIN' => 'openssl/openssl.stub', 'PKCS7_NOINTERN' => 'openssl/openssl.stub', 'PKCS7_NOOLDMIMETYPE' => 'openssl/openssl.stub', 'PKCS7_NOSIGS' => 'openssl/openssl.stub', 'PKCS7_NOVERIFY' => 'openssl/openssl.stub', 'PKCS7_TEXT' => 'openssl/openssl.stub', 'PM_STR' => 'standard/standard_defines.stub', 'PNG_ALL_FILTERS' => 'gd/gd.stub', 'PNG_FILTER_AVG' => 'gd/gd.stub', 'PNG_FILTER_NONE' => 'gd/gd.stub', 'PNG_FILTER_PAETH' => 'gd/gd.stub', 'PNG_FILTER_SUB' => 'gd/gd.stub', 'PNG_FILTER_UP' => 'gd/gd.stub', 'PNG_NO_FILTER' => 'gd/gd.stub', 'POLL_ERR' => 'pcntl/pcntl.stub', 'POLL_HUP' => 'pcntl/pcntl.stub', 'POLL_IN' => 'pcntl/pcntl.stub', 'POLL_MSG' => 'pcntl/pcntl.stub', 'POLL_OUT' => 'pcntl/pcntl.stub', 'POLL_PRI' => 'pcntl/pcntl.stub', 'POSITIVE_SIGN' => 'standard/standard_defines.stub', 'POSIX_F_OK' => 'posix/posix.stub', 'POSIX_PC_ALLOC_SIZE_MIN' => 'posix/posix.stub', 'POSIX_PC_CHOWN_RESTRICTED' => 'posix/posix.stub', 'POSIX_PC_LINK_MAX' => 'posix/posix.stub', 'POSIX_PC_MAX_CANON' => 'posix/posix.stub', 'POSIX_PC_MAX_INPUT' => 'posix/posix.stub', 'POSIX_PC_NAME_MAX' => 'posix/posix.stub', 'POSIX_PC_NO_TRUNC' => 'posix/posix.stub', 'POSIX_PC_PATH_MAX' => 'posix/posix.stub', 'POSIX_PC_PIPE_BUF' => 'posix/posix.stub', 'POSIX_PC_SYMLINK_MAX' => 'posix/posix.stub', 'POSIX_RLIMIT_AS' => 'posix/posix.stub', 'POSIX_RLIMIT_CORE' => 'posix/posix.stub', 'POSIX_RLIMIT_CPU' => 'posix/posix.stub', 'POSIX_RLIMIT_DATA' => 'posix/posix.stub', 'POSIX_RLIMIT_FSIZE' => 'posix/posix.stub', 'POSIX_RLIMIT_INFINITY' => 'posix/posix.stub', 'POSIX_RLIMIT_LOCKS' => 'posix/posix.stub', 'POSIX_RLIMIT_MEMLOCK' => 'posix/posix.stub', 'POSIX_RLIMIT_MSGQUEUE' => 'posix/posix.stub', 'POSIX_RLIMIT_NICE' => 'posix/posix.stub', 'POSIX_RLIMIT_NOFILE' => 'posix/posix.stub', 'POSIX_RLIMIT_NPROC' => 'posix/posix.stub', 'POSIX_RLIMIT_RSS' => 'posix/posix.stub', 'POSIX_RLIMIT_RTPRIO' => 'posix/posix.stub', 'POSIX_RLIMIT_RTTIME' => 'posix/posix.stub', 'POSIX_RLIMIT_SIGPENDING' => 'posix/posix.stub', 'POSIX_RLIMIT_STACK' => 'posix/posix.stub', 'POSIX_R_OK' => 'posix/posix.stub', 'POSIX_SC_ARG_MAX' => 'posix/posix.stub', 'POSIX_SC_CHILD_MAX' => 'posix/posix.stub', 'POSIX_SC_CLK_TCK' => 'posix/posix.stub', 'POSIX_SC_NPROCESSORS_CONF' => 'posix/posix.stub', 'POSIX_SC_NPROCESSORS_ONLN' => 'posix/posix.stub', 'POSIX_SC_PAGESIZE' => 'posix/posix.stub', 'POSIX_S_IFBLK' => 'posix/posix.stub', 'POSIX_S_IFCHR' => 'posix/posix.stub', 'POSIX_S_IFIFO' => 'posix/posix.stub', 'POSIX_S_IFREG' => 'posix/posix.stub', 'POSIX_S_IFSOCK' => 'posix/posix.stub', 'POSIX_W_OK' => 'posix/posix.stub', 'POSIX_X_OK' => 'posix/posix.stub', 'PREG_BACKTRACK_LIMIT_ERROR' => 'pcre/pcre.stub', 'PREG_BAD_UTF8_ERROR' => 'pcre/pcre.stub', 'PREG_BAD_UTF8_OFFSET_ERROR' => 'pcre/pcre.stub', 'PREG_GREP_INVERT' => 'pcre/pcre.stub', 'PREG_INTERNAL_ERROR' => 'pcre/pcre.stub', 'PREG_JIT_STACKLIMIT_ERROR' => 'pcre/pcre.stub', 'PREG_NO_ERROR' => 'pcre/pcre.stub', 'PREG_OFFSET_CAPTURE' => 'pcre/pcre.stub', 'PREG_PATTERN_ORDER' => 'pcre/pcre.stub', 'PREG_RECURSION_LIMIT_ERROR' => 'pcre/pcre.stub', 'PREG_SET_ORDER' => 'pcre/pcre.stub', 'PREG_SPLIT_DELIM_CAPTURE' => 'pcre/pcre.stub', 'PREG_SPLIT_NO_EMPTY' => 'pcre/pcre.stub', 'PREG_SPLIT_OFFSET_CAPTURE' => 'pcre/pcre.stub', 'PREG_UNMATCHED_AS_NULL' => 'pcre/pcre.stub', 'PRIO_PGRP' => 'pcntl/pcntl.stub', 'PRIO_PROCESS' => 'pcntl/pcntl.stub', 'PRIO_USER' => 'pcntl/pcntl.stub', 'PSFS_ERR_FATAL' => 'standard/standard_defines.stub', 'PSFS_FEED_ME' => 'standard/standard_defines.stub', 'PSFS_FLAG_FLUSH_CLOSE' => 'standard/standard_defines.stub', 'PSFS_FLAG_FLUSH_INC' => 'standard/standard_defines.stub', 'PSFS_FLAG_NORMAL' => 'standard/standard_defines.stub', 'PSFS_PASS_ON' => 'standard/standard_defines.stub', 'PSPELL_BAD_SPELLERS' => 'pspell/pspell.stub', 'PSPELL_FAST' => 'pspell/pspell.stub', 'PSPELL_NORMAL' => 'pspell/pspell.stub', 'PSPELL_RUN_TOGETHER' => 'pspell/pspell.stub', 'PTHREADS_ALLOW_HEADERS' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_ALL' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_CLASSES' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_COMMENTS' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_CONSTANTS' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_FUNCTIONS' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_INCLUDES' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_INI' => 'pthreads/pthreads.stub', 'PTHREADS_INHERIT_NONE' => 'pthreads/pthreads.stub', 'P_ALL' => 'pcntl/pcntl.stub', 'P_CS_PRECEDES' => 'standard/standard_defines.stub', 'P_PGID' => 'pcntl/pcntl.stub', 'P_PID' => 'pcntl/pcntl.stub', 'P_PIDFD' => 'pcntl/pcntl.stub', 'P_SEP_BY_SPACE' => 'standard/standard_defines.stub', 'P_SIGN_POSN' => 'standard/standard_defines.stub', 'PopupWindow' => 'winbinder/winbinder.stub', 'PushButton' => 'winbinder/winbinder.stub', 'RADIUS_ACCESS_ACCEPT' => 'radius/radius.stub', 'RADIUS_ACCESS_CHALLENGE' => 'radius/radius.stub', 'RADIUS_ACCESS_REJECT' => 'radius/radius.stub', 'RADIUS_ACCESS_REQUEST' => 'radius/radius.stub', 'RADIUS_ACCOUNTING_OFF' => 'radius/radius.stub', 'RADIUS_ACCOUNTING_ON' => 'radius/radius.stub', 'RADIUS_ACCOUNTING_REQUEST' => 'radius/radius.stub', 'RADIUS_ACCOUNTING_RESPONSE' => 'radius/radius.stub', 'RADIUS_ACCT_AUTHENTIC' => 'radius/radius.stub', 'RADIUS_ACCT_DELAY_TIME' => 'radius/radius.stub', 'RADIUS_ACCT_INPUT_OCTETS' => 'radius/radius.stub', 'RADIUS_ACCT_INPUT_PACKETS' => 'radius/radius.stub', 'RADIUS_ACCT_LINK_COUNT' => 'radius/radius.stub', 'RADIUS_ACCT_MULTI_SESSION_ID' => 'radius/radius.stub', 'RADIUS_ACCT_OUTPUT_OCTETS' => 'radius/radius.stub', 'RADIUS_ACCT_OUTPUT_PACKETS' => 'radius/radius.stub', 'RADIUS_ACCT_SESSION_ID' => 'radius/radius.stub', 'RADIUS_ACCT_SESSION_TIME' => 'radius/radius.stub', 'RADIUS_ACCT_STATUS_TYPE' => 'radius/radius.stub', 'RADIUS_ACCT_TERMINATE_CAUSE' => 'radius/radius.stub', 'RADIUS_ADMINISTRATIVE' => 'radius/radius.stub', 'RADIUS_ADSL_CAP' => 'radius/radius.stub', 'RADIUS_ADSL_DMT' => 'radius/radius.stub', 'RADIUS_ARAP' => 'radius/radius.stub', 'RADIUS_ASYNC' => 'radius/radius.stub', 'RADIUS_AUTHENTICATE_ONLY' => 'radius/radius.stub', 'RADIUS_AUTH_LOCAL' => 'radius/radius.stub', 'RADIUS_AUTH_RADIUS' => 'radius/radius.stub', 'RADIUS_AUTH_REMOTE' => 'radius/radius.stub', 'RADIUS_CABLE' => 'radius/radius.stub', 'RADIUS_CALLBACK_FRAMED' => 'radius/radius.stub', 'RADIUS_CALLBACK_ID' => 'radius/radius.stub', 'RADIUS_CALLBACK_LOGIN' => 'radius/radius.stub', 'RADIUS_CALLBACK_NAS_PROMPT' => 'radius/radius.stub', 'RADIUS_CALLBACK_NUMBER' => 'radius/radius.stub', 'RADIUS_CALLED_STATION_ID' => 'radius/radius.stub', 'RADIUS_CALLING_STATION_ID' => 'radius/radius.stub', 'RADIUS_CHAP_CHALLENGE' => 'radius/radius.stub', 'RADIUS_CHAP_PASSWORD' => 'radius/radius.stub', 'RADIUS_CLASS' => 'radius/radius.stub', 'RADIUS_COA_ACK' => 'radius/radius.stub', 'RADIUS_COA_NAK' => 'radius/radius.stub', 'RADIUS_COA_REQUEST' => 'radius/radius.stub', 'RADIUS_COMP_IPXHDR' => 'radius/radius.stub', 'RADIUS_COMP_NONE' => 'radius/radius.stub', 'RADIUS_COMP_VJ' => 'radius/radius.stub', 'RADIUS_CONNECT_INFO' => 'radius/radius.stub', 'RADIUS_DISCONNECT_ACK' => 'radius/radius.stub', 'RADIUS_DISCONNECT_NAK' => 'radius/radius.stub', 'RADIUS_DISCONNECT_REQUEST' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_ADMINISTRATIVELY_PROHIBITED' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_INVALID_EAP_PACKET' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_INVALID_REQUEST' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_MISSING_ATTRIBUTE' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_NAS_IDENTIFICATION_MISMATCH' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_OTHER_PROXY_PROCESSING_ERROR' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_REQUEST_INITIATED' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_REQUEST_NOT_ROUTABLE' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_RESIDUAL_SESSION_CONTEXT_REMOVED' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_RESOURCES_UNAVAILABLE' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_SESSION_CONTEXT_NOT_FOUND' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_SESSION_CONTEXT_NOT_REMOVABLE' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_UNSUPPORTED_ATTRIBUTE' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_UNSUPPORTED_EXCEPTION' => 'radius/radius.stub', 'RADIUS_ERROR_CAUSE_UNSUPPORTED_SERVICE' => 'radius/radius.stub', 'RADIUS_ETHERNET' => 'radius/radius.stub', 'RADIUS_FILTER_ID' => 'radius/radius.stub', 'RADIUS_FRAMED' => 'radius/radius.stub', 'RADIUS_FRAMED_APPLETALK_LINK' => 'radius/radius.stub', 'RADIUS_FRAMED_APPLETALK_NETWORK' => 'radius/radius.stub', 'RADIUS_FRAMED_APPLETALK_ZONE' => 'radius/radius.stub', 'RADIUS_FRAMED_COMPRESSION' => 'radius/radius.stub', 'RADIUS_FRAMED_INTERFACE_ID' => 'radius/radius.stub', 'RADIUS_FRAMED_IPV6_POOL' => 'radius/radius.stub', 'RADIUS_FRAMED_IPV6_PREFIX' => 'radius/radius.stub', 'RADIUS_FRAMED_IPV6_ROUTE' => 'radius/radius.stub', 'RADIUS_FRAMED_IPX_NETWORK' => 'radius/radius.stub', 'RADIUS_FRAMED_IP_ADDRESS' => 'radius/radius.stub', 'RADIUS_FRAMED_IP_NETMASK' => 'radius/radius.stub', 'RADIUS_FRAMED_MTU' => 'radius/radius.stub', 'RADIUS_FRAMED_PROTOCOL' => 'radius/radius.stub', 'RADIUS_FRAMED_ROUTE' => 'radius/radius.stub', 'RADIUS_FRAMED_ROUTING' => 'radius/radius.stub', 'RADIUS_GANDALF' => 'radius/radius.stub', 'RADIUS_G_3_FAX' => 'radius/radius.stub', 'RADIUS_HDLC_CLEAR_CHANNEL' => 'radius/radius.stub', 'RADIUS_IDLE_TIMEOUT' => 'radius/radius.stub', 'RADIUS_IDSL' => 'radius/radius.stub', 'RADIUS_ISDN_ASYNC_V110' => 'radius/radius.stub', 'RADIUS_ISDN_ASYNC_V120' => 'radius/radius.stub', 'RADIUS_ISDN_SYNC' => 'radius/radius.stub', 'RADIUS_LOGIN' => 'radius/radius.stub', 'RADIUS_LOGIN_IPV6_HOST' => 'radius/radius.stub', 'RADIUS_LOGIN_IP_HOST' => 'radius/radius.stub', 'RADIUS_LOGIN_LAT_GROUP' => 'radius/radius.stub', 'RADIUS_LOGIN_LAT_NODE' => 'radius/radius.stub', 'RADIUS_LOGIN_LAT_PORT' => 'radius/radius.stub', 'RADIUS_LOGIN_LAT_SERVICE' => 'radius/radius.stub', 'RADIUS_LOGIN_SERVICE' => 'radius/radius.stub', 'RADIUS_LOGIN_TCP_PORT' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_ACCT_AUTH_TYPE' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_ACCT_EAP_TYPE' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_ARAP_CHALLENGE' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_ARAP_PASSWORD_CHANGE_REASON' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_BAP_USAGE' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP2_PW' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP2_RESPONSE' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP2_SUCCESS' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_CHALLENGE' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_DOMAIN' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_ERROR' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_LM_ENC_PW' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_MPPE_KEYS' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_NT_ENC_PW' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_PW_1' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_PW_2' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_CHAP_RESPONSE' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_FILTER' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_LINK_DROP_TIME_LIMIT' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_LINK_UTILIZATION_THRESHOLD' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_MPPE_ENCRYPTION_POLICY' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_MPPE_ENCRYPTION_TYPES' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_MPPE_RECV_KEY' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_MPPE_SEND_KEY' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_NEW_ARAP_PASSWORD' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_OLD_ARAP_PASSWORD' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_PRIMARY_DNS_SERVER' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_PRIMARY_NBNS_SERVER' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_RAS_VENDOR' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_RAS_VERSION' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_SECONDARY_DNS_SERVER' => 'radius/radius.stub', 'RADIUS_MICROSOFT_MS_SECONDARY_NBNS_SERVER' => 'radius/radius.stub', 'RADIUS_MPPE_KEY_LEN' => 'radius/radius.stub', 'RADIUS_NAS_IDENTIFIER' => 'radius/radius.stub', 'RADIUS_NAS_IPV6_ADDRESS' => 'radius/radius.stub', 'RADIUS_NAS_IP_ADDRESS' => 'radius/radius.stub', 'RADIUS_NAS_PORT' => 'radius/radius.stub', 'RADIUS_NAS_PORT_TYPE' => 'radius/radius.stub', 'RADIUS_NAS_PROMPT' => 'radius/radius.stub', 'RADIUS_OPTION_NONE' => 'radius/radius.stub', 'RADIUS_OPTION_SALT' => 'radius/radius.stub', 'RADIUS_OPTION_TAGGED' => 'radius/radius.stub', 'RADIUS_OUTBOUND' => 'radius/radius.stub', 'RADIUS_PIAFS' => 'radius/radius.stub', 'RADIUS_PORT_LIMIT' => 'radius/radius.stub', 'RADIUS_PPP' => 'radius/radius.stub', 'RADIUS_PROXY_STATE' => 'radius/radius.stub', 'RADIUS_REPLY_MESSAGE' => 'radius/radius.stub', 'RADIUS_SDSL' => 'radius/radius.stub', 'RADIUS_SERVICE_TYPE' => 'radius/radius.stub', 'RADIUS_SESSION_TIMEOUT' => 'radius/radius.stub', 'RADIUS_SLIP' => 'radius/radius.stub', 'RADIUS_START' => 'radius/radius.stub', 'RADIUS_STATE' => 'radius/radius.stub', 'RADIUS_STOP' => 'radius/radius.stub', 'RADIUS_SYNC' => 'radius/radius.stub', 'RADIUS_TERMINATION_ACTION' => 'radius/radius.stub', 'RADIUS_TERM_ADMIN_REBOOT' => 'radius/radius.stub', 'RADIUS_TERM_ADMIN_RESET' => 'radius/radius.stub', 'RADIUS_TERM_CALLBACK' => 'radius/radius.stub', 'RADIUS_TERM_HOST_REQUEST' => 'radius/radius.stub', 'RADIUS_TERM_IDLE_TIMEOUT' => 'radius/radius.stub', 'RADIUS_TERM_LOST_CARRIER' => 'radius/radius.stub', 'RADIUS_TERM_LOST_SERVICE' => 'radius/radius.stub', 'RADIUS_TERM_NAS_ERROR' => 'radius/radius.stub', 'RADIUS_TERM_NAS_REBOOT' => 'radius/radius.stub', 'RADIUS_TERM_NAS_REQUEST' => 'radius/radius.stub', 'RADIUS_TERM_PORT_ERROR' => 'radius/radius.stub', 'RADIUS_TERM_PORT_PREEMPTED' => 'radius/radius.stub', 'RADIUS_TERM_PORT_SUSPENDED' => 'radius/radius.stub', 'RADIUS_TERM_PORT_UNNEEDED' => 'radius/radius.stub', 'RADIUS_TERM_SERVICE_UNAVAILABLE' => 'radius/radius.stub', 'RADIUS_TERM_SESSION_TIMEOUT' => 'radius/radius.stub', 'RADIUS_TERM_USER_ERROR' => 'radius/radius.stub', 'RADIUS_TERM_USER_REQUEST' => 'radius/radius.stub', 'RADIUS_USER_NAME' => 'radius/radius.stub', 'RADIUS_USER_PASSWORD' => 'radius/radius.stub', 'RADIUS_VENDOR_MICROSOFT' => 'radius/radius.stub', 'RADIUS_VENDOR_SPECIFIC' => 'radius/radius.stub', 'RADIUS_VIRTUAL' => 'radius/radius.stub', 'RADIUS_WIRELESS_IEEE_802_11' => 'radius/radius.stub', 'RADIUS_WIRELESS_OTHER' => 'radius/radius.stub', 'RADIUS_XDSL' => 'radius/radius.stub', 'RADIUS_XYLOGICS' => 'radius/radius.stub', 'RADIUS_X_25' => 'radius/radius.stub', 'RADIUS_X_75' => 'radius/radius.stub', 'RADIXCHAR' => 'standard/standard_defines.stub', 'RAD_OPTION_TAG' => 'radius/radius.stub', 'RD_KAFKA_BUILD_VERSION' => 'rdkafka/constants.stub', 'RD_KAFKA_CONF_INVALID' => 'rdkafka/constants.stub', 'RD_KAFKA_CONF_OK' => 'rdkafka/constants.stub', 'RD_KAFKA_CONF_UNKNOWN' => 'rdkafka/constants.stub', 'RD_KAFKA_CONSUMER' => 'rdkafka/constants.stub', 'RD_KAFKA_LOG_PRINT' => 'rdkafka/constants.stub', 'RD_KAFKA_LOG_SYSLOG' => 'rdkafka/constants.stub', 'RD_KAFKA_LOG_SYSLOG_PRINT' => 'rdkafka/constants.stub', 'RD_KAFKA_MSG_F_BLOCK' => 'rdkafka/constants.stub', 'RD_KAFKA_MSG_PARTITIONER_CONSISTENT' => 'rdkafka/constants.stub', 'RD_KAFKA_MSG_PARTITIONER_CONSISTENT_RANDOM' => 'rdkafka/constants.stub', 'RD_KAFKA_MSG_PARTITIONER_MURMUR2' => 'rdkafka/constants.stub', 'RD_KAFKA_MSG_PARTITIONER_MURMUR2_RANDOM' => 'rdkafka/constants.stub', 'RD_KAFKA_MSG_PARTITIONER_RANDOM' => 'rdkafka/constants.stub', 'RD_KAFKA_OFFSET_BEGINNING' => 'rdkafka/constants.stub', 'RD_KAFKA_OFFSET_END' => 'rdkafka/constants.stub', 'RD_KAFKA_OFFSET_INVALID' => 'rdkafka/constants.stub', 'RD_KAFKA_OFFSET_STORED' => 'rdkafka/constants.stub', 'RD_KAFKA_PARTITION_UA' => 'rdkafka/constants.stub', 'RD_KAFKA_PRODUCER' => 'rdkafka/constants.stub', 'RD_KAFKA_PURGE_F_INFLIGHT' => 'rdkafka/constants.stub', 'RD_KAFKA_PURGE_F_NON_BLOCKING' => 'rdkafka/constants.stub', 'RD_KAFKA_PURGE_F_QUEUE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_BROKER_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_CLUSTER_AUTHORIZATION_FAILED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_COORDINATOR_LOAD_IN_PROGRESS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTHORIZATION_FAILED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTH_DISABLED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_EXPIRED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_NOT_FOUND' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_OWNER_MISMATCH' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_REQUEST_NOT_ALLOWED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DUPLICATE_RESOURCE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_DUPLICATE_SEQUENCE_NUMBER' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_ELECTION_NOT_NEEDED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_ELIGIBLE_LEADERS_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_FEATURE_UPDATE_FAILED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_FENCED_INSTANCE_ID' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_FENCED_LEADER_EPOCH' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_FETCH_SESSION_ID_NOT_FOUND' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_GROUP_AUTHORIZATION_FAILED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_GROUP_COORDINATOR_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_GROUP_LOAD_IN_PROGRESS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_GROUP_MAX_SIZE_REACHED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_GROUP_SUBSCRIBED_TO_TOPIC' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_ILLEGAL_SASL_STATE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INCONSISTENT_GROUP_PROTOCOL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INCONSISTENT_VOTER_SET' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_COMMIT_OFFSET_SIZE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_CONFIG' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_FETCH_SESSION_EPOCH' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_GROUP_ID' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_MSG' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_MSG_SIZE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_PARTITIONS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_PRINCIPAL_TYPE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_PRODUCER_ID_MAPPING' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_RECORD' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_REPLICATION_FACTOR' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_REPLICA_ASSIGNMENT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_REQUEST' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_REQUIRED_ACKS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_SESSION_TIMEOUT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_TIMESTAMP' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_TRANSACTION_TIMEOUT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_TXN_STATE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_INVALID_UPDATE_VERSION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_KAFKA_STORAGE_ERROR' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_LEADER_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_LISTENER_NOT_FOUND' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_LOG_DIR_NOT_FOUND' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_MEMBER_ID_REQUIRED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NETWORK_EXCEPTION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NON_EMPTY_GROUP' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NOT_CONTROLLER' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NOT_COORDINATOR' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NOT_COORDINATOR_FOR_GROUP' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS_AFTER_APPEND' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NO_ERROR' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_NO_REASSIGNMENT_IN_PROGRESS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_OFFSET_METADATA_TOO_LARGE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_OFFSET_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_OFFSET_OUT_OF_RANGE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_OPERATION_NOT_ATTEMPTED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_OUT_OF_ORDER_SEQUENCE_NUMBER' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_POLICY_VIOLATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_PREFERRED_LEADER_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_PRINCIPAL_DESERIALIZATION_FAILURE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_PRODUCER_FENCED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_REASSIGNMENT_IN_PROGRESS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_REBALANCE_IN_PROGRESS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_RECORD_LIST_TOO_LARGE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_REPLICA_NOT_AVAILABLE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_REQUEST_TIMED_OUT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_RESOURCE_NOT_FOUND' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_SASL_AUTHENTICATION_FAILED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_SECURITY_DISABLED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_STALE_BROKER_EPOCH' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_STALE_CTRL_EPOCH' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_THROTTLING_QUOTA_EXCEEDED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_TOPIC_ALREADY_EXISTS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_TOPIC_AUTHORIZATION_FAILED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_TOPIC_DELETION_DISABLED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_TOPIC_EXCEPTION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_TRANSACTIONAL_ID_AUTHORIZATION_FAILED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_TRANSACTION_COORDINATOR_FENCED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNACCEPTABLE_CREDENTIAL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNKNOWN' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNKNOWN_LEADER_EPOCH' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNKNOWN_PRODUCER_ID' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNSTABLE_OFFSET_COMMIT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNSUPPORTED_COMPRESSION_TYPE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNSUPPORTED_FOR_MESSAGE_FORMAT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNSUPPORTED_SASL_MECHANISM' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR_UNSUPPORTED_VERSION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__APPLICATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__ASSIGNMENT_LOST' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__AUTHENTICATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__AUTO_OFFSET_RESET' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__BAD_COMPRESSION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__BAD_MSG' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__BEGIN' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__CONFLICT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__CRIT_SYS_RESOURCE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__DESTROY' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__END' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__EXISTING_SUBSCRIPTION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__FAIL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__FATAL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__FENCED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__FS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__GAPLESS_GUARANTEE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__INCONSISTENT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__INTR' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__INVALID_ARG' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__INVALID_TYPE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__IN_PROGRESS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__ISR_INSUFF' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__KEY_DESERIALIZATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__KEY_SERIALIZATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__MSG_TIMED_OUT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__NODE_UPDATE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__NOENT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__NOOP' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__NOT_CONFIGURED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__NO_OFFSET' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__OUTDATED' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__PARTIAL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__PARTITION_EOF' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__PREV_IN_PROGRESS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__PURGE_INFLIGHT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__PURGE_QUEUE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__QUEUE_FULL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__READ_ONLY' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__RESOLVE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__RETRY' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__SSL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__STATE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__TIMED_OUT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__TIMED_OUT_QUEUE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__TRANSPORT' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__UNDERFLOW' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__UNKNOWN_BROKER' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__UNKNOWN_GROUP' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__UNKNOWN_PROTOCOL' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__UNSUPPORTED_FEATURE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__VALUE_DESERIALIZATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__VALUE_SERIALIZATION' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__WAIT_CACHE' => 'rdkafka/constants.stub', 'RD_KAFKA_RESP_ERR__WAIT_COORD' => 'rdkafka/constants.stub', 'RD_KAFKA_VERSION' => 'rdkafka/constants.stub', 'READLINE_LIB' => 'readline/readline.stub', 'RED' => 'winbinder/winbinder.stub', 'RPMMIRE_DEFAULT' => 'rpminfo/rpminfo.stub', 'RPMMIRE_GLOB' => 'rpminfo/rpminfo.stub', 'RPMMIRE_REGEX' => 'rpminfo/rpminfo.stub', 'RPMMIRE_STRCMP' => 'rpminfo/rpminfo.stub', 'RPMSENSE_ANY' => 'rpminfo/rpminfo.stub', 'RPMSENSE_CONFIG' => 'rpminfo/rpminfo.stub', 'RPMSENSE_EQUAL' => 'rpminfo/rpminfo.stub', 'RPMSENSE_FIND_PROVIDES' => 'rpminfo/rpminfo.stub', 'RPMSENSE_FIND_REQUIRES' => 'rpminfo/rpminfo.stub', 'RPMSENSE_GREATER' => 'rpminfo/rpminfo.stub', 'RPMSENSE_INTERP' => 'rpminfo/rpminfo.stub', 'RPMSENSE_KEYRING' => 'rpminfo/rpminfo.stub', 'RPMSENSE_LESS' => 'rpminfo/rpminfo.stub', 'RPMSENSE_MISSINGOK' => 'rpminfo/rpminfo.stub', 'RPMSENSE_POSTTRANS' => 'rpminfo/rpminfo.stub', 'RPMSENSE_PREREQ' => 'rpminfo/rpminfo.stub', 'RPMSENSE_PRETRANS' => 'rpminfo/rpminfo.stub', 'RPMSENSE_RPMLIB' => 'rpminfo/rpminfo.stub', 'RPMSENSE_SCRIPT_POST' => 'rpminfo/rpminfo.stub', 'RPMSENSE_SCRIPT_POSTUN' => 'rpminfo/rpminfo.stub', 'RPMSENSE_SCRIPT_PRE' => 'rpminfo/rpminfo.stub', 'RPMSENSE_SCRIPT_PREUN' => 'rpminfo/rpminfo.stub', 'RPMSENSE_SCRIPT_VERIFY' => 'rpminfo/rpminfo.stub', 'RPMSENSE_TRIGGERIN' => 'rpminfo/rpminfo.stub', 'RPMSENSE_TRIGGERPOSTUN' => 'rpminfo/rpminfo.stub', 'RPMSENSE_TRIGGERPREIN' => 'rpminfo/rpminfo.stub', 'RPMSENSE_TRIGGERUN' => 'rpminfo/rpminfo.stub', 'RPMTAG_ARCH' => 'rpminfo/rpminfo.stub', 'RPMTAG_ARCHIVESIZE' => 'rpminfo/rpminfo.stub', 'RPMTAG_BASENAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_BUGURL' => 'rpminfo/rpminfo.stub', 'RPMTAG_BUILDARCHS' => 'rpminfo/rpminfo.stub', 'RPMTAG_BUILDHOST' => 'rpminfo/rpminfo.stub', 'RPMTAG_BUILDTIME' => 'rpminfo/rpminfo.stub', 'RPMTAG_C' => 'rpminfo/rpminfo.stub', 'RPMTAG_CHANGELOGNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_CHANGELOGTEXT' => 'rpminfo/rpminfo.stub', 'RPMTAG_CHANGELOGTIME' => 'rpminfo/rpminfo.stub', 'RPMTAG_CLASSDICT' => 'rpminfo/rpminfo.stub', 'RPMTAG_CONFLICTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_CONFLICTNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_CONFLICTNEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_CONFLICTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_CONFLICTVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_COOKIE' => 'rpminfo/rpminfo.stub', 'RPMTAG_DBINSTANCE' => 'rpminfo/rpminfo.stub', 'RPMTAG_DEPENDSDICT' => 'rpminfo/rpminfo.stub', 'RPMTAG_DESCRIPTION' => 'rpminfo/rpminfo.stub', 'RPMTAG_DIRINDEXES' => 'rpminfo/rpminfo.stub', 'RPMTAG_DIRNAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_DISTRIBUTION' => 'rpminfo/rpminfo.stub', 'RPMTAG_DISTTAG' => 'rpminfo/rpminfo.stub', 'RPMTAG_DISTURL' => 'rpminfo/rpminfo.stub', 'RPMTAG_DSAHEADER' => 'rpminfo/rpminfo.stub', 'RPMTAG_E' => 'rpminfo/rpminfo.stub', 'RPMTAG_ENCODING' => 'rpminfo/rpminfo.stub', 'RPMTAG_ENHANCEFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_ENHANCENAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_ENHANCENEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_ENHANCES' => 'rpminfo/rpminfo.stub', 'RPMTAG_ENHANCEVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_EPOCH' => 'rpminfo/rpminfo.stub', 'RPMTAG_EPOCHNUM' => 'rpminfo/rpminfo.stub', 'RPMTAG_EVR' => 'rpminfo/rpminfo.stub', 'RPMTAG_EXCLUDEARCH' => 'rpminfo/rpminfo.stub', 'RPMTAG_EXCLUDEOS' => 'rpminfo/rpminfo.stub', 'RPMTAG_EXCLUSIVEARCH' => 'rpminfo/rpminfo.stub', 'RPMTAG_EXCLUSIVEOS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILECAPS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILECLASS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILECOLORS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILECONTEXTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEDEPENDSN' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEDEPENDSX' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEDEVICES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEDIGESTALGO' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEDIGESTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEGROUPNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEINODES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILELANGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILELINKTOS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEMD5S' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEMODES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEMTIMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILENAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILENLINKS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEPROVIDE' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILERDEVS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEREQUIRE' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILESIGNATURELENGTH' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILESIGNATURES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILESIZES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILESTATES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERCONDS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERINDEX' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERPRIORITIES' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERSCRIPTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERSCRIPTPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERSCRIPTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERTYPE' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILETRIGGERVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEUSERNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_FILEVERIFYFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_FSCONTEXTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_GIF' => 'rpminfo/rpminfo.stub', 'RPMTAG_GROUP' => 'rpminfo/rpminfo.stub', 'RPMTAG_HDRID' => 'rpminfo/rpminfo.stub', 'RPMTAG_HEADERCOLOR' => 'rpminfo/rpminfo.stub', 'RPMTAG_HEADERI18NTABLE' => 'rpminfo/rpminfo.stub', 'RPMTAG_HEADERIMAGE' => 'rpminfo/rpminfo.stub', 'RPMTAG_HEADERIMMUTABLE' => 'rpminfo/rpminfo.stub', 'RPMTAG_HEADERREGIONS' => 'rpminfo/rpminfo.stub', 'RPMTAG_HEADERSIGNATURES' => 'rpminfo/rpminfo.stub', 'RPMTAG_ICON' => 'rpminfo/rpminfo.stub', 'RPMTAG_INSTALLCOLOR' => 'rpminfo/rpminfo.stub', 'RPMTAG_INSTALLTID' => 'rpminfo/rpminfo.stub', 'RPMTAG_INSTALLTIME' => 'rpminfo/rpminfo.stub', 'RPMTAG_INSTFILENAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_INSTPREFIXES' => 'rpminfo/rpminfo.stub', 'RPMTAG_LICENSE' => 'rpminfo/rpminfo.stub', 'RPMTAG_LONGARCHIVESIZE' => 'rpminfo/rpminfo.stub', 'RPMTAG_LONGFILESIZES' => 'rpminfo/rpminfo.stub', 'RPMTAG_LONGSIGSIZE' => 'rpminfo/rpminfo.stub', 'RPMTAG_LONGSIZE' => 'rpminfo/rpminfo.stub', 'RPMTAG_MODULARITYLABEL' => 'rpminfo/rpminfo.stub', 'RPMTAG_N' => 'rpminfo/rpminfo.stub', 'RPMTAG_NAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_NEVR' => 'rpminfo/rpminfo.stub', 'RPMTAG_NEVRA' => 'rpminfo/rpminfo.stub', 'RPMTAG_NOPATCH' => 'rpminfo/rpminfo.stub', 'RPMTAG_NOSOURCE' => 'rpminfo/rpminfo.stub', 'RPMTAG_NVR' => 'rpminfo/rpminfo.stub', 'RPMTAG_NVRA' => 'rpminfo/rpminfo.stub', 'RPMTAG_O' => 'rpminfo/rpminfo.stub', 'RPMTAG_OBSOLETEFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_OBSOLETENAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_OBSOLETENEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_OBSOLETES' => 'rpminfo/rpminfo.stub', 'RPMTAG_OBSOLETEVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDENHANCES' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDENHANCESFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDENHANCESNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDENHANCESVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDFILENAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDSUGGESTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDSUGGESTSFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDSUGGESTSNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_OLDSUGGESTSVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_OPTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_ORDERFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_ORDERNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_ORDERVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_ORIGBASENAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_ORIGDIRINDEXES' => 'rpminfo/rpminfo.stub', 'RPMTAG_ORIGDIRNAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_ORIGFILENAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_OS' => 'rpminfo/rpminfo.stub', 'RPMTAG_P' => 'rpminfo/rpminfo.stub', 'RPMTAG_PACKAGER' => 'rpminfo/rpminfo.stub', 'RPMTAG_PATCH' => 'rpminfo/rpminfo.stub', 'RPMTAG_PATCHESFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PATCHESNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_PATCHESVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_PAYLOADCOMPRESSOR' => 'rpminfo/rpminfo.stub', 'RPMTAG_PAYLOADDIGEST' => 'rpminfo/rpminfo.stub', 'RPMTAG_PAYLOADDIGESTALGO' => 'rpminfo/rpminfo.stub', 'RPMTAG_PAYLOADFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PAYLOADFORMAT' => 'rpminfo/rpminfo.stub', 'RPMTAG_PKGID' => 'rpminfo/rpminfo.stub', 'RPMTAG_PLATFORM' => 'rpminfo/rpminfo.stub', 'RPMTAG_POLICIES' => 'rpminfo/rpminfo.stub', 'RPMTAG_POLICYFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_POLICYNAMES' => 'rpminfo/rpminfo.stub', 'RPMTAG_POLICYTYPES' => 'rpminfo/rpminfo.stub', 'RPMTAG_POLICYTYPESINDEXES' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTIN' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTINFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTINPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTTRANS' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTTRANSFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTTRANSPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTUN' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTUNFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_POSTUNPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_PREFIXES' => 'rpminfo/rpminfo.stub', 'RPMTAG_PREIN' => 'rpminfo/rpminfo.stub', 'RPMTAG_PREINFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PREINPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_PRETRANS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PRETRANSFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PRETRANSPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_PREUN' => 'rpminfo/rpminfo.stub', 'RPMTAG_PREUNFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PREUNPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_PROVIDEFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PROVIDENAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_PROVIDENEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_PROVIDES' => 'rpminfo/rpminfo.stub', 'RPMTAG_PROVIDEVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_PUBKEYS' => 'rpminfo/rpminfo.stub', 'RPMTAG_R' => 'rpminfo/rpminfo.stub', 'RPMTAG_RECOMMENDFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_RECOMMENDNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_RECOMMENDNEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_RECOMMENDS' => 'rpminfo/rpminfo.stub', 'RPMTAG_RECOMMENDVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_RECONTEXTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_RELEASE' => 'rpminfo/rpminfo.stub', 'RPMTAG_REMOVETID' => 'rpminfo/rpminfo.stub', 'RPMTAG_REQUIREFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_REQUIRENAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_REQUIRENEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_REQUIRES' => 'rpminfo/rpminfo.stub', 'RPMTAG_REQUIREVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_RPMVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_RSAHEADER' => 'rpminfo/rpminfo.stub', 'RPMTAG_SHA1HEADER' => 'rpminfo/rpminfo.stub', 'RPMTAG_SHA256HEADER' => 'rpminfo/rpminfo.stub', 'RPMTAG_SIGGPG' => 'rpminfo/rpminfo.stub', 'RPMTAG_SIGMD5' => 'rpminfo/rpminfo.stub', 'RPMTAG_SIGPGP' => 'rpminfo/rpminfo.stub', 'RPMTAG_SIGSIZE' => 'rpminfo/rpminfo.stub', 'RPMTAG_SIZE' => 'rpminfo/rpminfo.stub', 'RPMTAG_SOURCE' => 'rpminfo/rpminfo.stub', 'RPMTAG_SOURCEPACKAGE' => 'rpminfo/rpminfo.stub', 'RPMTAG_SOURCEPKGID' => 'rpminfo/rpminfo.stub', 'RPMTAG_SOURCERPM' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUGGESTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUGGESTNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUGGESTNEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUGGESTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUGGESTVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUMMARY' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUPPLEMENTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUPPLEMENTNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUPPLEMENTNEVRS' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUPPLEMENTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_SUPPLEMENTVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERCONDS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERINDEX' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERPRIORITIES' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERSCRIPTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERSCRIPTPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERSCRIPTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERTYPE' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRANSFILETRIGGERVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERCONDS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERINDEX' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERNAME' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERSCRIPTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERSCRIPTPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERSCRIPTS' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERTYPE' => 'rpminfo/rpminfo.stub', 'RPMTAG_TRIGGERVERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_URL' => 'rpminfo/rpminfo.stub', 'RPMTAG_V' => 'rpminfo/rpminfo.stub', 'RPMTAG_VCS' => 'rpminfo/rpminfo.stub', 'RPMTAG_VENDOR' => 'rpminfo/rpminfo.stub', 'RPMTAG_VERBOSE' => 'rpminfo/rpminfo.stub', 'RPMTAG_VERIFYSCRIPT' => 'rpminfo/rpminfo.stub', 'RPMTAG_VERIFYSCRIPTFLAGS' => 'rpminfo/rpminfo.stub', 'RPMTAG_VERIFYSCRIPTPROG' => 'rpminfo/rpminfo.stub', 'RPMTAG_VERSION' => 'rpminfo/rpminfo.stub', 'RPMTAG_XPM' => 'rpminfo/rpminfo.stub', 'RPMVERSION' => 'rpminfo/rpminfo.stub', 'RTFEditBox' => 'winbinder/winbinder.stub', 'RadioButton' => 'winbinder/winbinder.stub', 'ResizableWindow' => 'winbinder/winbinder.stub', 'SA_ALL' => 'imap/imap.stub', 'SA_MESSAGES' => 'imap/imap.stub', 'SA_RECENT' => 'imap/imap.stub', 'SA_UIDNEXT' => 'imap/imap.stub', 'SA_UIDVALIDITY' => 'imap/imap.stub', 'SA_UNSEEN' => 'imap/imap.stub', 'SCANDIR_SORT_ASCENDING' => 'standard/standard_defines.stub', 'SCANDIR_SORT_DESCENDING' => 'standard/standard_defines.stub', 'SCANDIR_SORT_NONE' => 'standard/standard_defines.stub', 'SCM_CREDENTIALS' => 'sockets/sockets.stub', 'SCM_RIGHTS' => 'sockets/sockets.stub', 'SEEK_CUR' => 'standard/standard_defines.stub', 'SEEK_END' => 'standard/standard_defines.stub', 'SEEK_SET' => 'standard/standard_defines.stub', 'SEGV_ACCERR' => 'pcntl/pcntl.stub', 'SEGV_MAPERR' => 'pcntl/pcntl.stub', 'SE_FREE' => 'imap/imap.stub', 'SE_NOPREFETCH' => 'imap/imap.stub', 'SE_UID' => 'imap/imap.stub', 'SID' => 'standard/standard_defines.stub', 'SIGABRT' => 'pcntl/pcntl.stub', 'SIGALRM' => 'pcntl/pcntl.stub', 'SIGBABY' => 'pcntl/pcntl.stub', 'SIGBUS' => 'pcntl/pcntl.stub', 'SIGCHLD' => 'pcntl/pcntl.stub', 'SIGCLD' => 'pcntl/pcntl.stub', 'SIGCONT' => 'pcntl/pcntl.stub', 'SIGFPE' => 'pcntl/pcntl.stub', 'SIGHUP' => 'pcntl/pcntl.stub', 'SIGILL' => 'pcntl/pcntl.stub', 'SIGINT' => 'pcntl/pcntl.stub', 'SIGIO' => 'pcntl/pcntl.stub', 'SIGIOT' => 'pcntl/pcntl.stub', 'SIGKILL' => 'pcntl/pcntl.stub', 'SIGPIPE' => 'pcntl/pcntl.stub', 'SIGPOLL' => 'pcntl/pcntl.stub', 'SIGPROF' => 'pcntl/pcntl.stub', 'SIGPWR' => 'pcntl/pcntl.stub', 'SIGQUIT' => 'pcntl/pcntl.stub', 'SIGRTMAX' => 'pcntl/pcntl.stub', 'SIGRTMIN' => 'pcntl/pcntl.stub', 'SIGSEGV' => 'pcntl/pcntl.stub', 'SIGSTKFLT' => 'pcntl/pcntl.stub', 'SIGSTOP' => 'pcntl/pcntl.stub', 'SIGSYS' => 'pcntl/pcntl.stub', 'SIGTERM' => 'pcntl/pcntl.stub', 'SIGTRAP' => 'pcntl/pcntl.stub', 'SIGTSTP' => 'pcntl/pcntl.stub', 'SIGTTIN' => 'pcntl/pcntl.stub', 'SIGTTOU' => 'pcntl/pcntl.stub', 'SIGURG' => 'pcntl/pcntl.stub', 'SIGUSR1' => 'pcntl/pcntl.stub', 'SIGUSR2' => 'pcntl/pcntl.stub', 'SIGVTALRM' => 'pcntl/pcntl.stub', 'SIGWINCH' => 'pcntl/pcntl.stub', 'SIGXCPU' => 'pcntl/pcntl.stub', 'SIGXFSZ' => 'pcntl/pcntl.stub', 'SIG_BLOCK' => 'pcntl/pcntl.stub', 'SIG_DFL' => 'pcntl/pcntl.stub', 'SIG_ERR' => 'pcntl/pcntl.stub', 'SIG_IGN' => 'pcntl/pcntl.stub', 'SIG_SETMASK' => 'pcntl/pcntl.stub', 'SIG_UNBLOCK' => 'pcntl/pcntl.stub', 'SI_ASYNCIO' => 'pcntl/pcntl.stub', 'SI_KERNEL' => 'pcntl/pcntl.stub', 'SI_MESGQ' => 'pcntl/pcntl.stub', 'SI_QUEUE' => 'pcntl/pcntl.stub', 'SI_SIGIO' => 'pcntl/pcntl.stub', 'SI_TIMER' => 'pcntl/pcntl.stub', 'SI_TKILL' => 'pcntl/pcntl.stub', 'SI_USER' => 'pcntl/pcntl.stub', 'SKF_AD_ALU_XOR_X' => 'sockets/sockets.stub', 'SKF_AD_CPU' => 'sockets/sockets.stub', 'SKF_AD_HATYPE' => 'sockets/sockets.stub', 'SKF_AD_IFINDEX' => 'sockets/sockets.stub', 'SKF_AD_MARK' => 'sockets/sockets.stub', 'SKF_AD_MAX' => 'sockets/sockets.stub', 'SKF_AD_NLATTR' => 'sockets/sockets.stub', 'SKF_AD_NLATTR_NEST' => 'sockets/sockets.stub', 'SKF_AD_OFF' => 'sockets/sockets.stub', 'SKF_AD_PAY_OFFSET' => 'sockets/sockets.stub', 'SKF_AD_PKTTYPE' => 'sockets/sockets.stub', 'SKF_AD_PROTOCOL' => 'sockets/sockets.stub', 'SKF_AD_QUEUE' => 'sockets/sockets.stub', 'SKF_AD_RANDOM' => 'sockets/sockets.stub', 'SKF_AD_RXHASH' => 'sockets/sockets.stub', 'SKF_AD_VLAN_TAG' => 'sockets/sockets.stub', 'SKF_AD_VLAN_TAG_PRESENT' => 'sockets/sockets.stub', 'SKF_AD_VLAN_TPID' => 'sockets/sockets.stub', 'SNMP_BIT_STR' => 'snmp/snmp.stub', 'SNMP_COUNTER' => 'snmp/snmp.stub', 'SNMP_COUNTER64' => 'snmp/snmp.stub', 'SNMP_INTEGER' => 'snmp/snmp.stub', 'SNMP_IPADDRESS' => 'snmp/snmp.stub', 'SNMP_NULL' => 'snmp/snmp.stub', 'SNMP_OBJECT_ID' => 'snmp/snmp.stub', 'SNMP_OCTET_STR' => 'snmp/snmp.stub', 'SNMP_OID_OUTPUT_FULL' => 'snmp/snmp.stub', 'SNMP_OID_OUTPUT_MODULE' => 'snmp/snmp.stub', 'SNMP_OID_OUTPUT_NONE' => 'snmp/snmp.stub', 'SNMP_OID_OUTPUT_NUMERIC' => 'snmp/snmp.stub', 'SNMP_OID_OUTPUT_SUFFIX' => 'snmp/snmp.stub', 'SNMP_OID_OUTPUT_UCD' => 'snmp/snmp.stub', 'SNMP_OPAQUE' => 'snmp/snmp.stub', 'SNMP_TIMETICKS' => 'snmp/snmp.stub', 'SNMP_UINTEGER' => 'snmp/snmp.stub', 'SNMP_UNSIGNED' => 'snmp/snmp.stub', 'SNMP_VALUE_LIBRARY' => 'snmp/snmp.stub', 'SNMP_VALUE_OBJECT' => 'snmp/snmp.stub', 'SNMP_VALUE_PLAIN' => 'snmp/snmp.stub', 'SOAP_1_1' => 'soap/soap.stub', 'SOAP_1_2' => 'soap/soap.stub', 'SOAP_ACTOR_NEXT' => 'soap/soap.stub', 'SOAP_ACTOR_NONE' => 'soap/soap.stub', 'SOAP_ACTOR_UNLIMATERECEIVER' => 'soap/soap.stub', 'SOAP_AUTHENTICATION_BASIC' => 'soap/soap.stub', 'SOAP_AUTHENTICATION_DIGEST' => 'soap/soap.stub', 'SOAP_COMPRESSION_ACCEPT' => 'soap/soap.stub', 'SOAP_COMPRESSION_DEFLATE' => 'soap/soap.stub', 'SOAP_COMPRESSION_GZIP' => 'soap/soap.stub', 'SOAP_DOCUMENT' => 'soap/soap.stub', 'SOAP_ENCODED' => 'soap/soap.stub', 'SOAP_ENC_ARRAY' => 'soap/soap.stub', 'SOAP_ENC_OBJECT' => 'soap/soap.stub', 'SOAP_FUNCTIONS_ALL' => 'soap/soap.stub', 'SOAP_LITERAL' => 'soap/soap.stub', 'SOAP_PERSISTENCE_REQUEST' => 'soap/soap.stub', 'SOAP_PERSISTENCE_SESSION' => 'soap/soap.stub', 'SOAP_RPC' => 'soap/soap.stub', 'SOAP_SINGLE_ELEMENT_ARRAYS' => 'soap/soap.stub', 'SOAP_SSL_METHOD_SSLv2' => 'soap/soap.stub', 'SOAP_SSL_METHOD_SSLv23' => 'soap/soap.stub', 'SOAP_SSL_METHOD_SSLv3' => 'soap/soap.stub', 'SOAP_SSL_METHOD_TLS' => 'soap/soap.stub', 'SOAP_USE_XSI_ARRAY_TYPE' => 'soap/soap.stub', 'SOAP_WAIT_ONE_WAY_CALLS' => 'soap/soap.stub', 'SOCKET_E2BIG' => 'sockets/sockets.stub', 'SOCKET_EACCES' => 'sockets/sockets.stub', 'SOCKET_EADDRINUSE' => 'sockets/sockets.stub', 'SOCKET_EADDRNOTAVAIL' => 'sockets/sockets.stub', 'SOCKET_EADV' => 'sockets/sockets.stub', 'SOCKET_EAFNOSUPPORT' => 'sockets/sockets.stub', 'SOCKET_EAGAIN' => 'sockets/sockets.stub', 'SOCKET_EALREADY' => 'sockets/sockets.stub', 'SOCKET_EBADE' => 'sockets/sockets.stub', 'SOCKET_EBADF' => 'sockets/sockets.stub', 'SOCKET_EBADFD' => 'sockets/sockets.stub', 'SOCKET_EBADMSG' => 'sockets/sockets.stub', 'SOCKET_EBADR' => 'sockets/sockets.stub', 'SOCKET_EBADRQC' => 'sockets/sockets.stub', 'SOCKET_EBADSLT' => 'sockets/sockets.stub', 'SOCKET_EBUSY' => 'sockets/sockets.stub', 'SOCKET_ECANCELED' => 'swoole/constants.stub', 'SOCKET_ECHRNG' => 'sockets/sockets.stub', 'SOCKET_ECOMM' => 'sockets/sockets.stub', 'SOCKET_ECONNABORTED' => 'sockets/sockets.stub', 'SOCKET_ECONNREFUSED' => 'sockets/sockets.stub', 'SOCKET_ECONNRESET' => 'sockets/sockets.stub', 'SOCKET_EDESTADDRREQ' => 'sockets/sockets.stub', 'SOCKET_EDISCON' => 'sockets/sockets.stub', 'SOCKET_EDQUOT' => 'sockets/sockets.stub', 'SOCKET_EEXIST' => 'sockets/sockets.stub', 'SOCKET_EFAULT' => 'sockets/sockets.stub', 'SOCKET_EHOSTDOWN' => 'sockets/sockets.stub', 'SOCKET_EHOSTUNREACH' => 'sockets/sockets.stub', 'SOCKET_EIDRM' => 'sockets/sockets.stub', 'SOCKET_EINPROGRESS' => 'sockets/sockets.stub', 'SOCKET_EINTR' => 'sockets/sockets.stub', 'SOCKET_EINVAL' => 'sockets/sockets.stub', 'SOCKET_EIO' => 'sockets/sockets.stub', 'SOCKET_EISCONN' => 'sockets/sockets.stub', 'SOCKET_EISDIR' => 'sockets/sockets.stub', 'SOCKET_EISNAM' => 'sockets/sockets.stub', 'SOCKET_EL2HLT' => 'sockets/sockets.stub', 'SOCKET_EL2NSYNC' => 'sockets/sockets.stub', 'SOCKET_EL3HLT' => 'sockets/sockets.stub', 'SOCKET_EL3RST' => 'sockets/sockets.stub', 'SOCKET_ELNRNG' => 'sockets/sockets.stub', 'SOCKET_ELOOP' => 'sockets/sockets.stub', 'SOCKET_EMEDIUMTYPE' => 'sockets/sockets.stub', 'SOCKET_EMFILE' => 'sockets/sockets.stub', 'SOCKET_EMLINK' => 'sockets/sockets.stub', 'SOCKET_EMSGSIZE' => 'sockets/sockets.stub', 'SOCKET_EMULTIHOP' => 'sockets/sockets.stub', 'SOCKET_ENAMETOOLONG' => 'sockets/sockets.stub', 'SOCKET_ENETDOWN' => 'sockets/sockets.stub', 'SOCKET_ENETRESET' => 'sockets/sockets.stub', 'SOCKET_ENETUNREACH' => 'sockets/sockets.stub', 'SOCKET_ENFILE' => 'sockets/sockets.stub', 'SOCKET_ENOANO' => 'sockets/sockets.stub', 'SOCKET_ENOBUFS' => 'sockets/sockets.stub', 'SOCKET_ENOCSI' => 'sockets/sockets.stub', 'SOCKET_ENODATA' => 'sockets/sockets.stub', 'SOCKET_ENODEV' => 'sockets/sockets.stub', 'SOCKET_ENOENT' => 'sockets/sockets.stub', 'SOCKET_ENOLCK' => 'sockets/sockets.stub', 'SOCKET_ENOLINK' => 'sockets/sockets.stub', 'SOCKET_ENOMEDIUM' => 'sockets/sockets.stub', 'SOCKET_ENOMEM' => 'sockets/sockets.stub', 'SOCKET_ENOMSG' => 'sockets/sockets.stub', 'SOCKET_ENONET' => 'sockets/sockets.stub', 'SOCKET_ENOPROTOOPT' => 'sockets/sockets.stub', 'SOCKET_ENOSPC' => 'sockets/sockets.stub', 'SOCKET_ENOSR' => 'sockets/sockets.stub', 'SOCKET_ENOSTR' => 'sockets/sockets.stub', 'SOCKET_ENOSYS' => 'sockets/sockets.stub', 'SOCKET_ENOTBLK' => 'sockets/sockets.stub', 'SOCKET_ENOTCONN' => 'sockets/sockets.stub', 'SOCKET_ENOTDIR' => 'sockets/sockets.stub', 'SOCKET_ENOTEMPTY' => 'sockets/sockets.stub', 'SOCKET_ENOTSOCK' => 'sockets/sockets.stub', 'SOCKET_ENOTTY' => 'sockets/sockets.stub', 'SOCKET_ENOTUNIQ' => 'sockets/sockets.stub', 'SOCKET_ENXIO' => 'sockets/sockets.stub', 'SOCKET_EOPNOTSUPP' => 'sockets/sockets.stub', 'SOCKET_EPERM' => 'sockets/sockets.stub', 'SOCKET_EPFNOSUPPORT' => 'sockets/sockets.stub', 'SOCKET_EPIPE' => 'sockets/sockets.stub', 'SOCKET_EPROCLIM' => 'sockets/sockets.stub', 'SOCKET_EPROTO' => 'sockets/sockets.stub', 'SOCKET_EPROTONOSUPPORT' => 'sockets/sockets.stub', 'SOCKET_EPROTOTYPE' => 'sockets/sockets.stub', 'SOCKET_EREMCHG' => 'sockets/sockets.stub', 'SOCKET_EREMOTE' => 'sockets/sockets.stub', 'SOCKET_EREMOTEIO' => 'sockets/sockets.stub', 'SOCKET_ERESTART' => 'sockets/sockets.stub', 'SOCKET_EROFS' => 'sockets/sockets.stub', 'SOCKET_ESHUTDOWN' => 'sockets/sockets.stub', 'SOCKET_ESOCKTNOSUPPORT' => 'sockets/sockets.stub', 'SOCKET_ESPIPE' => 'sockets/sockets.stub', 'SOCKET_ESRMNT' => 'sockets/sockets.stub', 'SOCKET_ESTALE' => 'sockets/sockets.stub', 'SOCKET_ESTRPIPE' => 'sockets/sockets.stub', 'SOCKET_ETIME' => 'sockets/sockets.stub', 'SOCKET_ETIMEDOUT' => 'sockets/sockets.stub', 'SOCKET_ETOOMANYREFS' => 'sockets/sockets.stub', 'SOCKET_EUNATCH' => 'sockets/sockets.stub', 'SOCKET_EUSERS' => 'sockets/sockets.stub', 'SOCKET_EWOULDBLOCK' => 'sockets/sockets.stub', 'SOCKET_EXDEV' => 'sockets/sockets.stub', 'SOCKET_EXFULL' => 'sockets/sockets.stub', 'SOCKET_HOST_NOT_FOUND' => 'sockets/sockets.stub', 'SOCKET_NOTINITIALISED' => 'sockets/sockets.stub', 'SOCKET_NO_ADDRESS' => 'sockets/sockets.stub', 'SOCKET_NO_DATA' => 'sockets/sockets.stub', 'SOCKET_NO_RECOVERY' => 'sockets/sockets.stub', 'SOCKET_SYSNOTREADY' => 'sockets/sockets.stub', 'SOCKET_TRY_AGAIN' => 'sockets/sockets.stub', 'SOCKET_VERNOTSUPPORTED' => 'sockets/sockets.stub', 'SOCK_CLOEXEC' => 'sockets/sockets.stub', 'SOCK_DCCP' => 'sockets/sockets.stub', 'SOCK_DGRAM' => 'sockets/sockets.stub', 'SOCK_NONBLOCK' => 'sockets/sockets.stub', 'SOCK_RAW' => 'sockets/sockets.stub', 'SOCK_RDM' => 'sockets/sockets.stub', 'SOCK_SEQPACKET' => 'sockets/sockets.stub', 'SOCK_STREAM' => 'sockets/sockets.stub', 'SODIUM_BASE64_VARIANT_ORIGINAL' => 'sodium/sodium.stub', 'SODIUM_BASE64_VARIANT_ORIGINAL_NO_PADDING' => 'sodium/sodium.stub', 'SODIUM_BASE64_VARIANT_URLSAFE' => 'sodium/sodium.stub', 'SODIUM_BASE64_VARIANT_URLSAFE_NO_PADDING' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_AEGIS128L_ABYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AEGIS128L_KEYBYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AEGIS128L_NPUBBYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AEGIS128L_NSECBYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AEGIS256_ABYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AEGIS256_KEYBYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AEGIS256_NPUBBYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AEGIS256_NSECBYTES' => 'libsodium/libsodium_d.stub', 'SODIUM_CRYPTO_AEAD_AES256GCM_ABYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_AES256GCM_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_AES256GCM_NPUBBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_AES256GCM_NSECBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_ABYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AUTH_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_AUTH_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_BOX_KEYPAIRBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_BOX_MACBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_BOX_NONCEBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_BOX_PUBLICKEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_BOX_SEALBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_BOX_SECRETKEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_BOX_SEEDBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_CORE_RISTRETTO255_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_CORE_RISTRETTO255_HASHBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_CORE_RISTRETTO255_SCALARBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_GENERICHASH_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_GENERICHASH_BYTES_MAX' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_GENERICHASH_BYTES_MIN' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_GENERICHASH_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_GENERICHASH_KEYBYTES_MAX' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_GENERICHASH_KEYBYTES_MIN' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KDF_BYTES_MAX' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KDF_BYTES_MIN' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KDF_CONTEXTBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KDF_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KX_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KX_KEYPAIRBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KX_PUBLICKEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KX_SECRETKEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KX_SEEDBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_KX_SESSIONKEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_ALG_ARGON2I13' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_ALG_DEFAULT' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_MEMLIMIT_MODERATE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_MEMLIMIT_SENSITIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_OPSLIMIT_MODERATE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_OPSLIMIT_SENSITIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_SALTBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_PWHASH_STRPREFIX' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SCALARMULT_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SCALARMULT_SCALARBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETBOX_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETBOX_MACBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETBOX_NONCEBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_MESSAGE' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SHORTHASH_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SHORTHASH_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SIGN_BYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SIGN_KEYPAIRBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SIGN_PUBLICKEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SIGN_SECRETKEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_SIGN_SEEDBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_STREAM_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_STREAM_NONCEBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_STREAM_XCHACHA20_KEYBYTES' => 'sodium/sodium.stub', 'SODIUM_CRYPTO_STREAM_XCHACHA20_NONCEBYTES' => 'sodium/sodium.stub', 'SODIUM_LIBRARY_MAJOR_VERSION' => 'sodium/sodium.stub', 'SODIUM_LIBRARY_MINOR_VERSION' => 'sodium/sodium.stub', 'SODIUM_LIBRARY_VERSION' => 'sodium/sodium.stub', 'SOLR_EXTENSION_VERSION' => 'solr/constants.stub', 'SOLR_MAJOR_VERSION' => 'solr/constants.stub', 'SOLR_MINOR_VERSION' => 'solr/constants.stub', 'SOLR_PATCH_VERSION' => 'solr/constants.stub', 'SOL_SOCKET' => 'sockets/sockets.stub', 'SOL_TCP' => 'sockets/sockets.stub', 'SOL_UDP' => 'sockets/sockets.stub', 'SOL_UDPLITE' => 'sockets/sockets.stub', 'SOMAXCONN' => 'sockets/sockets.stub', 'SORTARRIVAL' => 'imap/imap.stub', 'SORTCC' => 'imap/imap.stub', 'SORTDATE' => 'imap/imap.stub', 'SORTFROM' => 'imap/imap.stub', 'SORTSIZE' => 'imap/imap.stub', 'SORTSUBJECT' => 'imap/imap.stub', 'SORTTO' => 'imap/imap.stub', 'SORT_ASC' => 'standard/standard_defines.stub', 'SORT_DESC' => 'standard/standard_defines.stub', 'SORT_FLAG_CASE' => 'standard/standard_defines.stub', 'SORT_LOCALE_STRING' => 'standard/standard_defines.stub', 'SORT_NATURAL' => 'standard/standard_defines.stub', 'SORT_NUMERIC' => 'standard/standard_defines.stub', 'SORT_REGULAR' => 'standard/standard_defines.stub', 'SORT_STRING' => 'standard/standard_defines.stub', 'SO_ATTACH_REUSEPORT_CBPF' => 'sockets/sockets.stub', 'SO_BINDTODEVICE' => 'sockets/sockets.stub', 'SO_BINDTOIFINDEX' => 'sockets/sockets.stub', 'SO_BPF_EXTENSIONS' => 'sockets/sockets.stub', 'SO_BROADCAST' => 'sockets/sockets.stub', 'SO_DEBUG' => 'sockets/sockets.stub', 'SO_DETACH_BPF' => 'sockets/sockets.stub', 'SO_DETACH_FILTER' => 'sockets/sockets.stub', 'SO_DONTROUTE' => 'sockets/sockets.stub', 'SO_ERROR' => 'sockets/sockets.stub', 'SO_FREE' => 'imap/imap.stub', 'SO_INCOMING_CPU' => 'sockets/sockets.stub', 'SO_KEEPALIVE' => 'sockets/sockets.stub', 'SO_LINGER' => 'sockets/sockets.stub', 'SO_MARK' => 'sockets/sockets.stub', 'SO_MEMINFO' => 'sockets/sockets.stub', 'SO_NOSERVER' => 'imap/imap.stub', 'SO_OOBINLINE' => 'sockets/sockets.stub', 'SO_PASSCRED' => 'sockets/sockets.stub', 'SO_RCVBUF' => 'sockets/sockets.stub', 'SO_RCVLOWAT' => 'sockets/sockets.stub', 'SO_RCVTIMEO' => 'sockets/sockets.stub', 'SO_REUSEADDR' => 'sockets/sockets.stub', 'SO_REUSEPORT' => 'sockets/sockets.stub', 'SO_SNDBUF' => 'sockets/sockets.stub', 'SO_SNDLOWAT' => 'sockets/sockets.stub', 'SO_SNDTIMEO' => 'sockets/sockets.stub', 'SO_TYPE' => 'sockets/sockets.stub', 'SO_ZEROCOPY' => 'sockets/sockets.stub', 'SQLBIT' => 'mssql/mssql.stub', 'SQLCHAR' => 'mssql/mssql.stub', 'SQLFLT4' => 'mssql/mssql.stub', 'SQLFLT8' => 'mssql/mssql.stub', 'SQLFLTN' => 'mssql/mssql.stub', 'SQLINT1' => 'mssql/mssql.stub', 'SQLINT2' => 'mssql/mssql.stub', 'SQLINT4' => 'mssql/mssql.stub', 'SQLITE3_ASSOC' => 'sqlite3/sqlite3.stub', 'SQLITE3_BLOB' => 'sqlite3/sqlite3.stub', 'SQLITE3_BOTH' => 'sqlite3/sqlite3.stub', 'SQLITE3_DETERMINISTIC' => 'sqlite3/sqlite3.stub', 'SQLITE3_FLOAT' => 'sqlite3/sqlite3.stub', 'SQLITE3_INTEGER' => 'sqlite3/sqlite3.stub', 'SQLITE3_NULL' => 'sqlite3/sqlite3.stub', 'SQLITE3_NUM' => 'sqlite3/sqlite3.stub', 'SQLITE3_OPEN_CREATE' => 'sqlite3/sqlite3.stub', 'SQLITE3_OPEN_READONLY' => 'sqlite3/sqlite3.stub', 'SQLITE3_OPEN_READWRITE' => 'sqlite3/sqlite3.stub', 'SQLITE3_TEXT' => 'sqlite3/sqlite3.stub', 'SQLITE_ABORT' => 'SQLite/SQLite.stub', 'SQLITE_ASSOC' => 'SQLite/SQLite.stub', 'SQLITE_AUTH' => 'SQLite/SQLite.stub', 'SQLITE_BOTH' => 'SQLite/SQLite.stub', 'SQLITE_BUSY' => 'SQLite/SQLite.stub', 'SQLITE_CANTOPEN' => 'SQLite/SQLite.stub', 'SQLITE_CONSTRAINT' => 'SQLite/SQLite.stub', 'SQLITE_CORRUPT' => 'SQLite/SQLite.stub', 'SQLITE_DONE' => 'SQLite/SQLite.stub', 'SQLITE_EMPTY' => 'SQLite/SQLite.stub', 'SQLITE_ERROR' => 'SQLite/SQLite.stub', 'SQLITE_FORMAT' => 'SQLite/SQLite.stub', 'SQLITE_FULL' => 'SQLite/SQLite.stub', 'SQLITE_INTERNAL' => 'SQLite/SQLite.stub', 'SQLITE_INTERRUPT' => 'SQLite/SQLite.stub', 'SQLITE_IOERR' => 'SQLite/SQLite.stub', 'SQLITE_LOCKED' => 'SQLite/SQLite.stub', 'SQLITE_MISMATCH' => 'SQLite/SQLite.stub', 'SQLITE_MISUSE' => 'SQLite/SQLite.stub', 'SQLITE_NOLFS' => 'SQLite/SQLite.stub', 'SQLITE_NOMEM' => 'SQLite/SQLite.stub', 'SQLITE_NOTADB' => 'SQLite/SQLite.stub', 'SQLITE_NOTFOUND' => 'SQLite/SQLite.stub', 'SQLITE_NUM' => 'SQLite/SQLite.stub', 'SQLITE_OK' => 'SQLite/SQLite.stub', 'SQLITE_PERM' => 'SQLite/SQLite.stub', 'SQLITE_PROTOCOL' => 'SQLite/SQLite.stub', 'SQLITE_READONLY' => 'SQLite/SQLite.stub', 'SQLITE_ROW' => 'SQLite/SQLite.stub', 'SQLITE_SCHEMA' => 'SQLite/SQLite.stub', 'SQLITE_TOOBIG' => 'SQLite/SQLite.stub', 'SQLSRV_CURSOR_CLIENT_BUFFERED' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_CURSOR_DYNAMIC' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_CURSOR_FORWARD' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_CURSOR_KEYSET' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_CURSOR_STATIC' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_ENC_BINARY' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_ENC_CHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_ERR_ALL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_ERR_ERRORS' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_ERR_WARNINGS' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_FETCH_ASSOC' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_FETCH_BOTH' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_FETCH_NUMERIC' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SEVERITY_ALL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SEVERITY_ERROR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SEVERITY_NOTICE' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SEVERITY_WARNING' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SYSTEM_ALL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SYSTEM_CONN' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SYSTEM_INIT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SYSTEM_OFF' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SYSTEM_STMT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_LOG_SYSTEM_UTIL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_NULLABLE_NO' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_NULLABLE_UNKNOWN' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_NULLABLE_YES' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PARAM_IN' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PARAM_INOUT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PARAM_OUT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PHPTYPE_DATETIME' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PHPTYPE_FLOAT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PHPTYPE_INT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_PHPTYPE_NULL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SCROLL_ABSOLUTE' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SCROLL_FIRST' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SCROLL_LAST' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SCROLL_NEXT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SCROLL_PRIOR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SCROLL_RELATIVE' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_BIGINT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_BIT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_CHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_DATE' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_DATETIME' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_DATETIME2' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_DATETIMEOFFSET' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_DECIMAL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_FLOAT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_IMAGE' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_INT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_MONEY' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_NCHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_NTEXT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_NUMERIC' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_NVARCHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_REAL' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_SMALLDATETIME' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_SMALLINT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_SMALLMONEY' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_TEXT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_TIME' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_TIMESTAMP' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_TINYINT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_UDT' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_UNIQUEIDENTIFIER' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_VARBINARY' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_VARCHAR' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_SQLTYPE_XML' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_TXN_READ_COMMITTED' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_TXN_READ_UNCOMMITTED' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_TXN_REPEATABLE_READ' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_TXN_SERIALIZABLE' => 'sqlsrv/sqlsrv.stub', 'SQLSRV_TXN_SNAPSHOT' => 'sqlsrv/sqlsrv.stub', 'SQLTEXT' => 'mssql/mssql.stub', 'SQLT_AFC' => 'oci8/oci8.stub', 'SQLT_AVC' => 'oci8/oci8.stub', 'SQLT_BDOUBLE' => 'oci8/oci8.stub', 'SQLT_BFILEE' => 'oci8/oci8.stub', 'SQLT_BFLOAT' => 'oci8/oci8.stub', 'SQLT_BIN' => 'oci8/oci8.stub', 'SQLT_BLOB' => 'oci8/oci8.stub', 'SQLT_BOL' => 'oci8/oci8.stub', 'SQLT_CFILEE' => 'oci8/oci8.stub', 'SQLT_CHR' => 'oci8/oci8.stub', 'SQLT_CLOB' => 'oci8/oci8.stub', 'SQLT_FLT' => 'oci8/oci8.stub', 'SQLT_INT' => 'oci8/oci8.stub', 'SQLT_LBI' => 'oci8/oci8.stub', 'SQLT_LNG' => 'oci8/oci8.stub', 'SQLT_LVC' => 'oci8/oci8.stub', 'SQLT_NTY' => 'oci8/oci8.stub', 'SQLT_NUM' => 'oci8/oci8.stub', 'SQLT_ODT' => 'oci8/oci8.stub', 'SQLT_RDD' => 'oci8/oci8.stub', 'SQLT_RSET' => 'oci8/oci8.stub', 'SQLT_STR' => 'oci8/oci8.stub', 'SQLT_UIN' => 'oci8/oci8.stub', 'SQLT_VCS' => 'oci8/oci8.stub', 'SQLVARCHAR' => 'mssql/mssql.stub', 'SQL_BEST_ROWID' => 'odbc/odbc.stub', 'SQL_BIGINT' => 'odbc/odbc.stub', 'SQL_BINARY' => 'odbc/odbc.stub', 'SQL_BIT' => 'odbc/odbc.stub', 'SQL_CHAR' => 'odbc/odbc.stub', 'SQL_CONCURRENCY' => 'odbc/odbc.stub', 'SQL_CONCUR_LOCK' => 'odbc/odbc.stub', 'SQL_CONCUR_READ_ONLY' => 'odbc/odbc.stub', 'SQL_CONCUR_ROWVER' => 'odbc/odbc.stub', 'SQL_CONCUR_VALUES' => 'odbc/odbc.stub', 'SQL_CURSOR_DYNAMIC' => 'odbc/odbc.stub', 'SQL_CURSOR_FORWARD_ONLY' => 'odbc/odbc.stub', 'SQL_CURSOR_KEYSET_DRIVEN' => 'odbc/odbc.stub', 'SQL_CURSOR_STATIC' => 'odbc/odbc.stub', 'SQL_CURSOR_TYPE' => 'odbc/odbc.stub', 'SQL_CUR_USE_DRIVER' => 'odbc/odbc.stub', 'SQL_CUR_USE_IF_NEEDED' => 'odbc/odbc.stub', 'SQL_CUR_USE_ODBC' => 'odbc/odbc.stub', 'SQL_DATE' => 'odbc/odbc.stub', 'SQL_DECIMAL' => 'odbc/odbc.stub', 'SQL_DOUBLE' => 'odbc/odbc.stub', 'SQL_ENSURE' => 'odbc/odbc.stub', 'SQL_FETCH_FIRST' => 'odbc/odbc.stub', 'SQL_FETCH_NEXT' => 'odbc/odbc.stub', 'SQL_FLOAT' => 'odbc/odbc.stub', 'SQL_INDEX_ALL' => 'odbc/odbc.stub', 'SQL_INDEX_UNIQUE' => 'odbc/odbc.stub', 'SQL_INTEGER' => 'odbc/odbc.stub', 'SQL_KEYSET_SIZE' => 'odbc/odbc.stub', 'SQL_LONGVARBINARY' => 'odbc/odbc.stub', 'SQL_LONGVARCHAR' => 'odbc/odbc.stub', 'SQL_NO_NULLS' => 'odbc/odbc.stub', 'SQL_NULLABLE' => 'odbc/odbc.stub', 'SQL_NUMERIC' => 'odbc/odbc.stub', 'SQL_ODBC_CURSORS' => 'odbc/odbc.stub', 'SQL_QUICK' => 'odbc/odbc.stub', 'SQL_REAL' => 'odbc/odbc.stub', 'SQL_ROWVER' => 'odbc/odbc.stub', 'SQL_SCOPE_CURROW' => 'odbc/odbc.stub', 'SQL_SCOPE_SESSION' => 'odbc/odbc.stub', 'SQL_SCOPE_TRANSACTION' => 'odbc/odbc.stub', 'SQL_SMALLINT' => 'odbc/odbc.stub', 'SQL_TIME' => 'odbc/odbc.stub', 'SQL_TIMESTAMP' => 'odbc/odbc.stub', 'SQL_TINYINT' => 'odbc/odbc.stub', 'SQL_TYPE_DATE' => 'odbc/odbc.stub', 'SQL_TYPE_TIME' => 'odbc/odbc.stub', 'SQL_TYPE_TIMESTAMP' => 'odbc/odbc.stub', 'SQL_VARBINARY' => 'odbc/odbc.stub', 'SQL_VARCHAR' => 'odbc/odbc.stub', 'SQL_WCHAR' => 'odbc/odbc.stub', 'SQL_WLONGVARCHAR' => 'odbc/odbc.stub', 'SQL_WVARCHAR' => 'odbc/odbc.stub', 'SSH2_DEFAULT_TERMINAL' => 'ssh2/ssh2.stub', 'SSH2_DEFAULT_TERM_HEIGHT' => 'ssh2/ssh2.stub', 'SSH2_DEFAULT_TERM_UNIT' => 'ssh2/ssh2.stub', 'SSH2_DEFAULT_TERM_WIDTH' => 'ssh2/ssh2.stub', 'SSH2_FINGERPRINT_HEX' => 'ssh2/ssh2.stub', 'SSH2_FINGERPRINT_MD5' => 'ssh2/ssh2.stub', 'SSH2_FINGERPRINT_RAW' => 'ssh2/ssh2.stub', 'SSH2_FINGERPRINT_SHA1' => 'ssh2/ssh2.stub', 'SSH2_POLLERR' => 'ssh2/ssh2.stub', 'SSH2_POLLEXT' => 'ssh2/ssh2.stub', 'SSH2_POLLHUP' => 'ssh2/ssh2.stub', 'SSH2_POLLIN' => 'ssh2/ssh2.stub', 'SSH2_POLLNVAL' => 'ssh2/ssh2.stub', 'SSH2_POLLOUT' => 'ssh2/ssh2.stub', 'SSH2_POLL_CHANNEL_CLOSED' => 'ssh2/ssh2.stub', 'SSH2_POLL_LISTENER_CLOSED' => 'ssh2/ssh2.stub', 'SSH2_POLL_SESSION_CLOSED' => 'ssh2/ssh2.stub', 'SSH2_STREAM_STDERR' => 'ssh2/ssh2.stub', 'SSH2_STREAM_STDIO' => 'ssh2/ssh2.stub', 'SSH2_TERM_UNIT_CHARS' => 'ssh2/ssh2.stub', 'SSH2_TERM_UNIT_PIXELS' => 'ssh2/ssh2.stub', 'STDERR' => 'Core/Core_d.stub', 'STDIN' => 'Core/Core_d.stub', 'STDOUT' => 'Core/Core_d.stub', 'STREAM_BUFFER_FULL' => 'standard/standard_defines.stub', 'STREAM_BUFFER_LINE' => 'standard/standard_defines.stub', 'STREAM_BUFFER_NONE' => 'standard/standard_defines.stub', 'STREAM_CAST_AS_STREAM' => 'standard/standard_defines.stub', 'STREAM_CAST_FOR_SELECT' => 'standard/standard_defines.stub', 'STREAM_CLIENT_ASYNC_CONNECT' => 'standard/standard_defines.stub', 'STREAM_CLIENT_CONNECT' => 'standard/standard_defines.stub', 'STREAM_CLIENT_PERSISTENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_ANY_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_ANY_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_SSLv23_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_SSLv23_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_SSLv2_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_SSLv2_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_SSLv3_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_SSLv3_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLS_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLS_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_0_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_1_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_2_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_METHOD_TLSv1_3_SERVER' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_PROTO_SSLv3' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_PROTO_TLSv1_0' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_PROTO_TLSv1_1' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_PROTO_TLSv1_2' => 'standard/standard_defines.stub', 'STREAM_CRYPTO_PROTO_TLSv1_3' => 'standard/standard_defines.stub', 'STREAM_ENFORCE_SAFE_MODE' => 'standard/standard_defines.stub', 'STREAM_FILTER_ALL' => 'standard/standard_defines.stub', 'STREAM_FILTER_READ' => 'standard/standard_defines.stub', 'STREAM_FILTER_WRITE' => 'standard/standard_defines.stub', 'STREAM_IGNORE_URL' => 'standard/standard_defines.stub', 'STREAM_IPPROTO_ICMP' => 'standard/standard_defines.stub', 'STREAM_IPPROTO_IP' => 'standard/standard_defines.stub', 'STREAM_IPPROTO_RAW' => 'standard/standard_defines.stub', 'STREAM_IPPROTO_TCP' => 'standard/standard_defines.stub', 'STREAM_IPPROTO_UDP' => 'standard/standard_defines.stub', 'STREAM_IS_URL' => 'standard/standard_defines.stub', 'STREAM_META_ACCESS' => 'standard/standard_defines.stub', 'STREAM_META_GROUP' => 'standard/standard_defines.stub', 'STREAM_META_GROUP_NAME' => 'standard/standard_defines.stub', 'STREAM_META_OWNER' => 'standard/standard_defines.stub', 'STREAM_META_OWNER_NAME' => 'standard/standard_defines.stub', 'STREAM_META_TOUCH' => 'standard/standard_defines.stub', 'STREAM_MKDIR_RECURSIVE' => 'standard/standard_defines.stub', 'STREAM_MUST_SEEK' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_AUTH_REQUIRED' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_AUTH_RESULT' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_COMPLETED' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_CONNECT' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_FAILURE' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_FILE_SIZE_IS' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_MIME_TYPE_IS' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_PROGRESS' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_REDIRECTED' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_RESOLVE' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_SEVERITY_ERR' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_SEVERITY_INFO' => 'standard/standard_defines.stub', 'STREAM_NOTIFY_SEVERITY_WARN' => 'standard/standard_defines.stub', 'STREAM_OOB' => 'standard/standard_defines.stub', 'STREAM_OPTION_BLOCKING' => 'standard/standard_defines.stub', 'STREAM_OPTION_READ_BUFFER' => 'standard/standard_defines.stub', 'STREAM_OPTION_READ_TIMEOUT' => 'standard/standard_defines.stub', 'STREAM_OPTION_WRITE_BUFFER' => 'standard/standard_defines.stub', 'STREAM_PEEK' => 'standard/standard_defines.stub', 'STREAM_PF_INET' => 'standard/standard_defines.stub', 'STREAM_PF_INET6' => 'standard/standard_defines.stub', 'STREAM_PF_UNIX' => 'standard/standard_defines.stub', 'STREAM_REPORT_ERRORS' => 'standard/standard_defines.stub', 'STREAM_SERVER_BIND' => 'standard/standard_defines.stub', 'STREAM_SERVER_LISTEN' => 'standard/standard_defines.stub', 'STREAM_SHUT_RD' => 'standard/standard_defines.stub', 'STREAM_SHUT_RDWR' => 'standard/standard_defines.stub', 'STREAM_SHUT_WR' => 'standard/standard_defines.stub', 'STREAM_SOCK_DGRAM' => 'standard/standard_defines.stub', 'STREAM_SOCK_RAW' => 'standard/standard_defines.stub', 'STREAM_SOCK_RDM' => 'standard/standard_defines.stub', 'STREAM_SOCK_SEQPACKET' => 'standard/standard_defines.stub', 'STREAM_SOCK_STREAM' => 'standard/standard_defines.stub', 'STREAM_URL_STAT_LINK' => 'standard/standard_defines.stub', 'STREAM_URL_STAT_QUIET' => 'standard/standard_defines.stub', 'STREAM_USE_PATH' => 'standard/standard_defines.stub', 'STR_PAD_BOTH' => 'standard/standard_defines.stub', 'STR_PAD_LEFT' => 'standard/standard_defines.stub', 'STR_PAD_RIGHT' => 'standard/standard_defines.stub', 'ST_SET' => 'imap/imap.stub', 'ST_SILENT' => 'imap/imap.stub', 'ST_UID' => 'imap/imap.stub', 'SUHOSIN_PATCH' => 'Core/Core_d.stub', 'SUHOSIN_PATCH_VERSION' => 'Core/Core_d.stub', 'SUNFUNCS_RET_DOUBLE' => 'date/date_d.stub', 'SUNFUNCS_RET_STRING' => 'date/date_d.stub', 'SUNFUNCS_RET_TIMESTAMP' => 'date/date_d.stub', 'SVN_ALL' => 'svn/svn.stub', 'SVN_AUTH_PARAM_CONFIG' => 'svn/svn.stub', 'SVN_AUTH_PARAM_CONFIG_DIR' => 'svn/svn.stub', 'SVN_AUTH_PARAM_DEFAULT_PASSWORD' => 'svn/svn.stub', 'SVN_AUTH_PARAM_DEFAULT_USERNAME' => 'svn/svn.stub', 'SVN_AUTH_PARAM_DONT_STORE_PASSWORDS' => 'svn/svn.stub', 'SVN_AUTH_PARAM_NON_INTERACTIVE' => 'svn/svn.stub', 'SVN_AUTH_PARAM_NO_AUTH_CACHE' => 'svn/svn.stub', 'SVN_AUTH_PARAM_SERVER_GROUP' => 'svn/svn.stub', 'SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO' => 'svn/svn.stub', 'SVN_AUTH_PARAM_SSL_SERVER_FAILURES' => 'svn/svn.stub', 'SVN_DISCOVER_CHANGED_PATHS' => 'svn/svn.stub', 'SVN_FS_CONFIG_FS_TYPE' => 'svn/svn.stub', 'SVN_FS_TYPE_BDB' => 'svn/svn.stub', 'SVN_FS_TYPE_FSFS' => 'svn/svn.stub', 'SVN_NODE_DIR' => 'svn/svn.stub', 'SVN_NODE_FILE' => 'svn/svn.stub', 'SVN_NODE_NONE' => 'svn/svn.stub', 'SVN_NODE_UNKNOWN' => 'svn/svn.stub', 'SVN_NON_RECURSIVE' => 'svn/svn.stub', 'SVN_NO_IGNORE' => 'svn/svn.stub', 'SVN_OMIT_MESSAGES' => 'svn/svn.stub', 'SVN_PROP_REVISION_AUTHOR' => 'svn/svn.stub', 'SVN_PROP_REVISION_DATE' => 'svn/svn.stub', 'SVN_PROP_REVISION_LOG' => 'svn/svn.stub', 'SVN_PROP_REVISION_ORIG_DATE' => 'svn/svn.stub', 'SVN_REVISION_BASE' => 'svn/svn.stub', 'SVN_REVISION_COMMITTED' => 'svn/svn.stub', 'SVN_REVISION_HEAD' => 'svn/svn.stub', 'SVN_REVISION_INITIAL' => 'svn/svn.stub', 'SVN_REVISION_PREV' => 'svn/svn.stub', 'SVN_REVISION_UNSPECIFIED' => 'svn/svn.stub', 'SVN_SHOW_UPDATES' => 'svn/svn.stub', 'SVN_STOP_ON_COPY' => 'svn/svn.stub', 'SVN_WC_SCHEDULE_ADD' => 'svn/svn.stub', 'SVN_WC_SCHEDULE_DELETE' => 'svn/svn.stub', 'SVN_WC_SCHEDULE_NORMAL' => 'svn/svn.stub', 'SVN_WC_SCHEDULE_REPLACE' => 'svn/svn.stub', 'SVN_WC_STATUS_ADDED' => 'svn/svn.stub', 'SVN_WC_STATUS_CONFLICTED' => 'svn/svn.stub', 'SVN_WC_STATUS_DELETED' => 'svn/svn.stub', 'SVN_WC_STATUS_EXTERNAL' => 'svn/svn.stub', 'SVN_WC_STATUS_IGNORED' => 'svn/svn.stub', 'SVN_WC_STATUS_INCOMPLETE' => 'svn/svn.stub', 'SVN_WC_STATUS_MERGED' => 'svn/svn.stub', 'SVN_WC_STATUS_MISSING' => 'svn/svn.stub', 'SVN_WC_STATUS_MODIFIED' => 'svn/svn.stub', 'SVN_WC_STATUS_NONE' => 'svn/svn.stub', 'SVN_WC_STATUS_NORMAL' => 'svn/svn.stub', 'SVN_WC_STATUS_OBSTRUCTED' => 'svn/svn.stub', 'SVN_WC_STATUS_REPLACED' => 'svn/svn.stub', 'SVN_WC_STATUS_UNVERSIONED' => 'svn/svn.stub', 'SWFACTION_DATA' => 'ming/ming.stub', 'SWFACTION_ENTERFRAME' => 'ming/ming.stub', 'SWFACTION_KEYDOWN' => 'ming/ming.stub', 'SWFACTION_KEYUP' => 'ming/ming.stub', 'SWFACTION_MOUSEDOWN' => 'ming/ming.stub', 'SWFACTION_MOUSEMOVE' => 'ming/ming.stub', 'SWFACTION_MOUSEUP' => 'ming/ming.stub', 'SWFACTION_ONLOAD' => 'ming/ming.stub', 'SWFACTION_UNLOAD' => 'ming/ming.stub', 'SWFBUTTON_DOWN' => 'ming/ming.stub', 'SWFBUTTON_DRAGOUT' => 'ming/ming.stub', 'SWFBUTTON_DRAGOVER' => 'ming/ming.stub', 'SWFBUTTON_HIT' => 'ming/ming.stub', 'SWFBUTTON_MOUSEDOWN' => 'ming/ming.stub', 'SWFBUTTON_MOUSEOUT' => 'ming/ming.stub', 'SWFBUTTON_MOUSEOVER' => 'ming/ming.stub', 'SWFBUTTON_MOUSEUP' => 'ming/ming.stub', 'SWFBUTTON_MOUSEUPOUTSIDE' => 'ming/ming.stub', 'SWFBUTTON_OVER' => 'ming/ming.stub', 'SWFBUTTON_UP' => 'ming/ming.stub', 'SWFFILL_CLIPPED_BITMAP' => 'ming/ming.stub', 'SWFFILL_LINEAR_GRADIENT' => 'ming/ming.stub', 'SWFFILL_RADIAL_GRADIENT' => 'ming/ming.stub', 'SWFFILL_TILED_BITMAP' => 'ming/ming.stub', 'SWFTEXTFIELD_ALIGN_CENTER' => 'ming/ming.stub', 'SWFTEXTFIELD_ALIGN_JUSTIFY' => 'ming/ming.stub', 'SWFTEXTFIELD_ALIGN_LEFT' => 'ming/ming.stub', 'SWFTEXTFIELD_ALIGN_RIGHT' => 'ming/ming.stub', 'SWFTEXTFIELD_AUTOSIZE' => 'ming/ming.stub', 'SWFTEXTFIELD_DRAWBOX' => 'ming/ming.stub', 'SWFTEXTFIELD_HASLENGTH' => 'ming/ming.stub', 'SWFTEXTFIELD_HTML' => 'ming/ming.stub', 'SWFTEXTFIELD_MULTILINE' => 'ming/ming.stub', 'SWFTEXTFIELD_NOEDIT' => 'ming/ming.stub', 'SWFTEXTFIELD_NOSELECT' => 'ming/ming.stub', 'SWFTEXTFIELD_PASSWORD' => 'ming/ming.stub', 'SWFTEXTFIELD_USEFONT' => 'ming/ming.stub', 'SWFTEXTFIELD_WORDWRAP' => 'ming/ming.stub', 'SWF_SOUND_11KHZ' => 'ming/ming.stub', 'SWF_SOUND_16BITS' => 'ming/ming.stub', 'SWF_SOUND_22KHZ' => 'ming/ming.stub', 'SWF_SOUND_44KHZ' => 'ming/ming.stub', 'SWF_SOUND_5KHZ' => 'ming/ming.stub', 'SWF_SOUND_8BITS' => 'ming/ming.stub', 'SWF_SOUND_ADPCM_COMPRESSED' => 'ming/ming.stub', 'SWF_SOUND_MONO' => 'ming/ming.stub', 'SWF_SOUND_MP3_COMPRESSED' => 'ming/ming.stub', 'SWF_SOUND_NELLY_COMPRESSED' => 'ming/ming.stub', 'SWF_SOUND_NOT_COMPRESSED' => 'ming/ming.stub', 'SWF_SOUND_NOT_COMPRESSED_LE' => 'ming/ming.stub', 'SWF_SOUND_STEREO' => 'ming/ming.stub', 'SWOOLE_ASYNC' => 'swoole/constants.stub', 'SWOOLE_BASE' => 'swoole/constants.stub', 'SWOOLE_CHANNEL_CANCELED' => 'swoole/constants.stub', 'SWOOLE_CHANNEL_CLOSED' => 'swoole/constants.stub', 'SWOOLE_CHANNEL_OK' => 'swoole/constants.stub', 'SWOOLE_CHANNEL_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_CORO_END' => 'swoole/constants.stub', 'SWOOLE_CORO_INIT' => 'swoole/constants.stub', 'SWOOLE_CORO_MAX_NUM_LIMIT' => 'swoole/constants.stub', 'SWOOLE_CORO_RUNNING' => 'swoole/constants.stub', 'SWOOLE_CORO_WAITING' => 'swoole/constants.stub', 'SWOOLE_DEBUG' => 'swoole/constants.stub', 'SWOOLE_DEFAULT_MAX_CORO_NUM' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_CO_CONN_LB' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_CO_REQ_LB' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_FDMOD' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_IDLE_WORKER' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_IPMOD' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_RESULT_CLOSE_CONNECTION' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_RESULT_DISCARD_PACKET' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_RESULT_USERFUNC_FALLBACK' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_ROUND' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_STREAM' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_UIDMOD' => 'swoole/constants.stub', 'SWOOLE_DISPATCH_USERFUNC' => 'swoole/constants.stub', 'SWOOLE_DTLS_CLIENT_METHOD' => 'swoole/constants.stub', 'SWOOLE_DTLS_SERVER_METHOD' => 'swoole/constants.stub', 'SWOOLE_ERROR_AIO_BAD_REQUEST' => 'swoole/constants.stub', 'SWOOLE_ERROR_AIO_CANCELED' => 'swoole/constants.stub', 'SWOOLE_ERROR_AIO_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_ERROR_BAD_IPV6_ADDRESS' => 'swoole/constants.stub', 'SWOOLE_ERROR_CLIENT_NO_CONNECTION' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_BLOCK_OBJECT_LOCKED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_BLOCK_OBJECT_WAITING' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_CANCELED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_CANNOT_CANCEL' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_DISABLED_MULTI_THREAD' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_GETCONTEXT_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_HAS_BEEN_BOUND' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_HAS_BEEN_DISCARDED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_IOCPINIT_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_MAKECONTEXT_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_MUTEX_DOUBLE_UNLOCK' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_NOT_EXISTS' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_OUT_OF_COROUTINE' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_PROTECT_STACK_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_STD_THREAD_LINK_ERROR' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_SWAPCONTEXT_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_TIMEDOUT' => 'swoole/constants.stub', 'SWOOLE_ERROR_CO_YIELD_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_DATA_LENGTH_TOO_LARGE' => 'swoole/constants.stub', 'SWOOLE_ERROR_DNSLOOKUP_DUPLICATE_REQUEST' => 'swoole/constants.stub', 'SWOOLE_ERROR_DNSLOOKUP_NO_SERVER' => 'swoole/constants.stub', 'SWOOLE_ERROR_DNSLOOKUP_RESOLVE_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_DNSLOOKUP_RESOLVE_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_ERROR_DNSLOOKUP_UNSUPPORTED' => 'swoole/constants.stub', 'SWOOLE_ERROR_EVENT_SOCKET_REMOVED' => 'swoole/constants.stub', 'SWOOLE_ERROR_FILE_EMPTY' => 'swoole/constants.stub', 'SWOOLE_ERROR_FILE_NOT_EXIST' => 'swoole/constants.stub', 'SWOOLE_ERROR_FILE_TOO_LARGE' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP2_STREAM_ID_TOO_BIG' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP2_STREAM_IGNORE' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP2_STREAM_NOT_FOUND' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP2_STREAM_NO_HEADER' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP_INVALID_PROTOCOL' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP_PROXY_BAD_RESPONSE' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP_PROXY_HANDSHAKE_ERROR' => 'swoole/constants.stub', 'SWOOLE_ERROR_HTTP_PROXY_HANDSHAKE_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_INVALID_PARAMS' => 'swoole/constants.stub', 'SWOOLE_ERROR_MALLOC_FAIL' => 'swoole/constants.stub', 'SWOOLE_ERROR_NAME_TOO_LONG' => 'swoole/constants.stub', 'SWOOLE_ERROR_OPERATION_NOT_SUPPORT' => 'swoole/constants.stub', 'SWOOLE_ERROR_OUTPUT_BUFFER_OVERFLOW' => 'swoole/constants.stub', 'SWOOLE_ERROR_OUTPUT_SEND_YIELD' => 'swoole/constants.stub', 'SWOOLE_ERROR_PACKAGE_LENGTH_NOT_FOUND' => 'swoole/constants.stub', 'SWOOLE_ERROR_PACKAGE_LENGTH_TOO_LARGE' => 'swoole/constants.stub', 'SWOOLE_ERROR_PACKAGE_MALFORMED_DATA' => 'swoole/constants.stub', 'SWOOLE_ERROR_PHP_FATAL_ERROR' => 'swoole/constants.stub', 'SWOOLE_ERROR_PROTOCOL_ERROR' => 'swoole/constants.stub', 'SWOOLE_ERROR_QUEUE_FULL' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_CONNECT_FAIL' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_INVALID_COMMAND' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_INVALID_LISTEN_PORT' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_INVALID_REQUEST' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_MUST_CREATED_BEFORE_CLIENT' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_NO_IDLE_WORKER' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_ONLY_START_ONE' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_PIPE_BUFFER_FULL' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_SEND_IN_MASTER' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_TOO_MANY_LISTEN_PORT' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_TOO_MANY_SOCKET' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_WORKER_ABNORMAL_PIPE_DATA' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_WORKER_EXIT_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_WORKER_TERMINATED' => 'swoole/constants.stub', 'SWOOLE_ERROR_SERVER_WORKER_UNPROCESSED_DATA' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_CLOSED' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_CLOSED_BY_CLIENT' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_CLOSED_BY_SERVER' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_CLOSING' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_DISCARD_DATA' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_DISCARD_TIMEOUT_DATA' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_INVALID_ID' => 'swoole/constants.stub', 'SWOOLE_ERROR_SESSION_NOT_EXIST' => 'swoole/constants.stub', 'SWOOLE_ERROR_SOCKET_CLOSED' => 'swoole/constants.stub', 'SWOOLE_ERROR_SOCKET_POLL_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_ERROR_SOCKS5_AUTH_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_SOCKS5_HANDSHAKE_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_SOCKS5_SERVER_ERROR' => 'swoole/constants.stub', 'SWOOLE_ERROR_SOCKS5_UNSUPPORT_METHOD' => 'swoole/constants.stub', 'SWOOLE_ERROR_SOCKS5_UNSUPPORT_VERSION' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_BAD_CLIENT' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_BAD_PROTOCOL' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_CANNOT_USE_SENFILE' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_EMPTY_PEER_CERTIFICATE' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_HANDSHAKE_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_NOT_READY' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_RESET' => 'swoole/constants.stub', 'SWOOLE_ERROR_SSL_VERIFY_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_SYSTEM_CALL_FAIL' => 'swoole/constants.stub', 'SWOOLE_ERROR_TASK_DISPATCH_FAIL' => 'swoole/constants.stub', 'SWOOLE_ERROR_TASK_PACKAGE_TOO_BIG' => 'swoole/constants.stub', 'SWOOLE_ERROR_TASK_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_ERROR_UNREGISTERED_SIGNAL' => 'swoole/constants.stub', 'SWOOLE_ERROR_WEBSOCKET_BAD_CLIENT' => 'swoole/constants.stub', 'SWOOLE_ERROR_WEBSOCKET_BAD_OPCODE' => 'swoole/constants.stub', 'SWOOLE_ERROR_WEBSOCKET_HANDSHAKE_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_WEBSOCKET_INCOMPLETE_PACKET' => 'swoole/constants.stub', 'SWOOLE_ERROR_WEBSOCKET_PACK_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_WEBSOCKET_UNCONNECTED' => 'swoole/constants.stub', 'SWOOLE_ERROR_WEBSOCKET_UNPACK_FAILED' => 'swoole/constants.stub', 'SWOOLE_ERROR_WRONG_OPERATION' => 'swoole/constants.stub', 'SWOOLE_EVENT_READ' => 'swoole/constants.stub', 'SWOOLE_EVENT_WRITE' => 'swoole/constants.stub', 'SWOOLE_EXIT_IN_COROUTINE' => 'swoole/constants.stub', 'SWOOLE_EXIT_IN_SERVER' => 'swoole/constants.stub', 'SWOOLE_EXTRA_VERSION' => 'swoole/constants.stub', 'SWOOLE_FILELOCK' => 'swoole/constants.stub', 'SWOOLE_HAVE_BROTLI' => 'swoole/constants.stub', 'SWOOLE_HAVE_COMPRESSION' => 'swoole/constants.stub', 'SWOOLE_HAVE_ZLIB' => 'swoole/constants.stub', 'SWOOLE_HOOK_ALL' => 'swoole/constants.stub', 'SWOOLE_HOOK_BLOCKING_FUNCTION' => 'swoole/constants.stub', 'SWOOLE_HOOK_CURL' => 'swoole/constants.stub', 'SWOOLE_HOOK_FILE' => 'swoole/constants.stub', 'SWOOLE_HOOK_NATIVE_CURL' => 'swoole/constants.stub', 'SWOOLE_HOOK_PROC' => 'swoole/constants.stub', 'SWOOLE_HOOK_SLEEP' => 'swoole/constants.stub', 'SWOOLE_HOOK_SOCKETS' => 'swoole/constants.stub', 'SWOOLE_HOOK_SSL' => 'swoole/constants.stub', 'SWOOLE_HOOK_STDIO' => 'swoole/constants.stub', 'SWOOLE_HOOK_STREAM_FUNCTION' => 'swoole/constants.stub', 'SWOOLE_HOOK_STREAM_SELECT' => 'swoole/constants.stub', 'SWOOLE_HOOK_TCP' => 'swoole/constants.stub', 'SWOOLE_HOOK_TLS' => 'swoole/constants.stub', 'SWOOLE_HOOK_UDG' => 'swoole/constants.stub', 'SWOOLE_HOOK_UDP' => 'swoole/constants.stub', 'SWOOLE_HOOK_UNIX' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_CANCEL' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_COMPRESSION_ERROR' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_CONNECT_ERROR' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_ENHANCE_YOUR_CALM' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_FLOW_CONTROL_ERROR' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_FRAME_SIZE_ERROR' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_INADEQUATE_SECURITY' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_INTERNAL_ERROR' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_NO_ERROR' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_PROTOCOL_ERROR' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_REFUSED_STREAM' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_SETTINGS_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_HTTP2_ERROR_STREAM_CLOSED' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_CONTINUATION' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_DATA' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_GOAWAY' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_HEADERS' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_PING' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_PRIORITY' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_PUSH_PROMISE' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_RST_STREAM' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_SETTINGS' => 'swoole/constants.stub', 'SWOOLE_HTTP2_TYPE_WINDOW_UPDATE' => 'swoole/constants.stub', 'SWOOLE_HTTP_CLIENT_ESTATUS_CONNECT_FAILED' => 'swoole/constants.stub', 'SWOOLE_HTTP_CLIENT_ESTATUS_REQUEST_TIMEOUT' => 'swoole/constants.stub', 'SWOOLE_HTTP_CLIENT_ESTATUS_SEND_FAILED' => 'swoole/constants.stub', 'SWOOLE_HTTP_CLIENT_ESTATUS_SERVER_RESET' => 'swoole/constants.stub', 'SWOOLE_IOV_MAX' => 'swoole/constants.stub', 'SWOOLE_IPC_MSGQUEUE' => 'swoole/constants.stub', 'SWOOLE_IPC_NONE' => 'swoole/constants.stub', 'SWOOLE_IPC_PREEMPTIVE' => 'swoole/constants.stub', 'SWOOLE_IPC_SOCKET' => 'swoole/constants.stub', 'SWOOLE_IPC_UNIXSOCK' => 'swoole/constants.stub', 'SWOOLE_IPC_UNSOCK' => 'swoole/constants.stub', 'SWOOLE_KEEP' => 'swoole/constants.stub', 'SWOOLE_LOG_DEBUG' => 'swoole/constants.stub', 'SWOOLE_LOG_ERROR' => 'swoole/constants.stub', 'SWOOLE_LOG_INFO' => 'swoole/constants.stub', 'SWOOLE_LOG_NONE' => 'swoole/constants.stub', 'SWOOLE_LOG_NOTICE' => 'swoole/constants.stub', 'SWOOLE_LOG_ROTATION_DAILY' => 'swoole/constants.stub', 'SWOOLE_LOG_ROTATION_EVERY_MINUTE' => 'swoole/constants.stub', 'SWOOLE_LOG_ROTATION_HOURLY' => 'swoole/constants.stub', 'SWOOLE_LOG_ROTATION_MONTHLY' => 'swoole/constants.stub', 'SWOOLE_LOG_ROTATION_SINGLE' => 'swoole/constants.stub', 'SWOOLE_LOG_TRACE' => 'swoole/constants.stub', 'SWOOLE_LOG_WARNING' => 'swoole/constants.stub', 'SWOOLE_MAJOR_VERSION' => 'swoole/constants.stub', 'SWOOLE_MINOR_VERSION' => 'swoole/constants.stub', 'SWOOLE_MUTEX' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_CANT_FIND_CHARSET' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_COMMANDS_OUT_OF_SYNC' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_CONNECTION_ERROR' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_INVALID_BUFFER_USE' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_INVALID_PARAMETER_NO' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_MALFORMED_PACKET' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_NOT_IMPLEMENTED' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_NO_PREPARE_STMT' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_OUT_OF_MEMORY' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_PARAMS_NOT_BOUND' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_SERVER_GONE_ERROR' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_SERVER_LOST' => 'swoole/constants.stub', 'SWOOLE_MYSQLND_CR_UNKNOWN_ERROR' => 'swoole/constants.stub', 'SWOOLE_PROCESS' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_ALLOC' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_CLOSED' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_EOF' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_IO' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_NOAUTH' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_OOM' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_OTHER' => 'swoole/constants.stub', 'SWOOLE_REDIS_ERR_PROTOCOL' => 'swoole/constants.stub', 'SWOOLE_REDIS_MODE_MULTI' => 'swoole/constants.stub', 'SWOOLE_REDIS_MODE_PIPELINE' => 'swoole/constants.stub', 'SWOOLE_REDIS_TYPE_HASH' => 'swoole/constants.stub', 'SWOOLE_REDIS_TYPE_LIST' => 'swoole/constants.stub', 'SWOOLE_REDIS_TYPE_NOT_FOUND' => 'swoole/constants.stub', 'SWOOLE_REDIS_TYPE_SET' => 'swoole/constants.stub', 'SWOOLE_REDIS_TYPE_STRING' => 'swoole/constants.stub', 'SWOOLE_REDIS_TYPE_ZSET' => 'swoole/constants.stub', 'SWOOLE_RELEASE_VERSION' => 'swoole/constants.stub', 'SWOOLE_RWLOCK' => 'swoole/constants.stub', 'SWOOLE_SEM' => 'swoole/constants.stub', 'SWOOLE_SERVER_COMMAND_EVENT_WORKER' => 'swoole/constants.stub', 'SWOOLE_SERVER_COMMAND_MANAGER' => 'swoole/constants.stub', 'SWOOLE_SERVER_COMMAND_MASTER' => 'swoole/constants.stub', 'SWOOLE_SERVER_COMMAND_REACTOR_THREAD' => 'swoole/constants.stub', 'SWOOLE_SERVER_COMMAND_TASK_WORKER' => 'swoole/constants.stub', 'SWOOLE_SERVER_COMMAND_WORKER' => 'swoole/constants.stub', 'SWOOLE_SOCK_ASYNC' => 'swoole/constants.stub', 'SWOOLE_SOCK_SYNC' => 'swoole/constants.stub', 'SWOOLE_SOCK_TCP' => 'swoole/constants.stub', 'SWOOLE_SOCK_TCP6' => 'swoole/constants.stub', 'SWOOLE_SOCK_UDP' => 'swoole/constants.stub', 'SWOOLE_SOCK_UDP6' => 'swoole/constants.stub', 'SWOOLE_SOCK_UNIX_DGRAM' => 'swoole/constants.stub', 'SWOOLE_SOCK_UNIX_STREAM' => 'swoole/constants.stub', 'SWOOLE_SPINLOCK' => 'swoole/constants.stub', 'SWOOLE_SSL' => 'swoole/constants.stub', 'SWOOLE_SSL_DTLS' => 'swoole/constants.stub', 'SWOOLE_SSL_SSLv2' => 'swoole/constants.stub', 'SWOOLE_SSL_TLSv1' => 'swoole/constants.stub', 'SWOOLE_SSL_TLSv1_1' => 'swoole/constants.stub', 'SWOOLE_SSL_TLSv1_2' => 'swoole/constants.stub', 'SWOOLE_SSL_TLSv1_3' => 'swoole/constants.stub', 'SWOOLE_SSLv23_CLIENT_METHOD' => 'swoole/constants.stub', 'SWOOLE_SSLv23_METHOD' => 'swoole/constants.stub', 'SWOOLE_SSLv23_SERVER_METHOD' => 'swoole/constants.stub', 'SWOOLE_SSLv3_CLIENT_METHOD' => 'swoole/constants.stub', 'SWOOLE_SSLv3_METHOD' => 'swoole/constants.stub', 'SWOOLE_SSLv3_SERVER_METHOD' => 'swoole/constants.stub', 'SWOOLE_STRERROR_DNS' => 'swoole/constants.stub', 'SWOOLE_STRERROR_GAI' => 'swoole/constants.stub', 'SWOOLE_STRERROR_SWOOLE' => 'swoole/constants.stub', 'SWOOLE_STRERROR_SYSTEM' => 'swoole/constants.stub', 'SWOOLE_SYNC' => 'swoole/constants.stub', 'SWOOLE_TASK_CALLBACK' => 'swoole/constants.stub', 'SWOOLE_TASK_COROUTINE' => 'swoole/constants.stub', 'SWOOLE_TASK_NONBLOCK' => 'swoole/constants.stub', 'SWOOLE_TASK_NOREPLY' => 'swoole/constants.stub', 'SWOOLE_TASK_PEEK' => 'swoole/constants.stub', 'SWOOLE_TASK_SERIALIZE' => 'swoole/constants.stub', 'SWOOLE_TASK_TMPFILE' => 'swoole/constants.stub', 'SWOOLE_TASK_WAITALL' => 'swoole/constants.stub', 'SWOOLE_TCP' => 'swoole/constants.stub', 'SWOOLE_TCP6' => 'swoole/constants.stub', 'SWOOLE_TIMER_MAX_MS' => 'swoole/constants.stub', 'SWOOLE_TIMER_MAX_SEC' => 'swoole/constants.stub', 'SWOOLE_TIMER_MIN_MS' => 'swoole/constants.stub', 'SWOOLE_TIMER_MIN_SEC' => 'swoole/constants.stub', 'SWOOLE_TLS_CLIENT_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLS_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLS_SERVER_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_1_CLIENT_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_1_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_1_SERVER_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_2_CLIENT_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_2_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_2_SERVER_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_CLIENT_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_METHOD' => 'swoole/constants.stub', 'SWOOLE_TLSv1_SERVER_METHOD' => 'swoole/constants.stub', 'SWOOLE_TRACE_AIO' => 'swoole/constants.stub', 'SWOOLE_TRACE_ALL' => 'swoole/constants.stub', 'SWOOLE_TRACE_BUFFER' => 'swoole/constants.stub', 'SWOOLE_TRACE_CARES' => 'swoole/constants.stub', 'SWOOLE_TRACE_CHANNEL' => 'swoole/constants.stub', 'SWOOLE_TRACE_CLIENT' => 'swoole/constants.stub', 'SWOOLE_TRACE_CLOSE' => 'swoole/constants.stub', 'SWOOLE_TRACE_CONN' => 'swoole/constants.stub', 'SWOOLE_TRACE_CONTEXT' => 'swoole/constants.stub', 'SWOOLE_TRACE_COROUTINE' => 'swoole/constants.stub', 'SWOOLE_TRACE_CO_CURL' => 'swoole/constants.stub', 'SWOOLE_TRACE_CO_HTTP_SERVER' => 'swoole/constants.stub', 'SWOOLE_TRACE_EOF_PROTOCOL' => 'swoole/constants.stub', 'SWOOLE_TRACE_EVENT' => 'swoole/constants.stub', 'SWOOLE_TRACE_HTTP' => 'swoole/constants.stub', 'SWOOLE_TRACE_HTTP2' => 'swoole/constants.stub', 'SWOOLE_TRACE_HTTP_CLIENT' => 'swoole/constants.stub', 'SWOOLE_TRACE_LENGTH_PROTOCOL' => 'swoole/constants.stub', 'SWOOLE_TRACE_MEMORY' => 'swoole/constants.stub', 'SWOOLE_TRACE_MYSQL_CLIENT' => 'swoole/constants.stub', 'SWOOLE_TRACE_NORMAL' => 'swoole/constants.stub', 'SWOOLE_TRACE_PHP' => 'swoole/constants.stub', 'SWOOLE_TRACE_REACTOR' => 'swoole/constants.stub', 'SWOOLE_TRACE_REDIS_CLIENT' => 'swoole/constants.stub', 'SWOOLE_TRACE_SERVER' => 'swoole/constants.stub', 'SWOOLE_TRACE_SOCKET' => 'swoole/constants.stub', 'SWOOLE_TRACE_SSL' => 'swoole/constants.stub', 'SWOOLE_TRACE_TABLE' => 'swoole/constants.stub', 'SWOOLE_TRACE_TIMER' => 'swoole/constants.stub', 'SWOOLE_TRACE_WEBSOCKET' => 'swoole/constants.stub', 'SWOOLE_TRACE_WORKER' => 'swoole/constants.stub', 'SWOOLE_UDP' => 'swoole/constants.stub', 'SWOOLE_UDP6' => 'swoole/constants.stub', 'SWOOLE_UNIX_DGRAM' => 'swoole/constants.stub', 'SWOOLE_UNIX_STREAM' => 'swoole/constants.stub', 'SWOOLE_USE_HTTP2' => 'swoole/constants.stub', 'SWOOLE_USE_SHORTNAME' => 'swoole/constants.stub', 'SWOOLE_VERSION' => 'swoole/constants.stub', 'SWOOLE_VERSION_ID' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_ABNORMAL' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_DATA_ERROR' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_EXTENSION_MISSING' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_GOING_AWAY' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_MESSAGE_ERROR' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_MESSAGE_TOO_BIG' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_NORMAL' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_POLICY_ERROR' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_PROTOCOL_ERROR' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_SERVER_ERROR' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_STATUS_ERROR' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_CLOSE_TLS' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_FLAG_COMPRESS' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_FLAG_FIN' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_FLAG_MASK' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_FLAG_RSV1' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_FLAG_RSV2' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_FLAG_RSV3' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_OPCODE_BINARY' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_OPCODE_CLOSE' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_OPCODE_CONTINUATION' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_OPCODE_PING' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_OPCODE_PONG' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_OPCODE_TEXT' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_STATUS_ACTIVE' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_STATUS_CLOSING' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_STATUS_CONNECTION' => 'swoole/constants.stub', 'SWOOLE_WEBSOCKET_STATUS_HANDSHAKE' => 'swoole/constants.stub', 'SWOOLE_WORKER_BUSY' => 'swoole/constants.stub', 'SWOOLE_WORKER_EXIT' => 'swoole/constants.stub', 'SWOOLE_WORKER_IDLE' => 'swoole/constants.stub', 'S_ALL' => 'Core/Core_d.stub', 'S_EXECUTOR' => 'Core/Core_d.stub', 'S_FILES' => 'Core/Core_d.stub', 'S_INCLUDE' => 'Core/Core_d.stub', 'S_INTERNAL' => 'Core/Core_d.stub', 'S_IRGRP' => 'dio/dio_d.stub', 'S_IROTH' => 'dio/dio_d.stub', 'S_IRUSR' => 'dio/dio_d.stub', 'S_IRWXG' => 'dio/dio_d.stub', 'S_IRWXO' => 'dio/dio_d.stub', 'S_IRWXU' => 'dio/dio_d.stub', 'S_IWGRP' => 'dio/dio_d.stub', 'S_IWOTH' => 'dio/dio_d.stub', 'S_IWUSR' => 'dio/dio_d.stub', 'S_IXGRP' => 'dio/dio_d.stub', 'S_IXOTH' => 'dio/dio_d.stub', 'S_IXUSR' => 'dio/dio_d.stub', 'S_MAIL' => 'Core/Core_d.stub', 'S_MEMORY' => 'Core/Core_d.stub', 'S_MISC' => 'Core/Core_d.stub', 'S_SESSION' => 'Core/Core_d.stub', 'S_SQL' => 'Core/Core_d.stub', 'S_VARS' => 'Core/Core_d.stub', 'ScrollBar' => 'winbinder/winbinder.stub', 'Slider' => 'winbinder/winbinder.stub', 'Sodium\\CRYPTO_AEAD_AES256GCM_ABYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AEAD_AES256GCM_KEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AEAD_AES256GCM_NPUBBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AEAD_AES256GCM_NSECBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AEAD_CHACHA20POLY1305_ABYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AUTH_BYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_AUTH_KEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_BOX_KEYPAIRBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_BOX_MACBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_BOX_NONCEBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_BOX_PUBLICKEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_BOX_SEALBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_BOX_SECRETKEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_BOX_SEEDBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_GENERICHASH_BYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_GENERICHASH_BYTES_MAX' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_GENERICHASH_BYTES_MIN' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_GENERICHASH_KEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_GENERICHASH_KEYBYTES_MAX' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_GENERICHASH_KEYBYTES_MIN' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_KX_BYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_KX_PUBLICKEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_KX_SECRETKEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_MEMLIMIT_MODERATE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_MEMLIMIT_SENSITIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_OPSLIMIT_MODERATE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_OPSLIMIT_SENSITIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SCALARMULT_BYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SCALARMULT_SCALARBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SECRETBOX_KEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SECRETBOX_MACBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SECRETBOX_NONCEBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SHORTHASH_BYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SHORTHASH_KEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SIGN_BYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SIGN_KEYPAIRBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SIGN_PUBLICKEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SIGN_SECRETKEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_SIGN_SEEDBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_STREAM_KEYBYTES' => 'libsodium/libsodium.stub', 'Sodium\\CRYPTO_STREAM_NONCEBYTES' => 'libsodium/libsodium.stub', 'Spinner' => 'winbinder/winbinder.stub', 'StatusBar' => 'winbinder/winbinder.stub', 'TCP_CONGESTION' => 'sockets/sockets.stub', 'TCP_DEFER_ACCEPT' => 'sockets/sockets.stub', 'TCP_KEEPCNT' => 'sockets/sockets.stub', 'TCP_KEEPIDLE' => 'sockets/sockets.stub', 'TCP_KEEPINTVL' => 'sockets/sockets.stub', 'TCP_NODELAY' => 'sockets/sockets.stub', 'TCP_NOTSENT_LOWAT' => 'sockets/sockets.stub', 'TCP_QUICKACK' => 'sockets/sockets.stub', 'TCP_REPAIR' => 'sockets/sockets.stub', 'TCP_SYNCNT' => 'sockets/sockets.stub', 'THOUSANDS_SEP' => 'standard/standard_defines.stub', 'THOUSEP' => 'standard/standard_defines.stub', 'TIDY_NODETYPE_ASP' => 'tidy/tidy.stub', 'TIDY_NODETYPE_CDATA' => 'tidy/tidy.stub', 'TIDY_NODETYPE_COMMENT' => 'tidy/tidy.stub', 'TIDY_NODETYPE_DOCTYPE' => 'tidy/tidy.stub', 'TIDY_NODETYPE_END' => 'tidy/tidy.stub', 'TIDY_NODETYPE_JSTE' => 'tidy/tidy.stub', 'TIDY_NODETYPE_PHP' => 'tidy/tidy.stub', 'TIDY_NODETYPE_PROCINS' => 'tidy/tidy.stub', 'TIDY_NODETYPE_ROOT' => 'tidy/tidy.stub', 'TIDY_NODETYPE_SECTION' => 'tidy/tidy.stub', 'TIDY_NODETYPE_START' => 'tidy/tidy.stub', 'TIDY_NODETYPE_STARTEND' => 'tidy/tidy.stub', 'TIDY_NODETYPE_TEXT' => 'tidy/tidy.stub', 'TIDY_NODETYPE_XMLDECL' => 'tidy/tidy.stub', 'TIDY_TAG_A' => 'tidy/tidy.stub', 'TIDY_TAG_ABBR' => 'tidy/tidy.stub', 'TIDY_TAG_ACRONYM' => 'tidy/tidy.stub', 'TIDY_TAG_ADDRESS' => 'tidy/tidy.stub', 'TIDY_TAG_ALIGN' => 'tidy/tidy.stub', 'TIDY_TAG_APPLET' => 'tidy/tidy.stub', 'TIDY_TAG_AREA' => 'tidy/tidy.stub', 'TIDY_TAG_ARTICLE' => 'tidy/tidy.stub', 'TIDY_TAG_ASIDE' => 'tidy/tidy.stub', 'TIDY_TAG_AUDIO' => 'tidy/tidy.stub', 'TIDY_TAG_B' => 'tidy/tidy.stub', 'TIDY_TAG_BASE' => 'tidy/tidy.stub', 'TIDY_TAG_BASEFONT' => 'tidy/tidy.stub', 'TIDY_TAG_BDI' => 'tidy/tidy.stub', 'TIDY_TAG_BDO' => 'tidy/tidy.stub', 'TIDY_TAG_BGSOUND' => 'tidy/tidy.stub', 'TIDY_TAG_BIG' => 'tidy/tidy.stub', 'TIDY_TAG_BLINK' => 'tidy/tidy.stub', 'TIDY_TAG_BLOCKQUOTE' => 'tidy/tidy.stub', 'TIDY_TAG_BODY' => 'tidy/tidy.stub', 'TIDY_TAG_BR' => 'tidy/tidy.stub', 'TIDY_TAG_BUTTON' => 'tidy/tidy.stub', 'TIDY_TAG_CANVAS' => 'tidy/tidy.stub', 'TIDY_TAG_CAPTION' => 'tidy/tidy.stub', 'TIDY_TAG_CENTER' => 'tidy/tidy.stub', 'TIDY_TAG_CITE' => 'tidy/tidy.stub', 'TIDY_TAG_CODE' => 'tidy/tidy.stub', 'TIDY_TAG_COL' => 'tidy/tidy.stub', 'TIDY_TAG_COLGROUP' => 'tidy/tidy.stub', 'TIDY_TAG_COMMAND' => 'tidy/tidy.stub', 'TIDY_TAG_COMMENT' => 'tidy/tidy.stub', 'TIDY_TAG_DATALIST' => 'tidy/tidy.stub', 'TIDY_TAG_DD' => 'tidy/tidy.stub', 'TIDY_TAG_DEL' => 'tidy/tidy.stub', 'TIDY_TAG_DETAILS' => 'tidy/tidy.stub', 'TIDY_TAG_DFN' => 'tidy/tidy.stub', 'TIDY_TAG_DIALOG' => 'tidy/tidy.stub', 'TIDY_TAG_DIR' => 'tidy/tidy.stub', 'TIDY_TAG_DIV' => 'tidy/tidy.stub', 'TIDY_TAG_DL' => 'tidy/tidy.stub', 'TIDY_TAG_DT' => 'tidy/tidy.stub', 'TIDY_TAG_EM' => 'tidy/tidy.stub', 'TIDY_TAG_EMBED' => 'tidy/tidy.stub', 'TIDY_TAG_FIELDSET' => 'tidy/tidy.stub', 'TIDY_TAG_FIGCAPTION' => 'tidy/tidy.stub', 'TIDY_TAG_FIGURE' => 'tidy/tidy.stub', 'TIDY_TAG_FONT' => 'tidy/tidy.stub', 'TIDY_TAG_FOOTER' => 'tidy/tidy.stub', 'TIDY_TAG_FORM' => 'tidy/tidy.stub', 'TIDY_TAG_FRAME' => 'tidy/tidy.stub', 'TIDY_TAG_FRAMESET' => 'tidy/tidy.stub', 'TIDY_TAG_H1' => 'tidy/tidy.stub', 'TIDY_TAG_H2' => 'tidy/tidy.stub', 'TIDY_TAG_H3' => 'tidy/tidy.stub', 'TIDY_TAG_H4' => 'tidy/tidy.stub', 'TIDY_TAG_H5' => 'tidy/tidy.stub', 'TIDY_TAG_H6' => 'tidy/tidy.stub', 'TIDY_TAG_HEAD' => 'tidy/tidy.stub', 'TIDY_TAG_HEADER' => 'tidy/tidy.stub', 'TIDY_TAG_HGROUP' => 'tidy/tidy.stub', 'TIDY_TAG_HR' => 'tidy/tidy.stub', 'TIDY_TAG_HTML' => 'tidy/tidy.stub', 'TIDY_TAG_I' => 'tidy/tidy.stub', 'TIDY_TAG_IFRAME' => 'tidy/tidy.stub', 'TIDY_TAG_ILAYER' => 'tidy/tidy.stub', 'TIDY_TAG_IMG' => 'tidy/tidy.stub', 'TIDY_TAG_INPUT' => 'tidy/tidy.stub', 'TIDY_TAG_INS' => 'tidy/tidy.stub', 'TIDY_TAG_ISINDEX' => 'tidy/tidy.stub', 'TIDY_TAG_KBD' => 'tidy/tidy.stub', 'TIDY_TAG_KEYGEN' => 'tidy/tidy.stub', 'TIDY_TAG_LABEL' => 'tidy/tidy.stub', 'TIDY_TAG_LAYER' => 'tidy/tidy.stub', 'TIDY_TAG_LEGEND' => 'tidy/tidy.stub', 'TIDY_TAG_LI' => 'tidy/tidy.stub', 'TIDY_TAG_LINK' => 'tidy/tidy.stub', 'TIDY_TAG_LISTING' => 'tidy/tidy.stub', 'TIDY_TAG_MAIN' => 'tidy/tidy.stub', 'TIDY_TAG_MAP' => 'tidy/tidy.stub', 'TIDY_TAG_MARK' => 'tidy/tidy.stub', 'TIDY_TAG_MARQUEE' => 'tidy/tidy.stub', 'TIDY_TAG_MENU' => 'tidy/tidy.stub', 'TIDY_TAG_MENUITEM' => 'tidy/tidy.stub', 'TIDY_TAG_META' => 'tidy/tidy.stub', 'TIDY_TAG_METER' => 'tidy/tidy.stub', 'TIDY_TAG_MULTICOL' => 'tidy/tidy.stub', 'TIDY_TAG_NAV' => 'tidy/tidy.stub', 'TIDY_TAG_NOBR' => 'tidy/tidy.stub', 'TIDY_TAG_NOEMBED' => 'tidy/tidy.stub', 'TIDY_TAG_NOFRAMES' => 'tidy/tidy.stub', 'TIDY_TAG_NOLAYER' => 'tidy/tidy.stub', 'TIDY_TAG_NOSAVE' => 'tidy/tidy.stub', 'TIDY_TAG_NOSCRIPT' => 'tidy/tidy.stub', 'TIDY_TAG_OBJECT' => 'tidy/tidy.stub', 'TIDY_TAG_OL' => 'tidy/tidy.stub', 'TIDY_TAG_OPTGROUP' => 'tidy/tidy.stub', 'TIDY_TAG_OPTION' => 'tidy/tidy.stub', 'TIDY_TAG_OUTPUT' => 'tidy/tidy.stub', 'TIDY_TAG_P' => 'tidy/tidy.stub', 'TIDY_TAG_PARAM' => 'tidy/tidy.stub', 'TIDY_TAG_PLAINTEXT' => 'tidy/tidy.stub', 'TIDY_TAG_PRE' => 'tidy/tidy.stub', 'TIDY_TAG_PROGRESS' => 'tidy/tidy.stub', 'TIDY_TAG_Q' => 'tidy/tidy.stub', 'TIDY_TAG_RB' => 'tidy/tidy.stub', 'TIDY_TAG_RBC' => 'tidy/tidy.stub', 'TIDY_TAG_RP' => 'tidy/tidy.stub', 'TIDY_TAG_RT' => 'tidy/tidy.stub', 'TIDY_TAG_RTC' => 'tidy/tidy.stub', 'TIDY_TAG_RUBY' => 'tidy/tidy.stub', 'TIDY_TAG_S' => 'tidy/tidy.stub', 'TIDY_TAG_SAMP' => 'tidy/tidy.stub', 'TIDY_TAG_SCRIPT' => 'tidy/tidy.stub', 'TIDY_TAG_SECTION' => 'tidy/tidy.stub', 'TIDY_TAG_SELECT' => 'tidy/tidy.stub', 'TIDY_TAG_SERVER' => 'tidy/tidy.stub', 'TIDY_TAG_SERVLET' => 'tidy/tidy.stub', 'TIDY_TAG_SMALL' => 'tidy/tidy.stub', 'TIDY_TAG_SOURCE' => 'tidy/tidy.stub', 'TIDY_TAG_SPACER' => 'tidy/tidy.stub', 'TIDY_TAG_SPAN' => 'tidy/tidy.stub', 'TIDY_TAG_STRIKE' => 'tidy/tidy.stub', 'TIDY_TAG_STRONG' => 'tidy/tidy.stub', 'TIDY_TAG_STYLE' => 'tidy/tidy.stub', 'TIDY_TAG_SUB' => 'tidy/tidy.stub', 'TIDY_TAG_SUMMARY' => 'tidy/tidy.stub', 'TIDY_TAG_SUP' => 'tidy/tidy.stub', 'TIDY_TAG_TABLE' => 'tidy/tidy.stub', 'TIDY_TAG_TBODY' => 'tidy/tidy.stub', 'TIDY_TAG_TD' => 'tidy/tidy.stub', 'TIDY_TAG_TEMPLATE' => 'tidy/tidy.stub', 'TIDY_TAG_TEXTAREA' => 'tidy/tidy.stub', 'TIDY_TAG_TFOOT' => 'tidy/tidy.stub', 'TIDY_TAG_TH' => 'tidy/tidy.stub', 'TIDY_TAG_THEAD' => 'tidy/tidy.stub', 'TIDY_TAG_TIME' => 'tidy/tidy.stub', 'TIDY_TAG_TITLE' => 'tidy/tidy.stub', 'TIDY_TAG_TR' => 'tidy/tidy.stub', 'TIDY_TAG_TRACK' => 'tidy/tidy.stub', 'TIDY_TAG_TT' => 'tidy/tidy.stub', 'TIDY_TAG_U' => 'tidy/tidy.stub', 'TIDY_TAG_UL' => 'tidy/tidy.stub', 'TIDY_TAG_UNKNOWN' => 'tidy/tidy.stub', 'TIDY_TAG_VAR' => 'tidy/tidy.stub', 'TIDY_TAG_VIDEO' => 'tidy/tidy.stub', 'TIDY_TAG_WBR' => 'tidy/tidy.stub', 'TIDY_TAG_XMP' => 'tidy/tidy.stub', 'TOKEN_PARSE' => 'tokenizer/tokenizer.stub', 'TRAP_BRKPT' => 'pcntl/pcntl.stub', 'TRAP_TRACE' => 'pcntl/pcntl.stub', 'TYPEAPPLICATION' => 'imap/imap.stub', 'TYPEAUDIO' => 'imap/imap.stub', 'TYPEIMAGE' => 'imap/imap.stub', 'TYPEMESSAGE' => 'imap/imap.stub', 'TYPEMODEL' => 'imap/imap.stub', 'TYPEMULTIPART' => 'imap/imap.stub', 'TYPEOTHER' => 'imap/imap.stub', 'TYPETEXT' => 'imap/imap.stub', 'TYPEVIDEO' => 'imap/imap.stub', 'T_ABSTRACT' => 'tokenizer/tokenizer.stub', 'T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG' => 'tokenizer/tokenizer.stub', 'T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG' => 'tokenizer/tokenizer.stub', 'T_AND_EQUAL' => 'tokenizer/tokenizer.stub', 'T_ARRAY' => 'tokenizer/tokenizer.stub', 'T_ARRAY_CAST' => 'tokenizer/tokenizer.stub', 'T_AS' => 'tokenizer/tokenizer.stub', 'T_ATTRIBUTE' => 'tokenizer/tokenizer.stub', 'T_BAD_CHARACTER' => 'tokenizer/tokenizer.stub', 'T_BOOLEAN_AND' => 'tokenizer/tokenizer.stub', 'T_BOOLEAN_OR' => 'tokenizer/tokenizer.stub', 'T_BOOL_CAST' => 'tokenizer/tokenizer.stub', 'T_BREAK' => 'tokenizer/tokenizer.stub', 'T_CALLABLE' => 'tokenizer/tokenizer.stub', 'T_CASE' => 'tokenizer/tokenizer.stub', 'T_CATCH' => 'tokenizer/tokenizer.stub', 'T_CHARACTER' => 'tokenizer/tokenizer.stub', 'T_CLASS' => 'tokenizer/tokenizer.stub', 'T_CLASS_C' => 'tokenizer/tokenizer.stub', 'T_CLONE' => 'tokenizer/tokenizer.stub', 'T_CLOSE_TAG' => 'tokenizer/tokenizer.stub', 'T_COALESCE' => 'tokenizer/tokenizer.stub', 'T_COALESCE_EQUAL' => 'tokenizer/tokenizer.stub', 'T_COMMENT' => 'tokenizer/tokenizer.stub', 'T_CONCAT_EQUAL' => 'tokenizer/tokenizer.stub', 'T_CONST' => 'tokenizer/tokenizer.stub', 'T_CONSTANT_ENCAPSED_STRING' => 'tokenizer/tokenizer.stub', 'T_CONTINUE' => 'tokenizer/tokenizer.stub', 'T_CURLY_OPEN' => 'tokenizer/tokenizer.stub', 'T_DEC' => 'tokenizer/tokenizer.stub', 'T_DECLARE' => 'tokenizer/tokenizer.stub', 'T_DEFAULT' => 'tokenizer/tokenizer.stub', 'T_DIR' => 'tokenizer/tokenizer.stub', 'T_DIV_EQUAL' => 'tokenizer/tokenizer.stub', 'T_DNUMBER' => 'tokenizer/tokenizer.stub', 'T_DO' => 'tokenizer/tokenizer.stub', 'T_DOC_COMMENT' => 'tokenizer/tokenizer.stub', 'T_DOLLAR_OPEN_CURLY_BRACES' => 'tokenizer/tokenizer.stub', 'T_DOUBLE_ARROW' => 'tokenizer/tokenizer.stub', 'T_DOUBLE_CAST' => 'tokenizer/tokenizer.stub', 'T_DOUBLE_COLON' => 'tokenizer/tokenizer.stub', 'T_ECHO' => 'tokenizer/tokenizer.stub', 'T_ELLIPSIS' => 'tokenizer/tokenizer.stub', 'T_ELSE' => 'tokenizer/tokenizer.stub', 'T_ELSEIF' => 'tokenizer/tokenizer.stub', 'T_EMPTY' => 'tokenizer/tokenizer.stub', 'T_ENCAPSED_AND_WHITESPACE' => 'tokenizer/tokenizer.stub', 'T_ENDDECLARE' => 'tokenizer/tokenizer.stub', 'T_ENDFOR' => 'tokenizer/tokenizer.stub', 'T_ENDFOREACH' => 'tokenizer/tokenizer.stub', 'T_ENDIF' => 'tokenizer/tokenizer.stub', 'T_ENDSWITCH' => 'tokenizer/tokenizer.stub', 'T_ENDWHILE' => 'tokenizer/tokenizer.stub', 'T_END_HEREDOC' => 'tokenizer/tokenizer.stub', 'T_ENUM' => 'tokenizer/tokenizer.stub', 'T_EVAL' => 'tokenizer/tokenizer.stub', 'T_EXIT' => 'tokenizer/tokenizer.stub', 'T_EXTENDS' => 'tokenizer/tokenizer.stub', 'T_FILE' => 'tokenizer/tokenizer.stub', 'T_FINAL' => 'tokenizer/tokenizer.stub', 'T_FINALLY' => 'tokenizer/tokenizer.stub', 'T_FMT' => 'standard/standard_defines.stub', 'T_FMT_AMPM' => 'standard/standard_defines.stub', 'T_FN' => 'tokenizer/tokenizer.stub', 'T_FOR' => 'tokenizer/tokenizer.stub', 'T_FOREACH' => 'tokenizer/tokenizer.stub', 'T_FUNCTION' => 'tokenizer/tokenizer.stub', 'T_FUNC_C' => 'tokenizer/tokenizer.stub', 'T_GLOBAL' => 'tokenizer/tokenizer.stub', 'T_GOTO' => 'tokenizer/tokenizer.stub', 'T_HALT_COMPILER' => 'tokenizer/tokenizer.stub', 'T_IF' => 'tokenizer/tokenizer.stub', 'T_IMPLEMENTS' => 'tokenizer/tokenizer.stub', 'T_INC' => 'tokenizer/tokenizer.stub', 'T_INCLUDE' => 'tokenizer/tokenizer.stub', 'T_INCLUDE_ONCE' => 'tokenizer/tokenizer.stub', 'T_INLINE_HTML' => 'tokenizer/tokenizer.stub', 'T_INSTANCEOF' => 'tokenizer/tokenizer.stub', 'T_INSTEADOF' => 'tokenizer/tokenizer.stub', 'T_INTERFACE' => 'tokenizer/tokenizer.stub', 'T_INT_CAST' => 'tokenizer/tokenizer.stub', 'T_ISSET' => 'tokenizer/tokenizer.stub', 'T_IS_EQUAL' => 'tokenizer/tokenizer.stub', 'T_IS_GREATER_OR_EQUAL' => 'tokenizer/tokenizer.stub', 'T_IS_IDENTICAL' => 'tokenizer/tokenizer.stub', 'T_IS_NOT_EQUAL' => 'tokenizer/tokenizer.stub', 'T_IS_NOT_IDENTICAL' => 'tokenizer/tokenizer.stub', 'T_IS_SMALLER_OR_EQUAL' => 'tokenizer/tokenizer.stub', 'T_LINE' => 'tokenizer/tokenizer.stub', 'T_LIST' => 'tokenizer/tokenizer.stub', 'T_LNUMBER' => 'tokenizer/tokenizer.stub', 'T_LOGICAL_AND' => 'tokenizer/tokenizer.stub', 'T_LOGICAL_OR' => 'tokenizer/tokenizer.stub', 'T_LOGICAL_XOR' => 'tokenizer/tokenizer.stub', 'T_MATCH' => 'tokenizer/tokenizer.stub', 'T_METHOD_C' => 'tokenizer/tokenizer.stub', 'T_MINUS_EQUAL' => 'tokenizer/tokenizer.stub', 'T_MOD_EQUAL' => 'tokenizer/tokenizer.stub', 'T_MUL_EQUAL' => 'tokenizer/tokenizer.stub', 'T_NAMESPACE' => 'tokenizer/tokenizer.stub', 'T_NAME_FULLY_QUALIFIED' => 'tokenizer/tokenizer.stub', 'T_NAME_QUALIFIED' => 'tokenizer/tokenizer.stub', 'T_NAME_RELATIVE' => 'tokenizer/tokenizer.stub', 'T_NEW' => 'tokenizer/tokenizer.stub', 'T_NS_C' => 'tokenizer/tokenizer.stub', 'T_NS_SEPARATOR' => 'tokenizer/tokenizer.stub', 'T_NULLSAFE_OBJECT_OPERATOR' => 'tokenizer/tokenizer.stub', 'T_NUM_STRING' => 'tokenizer/tokenizer.stub', 'T_OBJECT_CAST' => 'tokenizer/tokenizer.stub', 'T_OBJECT_OPERATOR' => 'tokenizer/tokenizer.stub', 'T_OPEN_TAG' => 'tokenizer/tokenizer.stub', 'T_OPEN_TAG_WITH_ECHO' => 'tokenizer/tokenizer.stub', 'T_OR_EQUAL' => 'tokenizer/tokenizer.stub', 'T_PAAMAYIM_NEKUDOTAYIM' => 'tokenizer/tokenizer.stub', 'T_PLUS_EQUAL' => 'tokenizer/tokenizer.stub', 'T_POW' => 'tokenizer/tokenizer.stub', 'T_POW_EQUAL' => 'tokenizer/tokenizer.stub', 'T_PRINT' => 'tokenizer/tokenizer.stub', 'T_PRIVATE' => 'tokenizer/tokenizer.stub', 'T_PRIVATE_SET' => 'tokenizer/tokenizer.stub', 'T_PROPERTY_C' => 'tokenizer/tokenizer.stub', 'T_PROTECTED' => 'tokenizer/tokenizer.stub', 'T_PROTECTED_SET' => 'tokenizer/tokenizer.stub', 'T_PUBLIC' => 'tokenizer/tokenizer.stub', 'T_PUBLIC_SET' => 'tokenizer/tokenizer.stub', 'T_READONLY' => 'tokenizer/tokenizer.stub', 'T_REQUIRE' => 'tokenizer/tokenizer.stub', 'T_REQUIRE_ONCE' => 'tokenizer/tokenizer.stub', 'T_RETURN' => 'tokenizer/tokenizer.stub', 'T_SL' => 'tokenizer/tokenizer.stub', 'T_SL_EQUAL' => 'tokenizer/tokenizer.stub', 'T_SPACESHIP' => 'tokenizer/tokenizer.stub', 'T_SR' => 'tokenizer/tokenizer.stub', 'T_SR_EQUAL' => 'tokenizer/tokenizer.stub', 'T_START_HEREDOC' => 'tokenizer/tokenizer.stub', 'T_STATIC' => 'tokenizer/tokenizer.stub', 'T_STRING' => 'tokenizer/tokenizer.stub', 'T_STRING_CAST' => 'tokenizer/tokenizer.stub', 'T_STRING_VARNAME' => 'tokenizer/tokenizer.stub', 'T_SWITCH' => 'tokenizer/tokenizer.stub', 'T_THROW' => 'tokenizer/tokenizer.stub', 'T_TRAIT' => 'tokenizer/tokenizer.stub', 'T_TRAIT_C' => 'tokenizer/tokenizer.stub', 'T_TRY' => 'tokenizer/tokenizer.stub', 'T_UNSET' => 'tokenizer/tokenizer.stub', 'T_UNSET_CAST' => 'tokenizer/tokenizer.stub', 'T_USE' => 'tokenizer/tokenizer.stub', 'T_VAR' => 'tokenizer/tokenizer.stub', 'T_VARIABLE' => 'tokenizer/tokenizer.stub', 'T_WHILE' => 'tokenizer/tokenizer.stub', 'T_WHITESPACE' => 'tokenizer/tokenizer.stub', 'T_XOR_EQUAL' => 'tokenizer/tokenizer.stub', 'T_YIELD' => 'tokenizer/tokenizer.stub', 'T_YIELD_FROM' => 'tokenizer/tokenizer.stub', 'TabControl' => 'winbinder/winbinder.stub', 'Timer' => 'winbinder/winbinder.stub', 'ToolBar' => 'winbinder/winbinder.stub', 'ToolDialog' => 'winbinder/winbinder.stub', 'TreeView' => 'winbinder/winbinder.stub', 'ULOC_ACTUAL_LOCALE' => 'intl/intl.stub', 'ULOC_VALID_LOCALE' => 'intl/intl.stub', 'UNKNOWN_TYPE' => 'soap/soap.stub', 'UPLOAD_ERR_CANT_WRITE' => 'Core/Core_d.stub', 'UPLOAD_ERR_EXTENSION' => 'Core/Core_d.stub', 'UPLOAD_ERR_FORM_SIZE' => 'Core/Core_d.stub', 'UPLOAD_ERR_INI_SIZE' => 'Core/Core_d.stub', 'UPLOAD_ERR_NO_FILE' => 'Core/Core_d.stub', 'UPLOAD_ERR_NO_TMP_DIR' => 'Core/Core_d.stub', 'UPLOAD_ERR_OK' => 'Core/Core_d.stub', 'UPLOAD_ERR_PARTIAL' => 'Core/Core_d.stub', 'UUID_TYPE_DCE' => 'uuid/uuid_c.stub', 'UUID_TYPE_DEFAULT' => 'uuid/uuid_c.stub', 'UUID_TYPE_INVALID' => 'uuid/uuid_c.stub', 'UUID_TYPE_MD5' => 'uuid/uuid_c.stub', 'UUID_TYPE_NAME' => 'uuid/uuid_c.stub', 'UUID_TYPE_NULL' => 'uuid/uuid_c.stub', 'UUID_TYPE_RANDOM' => 'uuid/uuid_c.stub', 'UUID_TYPE_SECURITY' => 'uuid/uuid_c.stub', 'UUID_TYPE_SHA1' => 'uuid/uuid_c.stub', 'UUID_TYPE_TIME' => 'uuid/uuid_c.stub', 'UUID_VARIANT_DCE' => 'uuid/uuid_c.stub', 'UUID_VARIANT_MICROSOFT' => 'uuid/uuid_c.stub', 'UUID_VARIANT_NCS' => 'uuid/uuid_c.stub', 'UUID_VARIANT_OTHER' => 'uuid/uuid_c.stub', 'U_AMBIGUOUS_ALIAS_WARNING' => 'intl/intl.stub', 'U_BAD_VARIABLE_DEFINITION' => 'intl/intl.stub', 'U_BRK_ASSIGN_ERROR' => 'intl/intl.stub', 'U_BRK_ERROR_LIMIT' => 'intl/intl.stub', 'U_BRK_ERROR_START' => 'intl/intl.stub', 'U_BRK_HEX_DIGITS_EXPECTED' => 'intl/intl.stub', 'U_BRK_INIT_ERROR' => 'intl/intl.stub', 'U_BRK_INTERNAL_ERROR' => 'intl/intl.stub', 'U_BRK_MALFORMED_RULE_TAG' => 'intl/intl.stub', 'U_BRK_MISMATCHED_PAREN' => 'intl/intl.stub', 'U_BRK_NEW_LINE_IN_QUOTED_STRING' => 'intl/intl.stub', 'U_BRK_RULE_EMPTY_SET' => 'intl/intl.stub', 'U_BRK_RULE_SYNTAX' => 'intl/intl.stub', 'U_BRK_SEMICOLON_EXPECTED' => 'intl/intl.stub', 'U_BRK_UNCLOSED_SET' => 'intl/intl.stub', 'U_BRK_UNDEFINED_VARIABLE' => 'intl/intl.stub', 'U_BRK_UNRECOGNIZED_OPTION' => 'intl/intl.stub', 'U_BRK_VARIABLE_REDFINITION' => 'intl/intl.stub', 'U_BUFFER_OVERFLOW_ERROR' => 'intl/intl.stub', 'U_CE_NOT_FOUND_ERROR' => 'intl/intl.stub', 'U_COLLATOR_VERSION_MISMATCH' => 'intl/intl.stub', 'U_DIFFERENT_UCA_VERSION' => 'intl/intl.stub', 'U_ENUM_OUT_OF_SYNC_ERROR' => 'intl/intl.stub', 'U_ERROR_LIMIT' => 'intl/intl.stub', 'U_ERROR_WARNING_LIMIT' => 'intl/intl.stub', 'U_ERROR_WARNING_START' => 'intl/intl.stub', 'U_FILE_ACCESS_ERROR' => 'intl/intl.stub', 'U_FMT_PARSE_ERROR_LIMIT' => 'intl/intl.stub', 'U_FMT_PARSE_ERROR_START' => 'intl/intl.stub', 'U_IDNA_ACE_PREFIX_ERROR' => 'intl/intl.stub', 'U_IDNA_CHECK_BIDI_ERROR' => 'intl/intl.stub', 'U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR' => 'intl/intl.stub', 'U_IDNA_ERROR_LIMIT' => 'intl/intl.stub', 'U_IDNA_ERROR_START' => 'intl/intl.stub', 'U_IDNA_LABEL_TOO_LONG_ERROR' => 'intl/intl.stub', 'U_IDNA_PROHIBITED_ERROR' => 'intl/intl.stub', 'U_IDNA_STD3_ASCII_RULES_ERROR' => 'intl/intl.stub', 'U_IDNA_UNASSIGNED_ERROR' => 'intl/intl.stub', 'U_IDNA_VERIFICATION_ERROR' => 'intl/intl.stub', 'U_IDNA_ZERO_LENGTH_LABEL_ERROR' => 'intl/intl.stub', 'U_ILLEGAL_ARGUMENT_ERROR' => 'intl/intl.stub', 'U_ILLEGAL_CHARACTER' => 'intl/intl.stub', 'U_ILLEGAL_CHAR_FOUND' => 'intl/intl.stub', 'U_ILLEGAL_CHAR_IN_SEGMENT' => 'intl/intl.stub', 'U_ILLEGAL_ESCAPE_SEQUENCE' => 'intl/intl.stub', 'U_ILLEGAL_PAD_POSITION' => 'intl/intl.stub', 'U_INDEX_OUTOFBOUNDS_ERROR' => 'intl/intl.stub', 'U_INTERNAL_PROGRAM_ERROR' => 'intl/intl.stub', 'U_INTERNAL_TRANSLITERATOR_ERROR' => 'intl/intl.stub', 'U_INVALID_CHAR_FOUND' => 'intl/intl.stub', 'U_INVALID_FORMAT_ERROR' => 'intl/intl.stub', 'U_INVALID_FUNCTION' => 'intl/intl.stub', 'U_INVALID_ID' => 'intl/intl.stub', 'U_INVALID_PROPERTY_PATTERN' => 'intl/intl.stub', 'U_INVALID_RBT_SYNTAX' => 'intl/intl.stub', 'U_INVALID_STATE_ERROR' => 'intl/intl.stub', 'U_INVALID_TABLE_FILE' => 'intl/intl.stub', 'U_INVALID_TABLE_FORMAT' => 'intl/intl.stub', 'U_INVARIANT_CONVERSION_ERROR' => 'intl/intl.stub', 'U_MALFORMED_EXPONENTIAL_PATTERN' => 'intl/intl.stub', 'U_MALFORMED_PRAGMA' => 'intl/intl.stub', 'U_MALFORMED_RULE' => 'intl/intl.stub', 'U_MALFORMED_SET' => 'intl/intl.stub', 'U_MALFORMED_SYMBOL_REFERENCE' => 'intl/intl.stub', 'U_MALFORMED_UNICODE_ESCAPE' => 'intl/intl.stub', 'U_MALFORMED_VARIABLE_DEFINITION' => 'intl/intl.stub', 'U_MALFORMED_VARIABLE_REFERENCE' => 'intl/intl.stub', 'U_MEMORY_ALLOCATION_ERROR' => 'intl/intl.stub', 'U_MESSAGE_PARSE_ERROR' => 'intl/intl.stub', 'U_MISMATCHED_SEGMENT_DELIMITERS' => 'intl/intl.stub', 'U_MISPLACED_ANCHOR_START' => 'intl/intl.stub', 'U_MISPLACED_COMPOUND_FILTER' => 'intl/intl.stub', 'U_MISPLACED_CURSOR_OFFSET' => 'intl/intl.stub', 'U_MISPLACED_QUANTIFIER' => 'intl/intl.stub', 'U_MISSING_OPERATOR' => 'intl/intl.stub', 'U_MISSING_RESOURCE_ERROR' => 'intl/intl.stub', 'U_MISSING_SEGMENT_CLOSE' => 'intl/intl.stub', 'U_MULTIPLE_ANTE_CONTEXTS' => 'intl/intl.stub', 'U_MULTIPLE_COMPOUND_FILTERS' => 'intl/intl.stub', 'U_MULTIPLE_CURSORS' => 'intl/intl.stub', 'U_MULTIPLE_DECIMAL_SEPARATORS' => 'intl/intl.stub', 'U_MULTIPLE_DECIMAL_SEPERATORS' => 'intl/intl.stub', 'U_MULTIPLE_EXPONENTIAL_SYMBOLS' => 'intl/intl.stub', 'U_MULTIPLE_PAD_SPECIFIERS' => 'intl/intl.stub', 'U_MULTIPLE_PERCENT_SYMBOLS' => 'intl/intl.stub', 'U_MULTIPLE_PERMILL_SYMBOLS' => 'intl/intl.stub', 'U_MULTIPLE_POST_CONTEXTS' => 'intl/intl.stub', 'U_NO_SPACE_AVAILABLE' => 'intl/intl.stub', 'U_NO_WRITE_PERMISSION' => 'intl/intl.stub', 'U_PARSE_ERROR' => 'intl/intl.stub', 'U_PARSE_ERROR_LIMIT' => 'intl/intl.stub', 'U_PARSE_ERROR_START' => 'intl/intl.stub', 'U_PATTERN_SYNTAX_ERROR' => 'intl/intl.stub', 'U_PRIMARY_TOO_LONG_ERROR' => 'intl/intl.stub', 'U_REGEX_BAD_ESCAPE_SEQUENCE' => 'intl/intl.stub', 'U_REGEX_BAD_INTERVAL' => 'intl/intl.stub', 'U_REGEX_ERROR_LIMIT' => 'intl/intl.stub', 'U_REGEX_ERROR_START' => 'intl/intl.stub', 'U_REGEX_INTERNAL_ERROR' => 'intl/intl.stub', 'U_REGEX_INVALID_BACK_REF' => 'intl/intl.stub', 'U_REGEX_INVALID_FLAG' => 'intl/intl.stub', 'U_REGEX_INVALID_STATE' => 'intl/intl.stub', 'U_REGEX_LOOK_BEHIND_LIMIT' => 'intl/intl.stub', 'U_REGEX_MAX_LT_MIN' => 'intl/intl.stub', 'U_REGEX_MISMATCHED_PAREN' => 'intl/intl.stub', 'U_REGEX_NUMBER_TOO_BIG' => 'intl/intl.stub', 'U_REGEX_PROPERTY_SYNTAX' => 'intl/intl.stub', 'U_REGEX_RULE_SYNTAX' => 'intl/intl.stub', 'U_REGEX_SET_CONTAINS_STRING' => 'intl/intl.stub', 'U_REGEX_UNIMPLEMENTED' => 'intl/intl.stub', 'U_RESOURCE_TYPE_MISMATCH' => 'intl/intl.stub', 'U_RULE_MASK_ERROR' => 'intl/intl.stub', 'U_SAFECLONE_ALLOCATED_WARNING' => 'intl/intl.stub', 'U_SORT_KEY_TOO_SHORT_WARNING' => 'intl/intl.stub', 'U_STANDARD_ERROR_LIMIT' => 'intl/intl.stub', 'U_STATE_OLD_WARNING' => 'intl/intl.stub', 'U_STATE_TOO_OLD_ERROR' => 'intl/intl.stub', 'U_STRINGPREP_CHECK_BIDI_ERROR' => 'intl/intl.stub', 'U_STRINGPREP_PROHIBITED_ERROR' => 'intl/intl.stub', 'U_STRINGPREP_UNASSIGNED_ERROR' => 'intl/intl.stub', 'U_STRING_NOT_TERMINATED_WARNING' => 'intl/intl.stub', 'U_TOO_MANY_ALIASES_ERROR' => 'intl/intl.stub', 'U_TRAILING_BACKSLASH' => 'intl/intl.stub', 'U_TRUNCATED_CHAR_FOUND' => 'intl/intl.stub', 'U_UNCLOSED_SEGMENT' => 'intl/intl.stub', 'U_UNDEFINED_SEGMENT_REFERENCE' => 'intl/intl.stub', 'U_UNDEFINED_VARIABLE' => 'intl/intl.stub', 'U_UNEXPECTED_TOKEN' => 'intl/intl.stub', 'U_UNMATCHED_BRACES' => 'intl/intl.stub', 'U_UNQUOTED_SPECIAL' => 'intl/intl.stub', 'U_UNSUPPORTED_ATTRIBUTE' => 'intl/intl.stub', 'U_UNSUPPORTED_ERROR' => 'intl/intl.stub', 'U_UNSUPPORTED_ESCAPE_SEQUENCE' => 'intl/intl.stub', 'U_UNSUPPORTED_PROPERTY' => 'intl/intl.stub', 'U_UNTERMINATED_QUOTE' => 'intl/intl.stub', 'U_USELESS_COLLATOR_ERROR' => 'intl/intl.stub', 'U_USING_DEFAULT_WARNING' => 'intl/intl.stub', 'U_USING_FALLBACK_WARNING' => 'intl/intl.stub', 'U_VARIABLE_RANGE_EXHAUSTED' => 'intl/intl.stub', 'U_VARIABLE_RANGE_OVERLAP' => 'intl/intl.stub', 'U_ZERO_ERROR' => 'intl/intl.stub', 'VARCMP_EQ' => 'com_dotnet/com_dotnet.stub', 'VARCMP_GT' => 'com_dotnet/com_dotnet.stub', 'VARCMP_LT' => 'com_dotnet/com_dotnet.stub', 'VARCMP_NULL' => 'com_dotnet/com_dotnet.stub', 'VIR_CONNECT_FLAG_SOUNDHW_GET_NAMES' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_LIST_NETWORKS_ACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_LIST_NETWORKS_AUTOSTART' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_LIST_NETWORKS_INACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_LIST_NETWORKS_PERSISTENT' => 'libvirt-php/libvirt-php.stub', 'VIR_CONNECT_LIST_NETWORKS_TRANSIENT' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_AUTHNAME' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_CNONCE' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_ECHOPROMPT' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_EXTERNAL' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_LANGUAGE' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_NOECHOPROMPT' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_PASSPHRASE' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_REALM' => 'libvirt-php/libvirt-php.stub', 'VIR_CRED_USERNAME' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_AFFECT_CONFIG' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_AFFECT_CURRENT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_AFFECT_LIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCKED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_COMMIT_ACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_COMMIT_DELETE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_COMMIT_RELATIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_COMMIT_SHALLOW' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_COPY_REUSE_EXT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_COPY_SHALLOW' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_TYPE_COPY' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_TYPE_PULL' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_REBASE_COPY' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_REBASE_COPY_DEV' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_REBASE_COPY_RAW' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_REBASE_RELATIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_REBASE_SHALLOW' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_BLOCK_RESIZE_BYTES' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_CRASHED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_DEVICE_MODIFY_CONFIG' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_DEVICE_MODIFY_CURRENT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_DEVICE_MODIFY_FORCE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_DEVICE_MODIFY_LIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_DISK_ACCESS_ALL' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_DISK_BLOCK' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_DISK_FILE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_FLAG_CLOCK_LOCALTIME' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_FLAG_FEATURE_ACPI' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_FLAG_FEATURE_APIC' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_FLAG_FEATURE_PAE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_FLAG_SOUND_AC97' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_FLAG_TEST_LOCAL_VNC' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_JOB_BOUNDED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_JOB_CANCELLED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_JOB_COMPLETED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_JOB_FAILED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_JOB_NONE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_JOB_UNBOUNDED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_AVAILABLE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_NR' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_RSS' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_SWAP_IN' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_SWAP_OUT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEMORY_STAT_UNUSED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEM_CONFIG' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEM_CURRENT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEM_LIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_MEM_MAXIMUM' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_METADATA_DESCRIPTION' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_METADATA_ELEMENT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_METADATA_TITLE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_NONE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_NOSTATE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_PAUSED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_PMSUSPENDED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_RUNNING' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_SHUTDOWN' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_SHUTOFF' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_START_AUTODESTROY' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_START_BYPASS_CACHE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_START_FORCE_BOOT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_START_PAUSED' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_START_VALIDATE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_STATS_BALLOON' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_STATS_BLOCK' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_STATS_CPU_TOTAL' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_STATS_INTERFACE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_STATS_STATE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_STATS_VCPU' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_UNDEFINE_KEEP_NVRAM' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_UNDEFINE_MANAGED_SAVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_UNDEFINE_NVRAM' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_VCPU_CONFIG' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_VCPU_CURRENT' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_VCPU_GUEST' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_VCPU_LIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_VCPU_MAXIMUM' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_XML_INACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_XML_MIGRATABLE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_XML_SECURE' => 'libvirt-php/libvirt-php.stub', 'VIR_DOMAIN_XML_UPDATE_CPU' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_ATSET1' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_ATSET2' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_ATSET3' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_LINUX' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_OSX' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_RFB' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_USB' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_WIN32' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_XT' => 'libvirt-php/libvirt-php.stub', 'VIR_KEYCODE_SET_XT_KBD' => 'libvirt-php/libvirt-php.stub', 'VIR_MEMORY_PHYSICAL' => 'libvirt-php/libvirt-php.stub', 'VIR_MEMORY_VIRTUAL' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_ABORT_ON_ERROR' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_AUTO_CONVERGE' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_CHANGE_PROTECTION' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_COMPRESSED' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_LIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_NON_SHARED_DISK' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_NON_SHARED_INC' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_OFFLINE' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_PAUSED' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_PEER2PEER' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_PERSIST_DEST' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_TUNNELLED' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_UNDEFINE_SOURCE' => 'libvirt-php/libvirt-php.stub', 'VIR_MIGRATE_UNSAFE' => 'libvirt-php/libvirt-php.stub', 'VIR_NETWORKS_ACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_NETWORKS_ALL' => 'libvirt-php/libvirt-php.stub', 'VIR_NETWORKS_INACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_NODE_CPU_STATS_ALL_CPUS' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_ATOMIC' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_CURRENT' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_DISK_ONLY' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_HALT' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_LIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_NO_METADATA' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_QUIESCE' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_REDEFINE' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_CREATE_REUSE_EXT' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_DELETE_CHILDREN' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_DELETE_CHILDREN_ONLY' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_DELETE_METADATA_ONLY' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_ACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_DESCENDANTS' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_DISK_ONLY' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_EXTERNAL' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_INACTIVE' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_INTERNAL' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_LEAVES' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_METADATA' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_NO_LEAVES' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_NO_METADATA' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_LIST_ROOTS' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_REVERT_FORCE' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_REVERT_PAUSED' => 'libvirt-php/libvirt-php.stub', 'VIR_SNAPSHOT_REVERT_RUNNING' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_POOL_BUILD_NEW' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_POOL_BUILD_REPAIR' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_POOL_BUILD_RESIZE' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_VOL_CREATE_REFLINK' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_VOL_RESIZE_ALLOCATE' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_VOL_RESIZE_DELTA' => 'libvirt-php/libvirt-php.stub', 'VIR_STORAGE_VOL_RESIZE_SHRINK' => 'libvirt-php/libvirt-php.stub', 'VIR_VERSION_BINDING' => 'libvirt-php/libvirt-php.stub', 'VIR_VERSION_LIBVIRT' => 'libvirt-php/libvirt-php.stub', 'VT_ARRAY' => 'com_dotnet/com_dotnet.stub', 'VT_BOOL' => 'com_dotnet/com_dotnet.stub', 'VT_BSTR' => 'com_dotnet/com_dotnet.stub', 'VT_BYREF' => 'com_dotnet/com_dotnet.stub', 'VT_CY' => 'com_dotnet/com_dotnet.stub', 'VT_DATE' => 'com_dotnet/com_dotnet.stub', 'VT_DECIMAL' => 'com_dotnet/com_dotnet.stub', 'VT_DISPATCH' => 'com_dotnet/com_dotnet.stub', 'VT_EMPTY' => 'com_dotnet/com_dotnet.stub', 'VT_ERROR' => 'com_dotnet/com_dotnet.stub', 'VT_I1' => 'com_dotnet/com_dotnet.stub', 'VT_I2' => 'com_dotnet/com_dotnet.stub', 'VT_I4' => 'com_dotnet/com_dotnet.stub', 'VT_INT' => 'com_dotnet/com_dotnet.stub', 'VT_NULL' => 'com_dotnet/com_dotnet.stub', 'VT_R4' => 'com_dotnet/com_dotnet.stub', 'VT_R8' => 'com_dotnet/com_dotnet.stub', 'VT_UI1' => 'com_dotnet/com_dotnet.stub', 'VT_UI2' => 'com_dotnet/com_dotnet.stub', 'VT_UI4' => 'com_dotnet/com_dotnet.stub', 'VT_UINT' => 'com_dotnet/com_dotnet.stub', 'VT_UNKNOWN' => 'com_dotnet/com_dotnet.stub', 'VT_VARIANT' => 'com_dotnet/com_dotnet.stub', 'WBC_ALT' => 'winbinder/winbinder.stub', 'WBC_AUTOREPEAT' => 'winbinder/winbinder.stub', 'WBC_BEEP' => 'winbinder/winbinder.stub', 'WBC_BORDER' => 'winbinder/winbinder.stub', 'WBC_BOTTOM' => 'winbinder/winbinder.stub', 'WBC_CENTER' => 'winbinder/winbinder.stub', 'WBC_CHECKBOXES' => 'winbinder/winbinder.stub', 'WBC_CONTROL' => 'winbinder/winbinder.stub', 'WBC_CUSTOMDRAW' => 'winbinder/winbinder.stub', 'WBC_DBLCLICK' => 'winbinder/winbinder.stub', 'WBC_DEFAULT' => 'winbinder/winbinder.stub', 'WBC_DEFAULTPOS' => 'winbinder/winbinder.stub', 'WBC_DISABLED' => 'winbinder/winbinder.stub', 'WBC_ELLIPSIS' => 'winbinder/winbinder.stub', 'WBC_ENABLED' => 'winbinder/winbinder.stub', 'WBC_GETFOCUS' => 'winbinder/winbinder.stub', 'WBC_GROUP' => 'winbinder/winbinder.stub', 'WBC_HEADERSEL' => 'winbinder/winbinder.stub', 'WBC_IMAGE' => 'winbinder/winbinder.stub', 'WBC_INFO' => 'winbinder/winbinder.stub', 'WBC_INVISIBLE' => 'winbinder/winbinder.stub', 'WBC_KEYDOWN' => 'winbinder/winbinder.stub', 'WBC_KEYUP' => 'winbinder/winbinder.stub', 'WBC_LBUTTON' => 'winbinder/winbinder.stub', 'WBC_LEFT' => 'winbinder/winbinder.stub', 'WBC_LINES' => 'winbinder/winbinder.stub', 'WBC_LV_BACK' => 'winbinder/winbinder.stub', 'WBC_LV_COLUMNS' => 'winbinder/winbinder.stub', 'WBC_LV_DEFAULT' => 'winbinder/winbinder.stub', 'WBC_LV_DRAW' => 'winbinder/winbinder.stub', 'WBC_LV_FORE' => 'winbinder/winbinder.stub', 'WBC_LV_NONE' => 'winbinder/winbinder.stub', 'WBC_MASKED' => 'winbinder/winbinder.stub', 'WBC_MAXIMIZED' => 'winbinder/winbinder.stub', 'WBC_MAXSIZE' => 'winbinder/winbinder.stub', 'WBC_MBUTTON' => 'winbinder/winbinder.stub', 'WBC_MIDDLE' => 'winbinder/winbinder.stub', 'WBC_MINIMIZED' => 'winbinder/winbinder.stub', 'WBC_MINSIZE' => 'winbinder/winbinder.stub', 'WBC_MOUSEDOWN' => 'winbinder/winbinder.stub', 'WBC_MOUSEMOVE' => 'winbinder/winbinder.stub', 'WBC_MOUSEUP' => 'winbinder/winbinder.stub', 'WBC_MULTILINE' => 'winbinder/winbinder.stub', 'WBC_MULTISELECT' => 'winbinder/winbinder.stub', 'WBC_NOHEADER' => 'winbinder/winbinder.stub', 'WBC_NORMAL' => 'winbinder/winbinder.stub', 'WBC_NOTIFY' => 'winbinder/winbinder.stub', 'WBC_NUMBER' => 'winbinder/winbinder.stub', 'WBC_OK' => 'winbinder/winbinder.stub', 'WBC_OKCANCEL' => 'winbinder/winbinder.stub', 'WBC_QUESTION' => 'winbinder/winbinder.stub', 'WBC_RBUTTON' => 'winbinder/winbinder.stub', 'WBC_READONLY' => 'winbinder/winbinder.stub', 'WBC_REDRAW' => 'winbinder/winbinder.stub', 'WBC_RESIZE' => 'winbinder/winbinder.stub', 'WBC_RIGHT' => 'winbinder/winbinder.stub', 'WBC_RTF_TEXT' => 'winbinder/winbinder.stub', 'WBC_SHIFT' => 'winbinder/winbinder.stub', 'WBC_SINGLE' => 'winbinder/winbinder.stub', 'WBC_SORT' => 'winbinder/winbinder.stub', 'WBC_STOP' => 'winbinder/winbinder.stub', 'WBC_TASKBAR' => 'winbinder/winbinder.stub', 'WBC_TITLE' => 'winbinder/winbinder.stub', 'WBC_TOP' => 'winbinder/winbinder.stub', 'WBC_TRANSPARENT' => 'winbinder/winbinder.stub', 'WBC_VERSION' => 'winbinder/winbinder.stub', 'WBC_VISIBLE' => 'winbinder/winbinder.stub', 'WBC_WARNING' => 'winbinder/winbinder.stub', 'WBC_YESNO' => 'winbinder/winbinder.stub', 'WBC_YESNOCANCEL' => 'winbinder/winbinder.stub', 'WCONTINUED' => 'pcntl/pcntl.stub', 'WEBSOCKET_CLOSE_ABNORMAL' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_DATA_ERROR' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_EXTENSION_MISSING' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_GOING_AWAY' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_MESSAGE_ERROR' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_MESSAGE_TOO_BIG' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_NORMAL' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_POLICY_ERROR' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_PROTOCOL_ERROR' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_SERVER_ERROR' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_STATUS_ERROR' => 'swoole/constants.stub', 'WEBSOCKET_CLOSE_TLS' => 'swoole/constants.stub', 'WEBSOCKET_OPCODE_BINARY' => 'swoole/constants.stub', 'WEBSOCKET_OPCODE_CLOSE' => 'swoole/constants.stub', 'WEBSOCKET_OPCODE_CONTINUATION' => 'swoole/constants.stub', 'WEBSOCKET_OPCODE_PING' => 'swoole/constants.stub', 'WEBSOCKET_OPCODE_PONG' => 'swoole/constants.stub', 'WEBSOCKET_OPCODE_TEXT' => 'swoole/constants.stub', 'WEBSOCKET_STATUS_ACTIVE' => 'swoole/constants.stub', 'WEBSOCKET_STATUS_CLOSING' => 'swoole/constants.stub', 'WEBSOCKET_STATUS_CONNECTION' => 'swoole/constants.stub', 'WEBSOCKET_STATUS_FRAME' => 'swoole/constants.stub', 'WEBSOCKET_STATUS_HANDSHAKE' => 'swoole/constants.stub', 'WEXITED' => 'pcntl/pcntl.stub', 'WHITE' => 'winbinder/winbinder.stub', 'WIN32_ABOVE_NORMAL_PRIORITY_CLASS' => 'win32service/win32service.stub', 'WIN32_BELOW_NORMAL_PRIORITY_CLASS' => 'win32service/win32service.stub', 'WIN32_ERROR_ACCESS_DENIED' => 'win32service/win32service.stub', 'WIN32_ERROR_CIRCULAR_DEPENDENCY' => 'win32service/win32service.stub', 'WIN32_ERROR_DATABASE_DOES_NOT_EXIST' => 'win32service/win32service.stub', 'WIN32_ERROR_DEPENDENT_SERVICES_RUNNING' => 'win32service/win32service.stub', 'WIN32_ERROR_DUPLICATE_SERVICE_NAME' => 'win32service/win32service.stub', 'WIN32_ERROR_FAILED_SERVICE_CONTROLLER_CONNECT' => 'win32service/win32service.stub', 'WIN32_ERROR_INSUFFICIENT_BUFFER' => 'win32service/win32service.stub', 'WIN32_ERROR_INVALID_DATA' => 'win32service/win32service.stub', 'WIN32_ERROR_INVALID_HANDLE' => 'win32service/win32service.stub', 'WIN32_ERROR_INVALID_LEVEL' => 'win32service/win32service.stub', 'WIN32_ERROR_INVALID_NAME' => 'win32service/win32service.stub', 'WIN32_ERROR_INVALID_PARAMETER' => 'win32service/win32service.stub', 'WIN32_ERROR_INVALID_SERVICE_ACCOUNT' => 'win32service/win32service.stub', 'WIN32_ERROR_INVALID_SERVICE_CONTROL' => 'win32service/win32service.stub', 'WIN32_ERROR_PATH_NOT_FOUND' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_ALREADY_RUNNING' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_CANNOT_ACCEPT_CTRL' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_DATABASE_LOCKED' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_DEPENDENCY_DELETED' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_DEPENDENCY_FAIL' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_DISABLED' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_DOES_NOT_EXIST' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_EXISTS' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_LOGON_FAILED' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_MARKED_FOR_DELETE' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_NOT_ACTIVE' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_NO_THREAD' => 'win32service/win32service.stub', 'WIN32_ERROR_SERVICE_REQUEST_TIMEOUT' => 'win32service/win32service.stub', 'WIN32_ERROR_SHUTDOWN_IN_PROGRESS' => 'win32service/win32service.stub', 'WIN32_HIGH_PRIORITY_CLASS' => 'win32service/win32service.stub', 'WIN32_IDLE_PRIORITY_CLASS' => 'win32service/win32service.stub', 'WIN32_NORMAL_PRIORITY_CLASS' => 'win32service/win32service.stub', 'WIN32_NO_ERROR' => 'win32service/win32service.stub', 'WIN32_REALTIME_PRIORITY_CLASS' => 'win32service/win32service.stub', 'WIN32_SERVICE_ACCEPT_PAUSE_CONTINUE' => 'win32service/win32service.stub', 'WIN32_SERVICE_ACCEPT_PRESHUTDOWN' => 'win32service/win32service.stub', 'WIN32_SERVICE_ACCEPT_SHUTDOWN' => 'win32service/win32service.stub', 'WIN32_SERVICE_ACCEPT_STOP' => 'win32service/win32service.stub', 'WIN32_SERVICE_AUTO_START' => 'win32service/win32service.stub', 'WIN32_SERVICE_CONTINUE_PENDING' => 'win32service/win32service.stub', 'WIN32_SERVICE_CONTROL_CONTINUE' => 'win32service/win32service.stub', 'WIN32_SERVICE_CONTROL_INTERROGATE' => 'win32service/win32service.stub', 'WIN32_SERVICE_CONTROL_PAUSE' => 'win32service/win32service.stub', 'WIN32_SERVICE_CONTROL_PRESHUTDOWN' => 'win32service/win32service.stub', 'WIN32_SERVICE_CONTROL_SHUTDOWN' => 'win32service/win32service.stub', 'WIN32_SERVICE_CONTROL_STOP' => 'win32service/win32service.stub', 'WIN32_SERVICE_DEMAND_START' => 'win32service/win32service.stub', 'WIN32_SERVICE_DISABLED' => 'win32service/win32service.stub', 'WIN32_SERVICE_ERROR_IGNORE' => 'win32service/win32service.stub', 'WIN32_SERVICE_ERROR_NORMAL' => 'win32service/win32service.stub', 'WIN32_SERVICE_INTERACTIVE_PROCESS' => 'win32service/win32service.stub', 'WIN32_SERVICE_PAUSED' => 'win32service/win32service.stub', 'WIN32_SERVICE_PAUSE_PENDING' => 'win32service/win32service.stub', 'WIN32_SERVICE_RUNNING' => 'win32service/win32service.stub', 'WIN32_SERVICE_RUNS_IN_SYSTEM_PROCESS' => 'win32service/win32service.stub', 'WIN32_SERVICE_START_PENDING' => 'win32service/win32service.stub', 'WIN32_SERVICE_STOPPED' => 'win32service/win32service.stub', 'WIN32_SERVICE_STOP_PENDING' => 'win32service/win32service.stub', 'WIN32_SERVICE_WIN32_OWN_PROCESS' => 'win32service/win32service.stub', 'WIN32_SERVICE_WIN32_OWN_PROCESS_INTERACTIVE' => 'win32service/win32service.stub', 'WNOHANG' => 'pcntl/pcntl.stub', 'WNOWAIT' => 'pcntl/pcntl.stub', 'WSDL_CACHE_BOTH' => 'soap/soap.stub', 'WSDL_CACHE_DISK' => 'soap/soap.stub', 'WSDL_CACHE_MEMORY' => 'soap/soap.stub', 'WSDL_CACHE_NONE' => 'soap/soap.stub', 'WSTOPPED' => 'pcntl/pcntl.stub', 'WUNTRACED' => 'pcntl/pcntl.stub', 'X509_PURPOSE_ANY' => 'openssl/openssl.stub', 'X509_PURPOSE_CRL_SIGN' => 'openssl/openssl.stub', 'X509_PURPOSE_NS_SSL_SERVER' => 'openssl/openssl.stub', 'X509_PURPOSE_OCSP_HELPER' => 'openssl/openssl.stub', 'X509_PURPOSE_SMIME_ENCRYPT' => 'openssl/openssl.stub', 'X509_PURPOSE_SMIME_SIGN' => 'openssl/openssl.stub', 'X509_PURPOSE_SSL_CLIENT' => 'openssl/openssl.stub', 'X509_PURPOSE_SSL_SERVER' => 'openssl/openssl.stub', 'X509_PURPOSE_TIMESTAMP_SIGN' => 'openssl/openssl.stub', 'XDEBUG_CC_BRANCH_CHECK' => 'xdebug/xdebug.stub', 'XDEBUG_CC_DEAD_CODE' => 'xdebug/xdebug.stub', 'XDEBUG_CC_UNUSED' => 'xdebug/xdebug.stub', 'XDEBUG_FILTER_CODE_COVERAGE' => 'xdebug/xdebug.stub', 'XDEBUG_FILTER_NONE' => 'xdebug/xdebug.stub', 'XDEBUG_FILTER_STACK' => 'xdebug/xdebug.stub', 'XDEBUG_FILTER_TRACING' => 'xdebug/xdebug.stub', 'XDEBUG_NAMESPACE_BLACKLIST' => 'xdebug/xdebug.stub', 'XDEBUG_NAMESPACE_EXCLUDE' => 'xdebug/xdebug.stub', 'XDEBUG_NAMESPACE_INCLUDE' => 'xdebug/xdebug.stub', 'XDEBUG_NAMESPACE_WHITELIST' => 'xdebug/xdebug.stub', 'XDEBUG_PATH_BLACKLIST' => 'xdebug/xdebug.stub', 'XDEBUG_PATH_EXCLUDE' => 'xdebug/xdebug.stub', 'XDEBUG_PATH_INCLUDE' => 'xdebug/xdebug.stub', 'XDEBUG_PATH_WHITELIST' => 'xdebug/xdebug.stub', 'XDEBUG_STACK_NO_DESC' => 'xdebug/xdebug.stub', 'XDEBUG_TRACE_APPEND' => 'xdebug/xdebug.stub', 'XDEBUG_TRACE_COMPUTERIZED' => 'xdebug/xdebug.stub', 'XDEBUG_TRACE_HTML' => 'xdebug/xdebug.stub', 'XDEBUG_TRACE_NAKED_FILENAME' => 'xdebug/xdebug.stub', 'XDIFF_PATCH_IGNORESPACE' => 'xdiff/xdiff.stub', 'XDIFF_PATCH_NORMAL' => 'xdiff/xdiff.stub', 'XDIFF_PATCH_REVERSE' => 'xdiff/xdiff.stub', 'XHPROF_FLAGS_CPU' => 'xhprof/xhprof.stub', 'XHPROF_FLAGS_MEMORY' => 'xhprof/xhprof.stub', 'XHPROF_FLAGS_NO_BUILTINS' => 'xhprof/xhprof.stub', 'XML_ATTRIBUTE_CDATA' => 'dom/dom.stub', 'XML_ATTRIBUTE_DECL_NODE' => 'dom/dom.stub', 'XML_ATTRIBUTE_ENTITY' => 'dom/dom.stub', 'XML_ATTRIBUTE_ENUMERATION' => 'dom/dom.stub', 'XML_ATTRIBUTE_ID' => 'dom/dom.stub', 'XML_ATTRIBUTE_IDREF' => 'dom/dom.stub', 'XML_ATTRIBUTE_IDREFS' => 'dom/dom.stub', 'XML_ATTRIBUTE_NMTOKEN' => 'dom/dom.stub', 'XML_ATTRIBUTE_NMTOKENS' => 'dom/dom.stub', 'XML_ATTRIBUTE_NODE' => 'dom/dom.stub', 'XML_ATTRIBUTE_NOTATION' => 'dom/dom.stub', 'XML_CDATA_SECTION_NODE' => 'dom/dom.stub', 'XML_COMMENT_NODE' => 'dom/dom.stub', 'XML_DOCUMENT_FRAG_NODE' => 'dom/dom.stub', 'XML_DOCUMENT_NODE' => 'dom/dom.stub', 'XML_DOCUMENT_TYPE_NODE' => 'dom/dom.stub', 'XML_DTD_NODE' => 'dom/dom.stub', 'XML_ELEMENT_DECL_NODE' => 'dom/dom.stub', 'XML_ELEMENT_NODE' => 'dom/dom.stub', 'XML_ENTITY_DECL_NODE' => 'dom/dom.stub', 'XML_ENTITY_NODE' => 'dom/dom.stub', 'XML_ENTITY_REF_NODE' => 'dom/dom.stub', 'XML_ERROR_ASYNC_ENTITY' => 'xml/xml.stub', 'XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF' => 'xml/xml.stub', 'XML_ERROR_BAD_CHAR_REF' => 'xml/xml.stub', 'XML_ERROR_BINARY_ENTITY_REF' => 'xml/xml.stub', 'XML_ERROR_DUPLICATE_ATTRIBUTE' => 'xml/xml.stub', 'XML_ERROR_EXTERNAL_ENTITY_HANDLING' => 'xml/xml.stub', 'XML_ERROR_INCORRECT_ENCODING' => 'xml/xml.stub', 'XML_ERROR_INVALID_TOKEN' => 'xml/xml.stub', 'XML_ERROR_JUNK_AFTER_DOC_ELEMENT' => 'xml/xml.stub', 'XML_ERROR_MISPLACED_XML_PI' => 'xml/xml.stub', 'XML_ERROR_NONE' => 'xml/xml.stub', 'XML_ERROR_NO_ELEMENTS' => 'xml/xml.stub', 'XML_ERROR_NO_MEMORY' => 'xml/xml.stub', 'XML_ERROR_PARAM_ENTITY_REF' => 'xml/xml.stub', 'XML_ERROR_PARTIAL_CHAR' => 'xml/xml.stub', 'XML_ERROR_RECURSIVE_ENTITY_REF' => 'xml/xml.stub', 'XML_ERROR_SYNTAX' => 'xml/xml.stub', 'XML_ERROR_TAG_MISMATCH' => 'xml/xml.stub', 'XML_ERROR_UNCLOSED_CDATA_SECTION' => 'xml/xml.stub', 'XML_ERROR_UNCLOSED_TOKEN' => 'xml/xml.stub', 'XML_ERROR_UNDEFINED_ENTITY' => 'xml/xml.stub', 'XML_ERROR_UNKNOWN_ENCODING' => 'xml/xml.stub', 'XML_HTML_DOCUMENT_NODE' => 'dom/dom.stub', 'XML_LOCAL_NAMESPACE' => 'dom/dom.stub', 'XML_NAMESPACE_DECL_NODE' => 'dom/dom.stub', 'XML_NOTATION_NODE' => 'dom/dom.stub', 'XML_OPTION_CASE_FOLDING' => 'xml/xml.stub', 'XML_OPTION_PARSE_HUGE' => 'xml/xml.stub', 'XML_OPTION_SKIP_TAGSTART' => 'xml/xml.stub', 'XML_OPTION_SKIP_WHITE' => 'xml/xml.stub', 'XML_OPTION_TARGET_ENCODING' => 'xml/xml.stub', 'XML_PI_NODE' => 'dom/dom.stub', 'XML_SAX_IMPL' => 'xml/xml.stub', 'XML_TEXT_NODE' => 'dom/dom.stub', 'XSD_1999_NAMESPACE' => 'soap/soap.stub', 'XSD_1999_TIMEINSTANT' => 'soap/soap.stub', 'XSD_ANYTYPE' => 'soap/soap.stub', 'XSD_ANYURI' => 'soap/soap.stub', 'XSD_ANYXML' => 'soap/soap.stub', 'XSD_BASE64BINARY' => 'soap/soap.stub', 'XSD_BOOLEAN' => 'soap/soap.stub', 'XSD_BYTE' => 'soap/soap.stub', 'XSD_DATE' => 'soap/soap.stub', 'XSD_DATETIME' => 'soap/soap.stub', 'XSD_DECIMAL' => 'soap/soap.stub', 'XSD_DOUBLE' => 'soap/soap.stub', 'XSD_DURATION' => 'soap/soap.stub', 'XSD_ENTITIES' => 'soap/soap.stub', 'XSD_ENTITY' => 'soap/soap.stub', 'XSD_FLOAT' => 'soap/soap.stub', 'XSD_GDAY' => 'soap/soap.stub', 'XSD_GMONTH' => 'soap/soap.stub', 'XSD_GMONTHDAY' => 'soap/soap.stub', 'XSD_GYEAR' => 'soap/soap.stub', 'XSD_GYEARMONTH' => 'soap/soap.stub', 'XSD_HEXBINARY' => 'soap/soap.stub', 'XSD_ID' => 'soap/soap.stub', 'XSD_IDREF' => 'soap/soap.stub', 'XSD_IDREFS' => 'soap/soap.stub', 'XSD_INT' => 'soap/soap.stub', 'XSD_INTEGER' => 'soap/soap.stub', 'XSD_LANGUAGE' => 'soap/soap.stub', 'XSD_LONG' => 'soap/soap.stub', 'XSD_NAME' => 'soap/soap.stub', 'XSD_NAMESPACE' => 'soap/soap.stub', 'XSD_NCNAME' => 'soap/soap.stub', 'XSD_NEGATIVEINTEGER' => 'soap/soap.stub', 'XSD_NMTOKEN' => 'soap/soap.stub', 'XSD_NMTOKENS' => 'soap/soap.stub', 'XSD_NONNEGATIVEINTEGER' => 'soap/soap.stub', 'XSD_NONPOSITIVEINTEGER' => 'soap/soap.stub', 'XSD_NORMALIZEDSTRING' => 'soap/soap.stub', 'XSD_NOTATION' => 'soap/soap.stub', 'XSD_POSITIVEINTEGER' => 'soap/soap.stub', 'XSD_QNAME' => 'soap/soap.stub', 'XSD_SHORT' => 'soap/soap.stub', 'XSD_STRING' => 'soap/soap.stub', 'XSD_TIME' => 'soap/soap.stub', 'XSD_TOKEN' => 'soap/soap.stub', 'XSD_UNSIGNEDBYTE' => 'soap/soap.stub', 'XSD_UNSIGNEDINT' => 'soap/soap.stub', 'XSD_UNSIGNEDLONG' => 'soap/soap.stub', 'XSD_UNSIGNEDSHORT' => 'soap/soap.stub', 'XSL_CLONE_ALWAYS' => 'xsl/xsl.stub', 'XSL_CLONE_AUTO' => 'xsl/xsl.stub', 'XSL_CLONE_NEVER' => 'xsl/xsl.stub', 'XSL_SECPREF_CREATE_DIRECTORY' => 'xsl/xsl.stub', 'XSL_SECPREF_DEFAULT' => 'xsl/xsl.stub', 'XSL_SECPREF_NONE' => 'xsl/xsl.stub', 'XSL_SECPREF_READ_FILE' => 'xsl/xsl.stub', 'XSL_SECPREF_READ_NETWORK' => 'xsl/xsl.stub', 'XSL_SECPREF_WRITE_FILE' => 'xsl/xsl.stub', 'XSL_SECPREF_WRITE_NETWORK' => 'xsl/xsl.stub', 'YAF\\ENVIRON' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\AUTOLOAD\\FAILED' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\CALL\\FAILED' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\DISPATCH\\FAILED' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\NOTFOUND\\ACTION' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\NOTFOUND\\CONTROLLER' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\NOTFOUND\\MODULE' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\NOTFOUND\\VIEW' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\ROUTE\\FAILED' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\STARTUP\\FAILED' => 'yaf/yaf_namespace.stub', 'YAF\\ERR\\TYPE\\ERROR' => 'yaf/yaf_namespace.stub', 'YAF\\VERSION' => 'yaf/yaf_namespace.stub', 'YAF_ENVIRON' => 'yaf/yaf.stub', 'YAF_ERR_ACCESS_ERROR' => 'yaf/yaf.stub', 'YAF_ERR_AUTOLOAD_FAILED' => 'yaf/yaf.stub', 'YAF_ERR_CALL_FAILED' => 'yaf/yaf.stub', 'YAF_ERR_DISPATCH_FAILED' => 'yaf/yaf.stub', 'YAF_ERR_NOTFOUND_ACTION' => 'yaf/yaf.stub', 'YAF_ERR_NOTFOUND_CONTROLLER' => 'yaf/yaf.stub', 'YAF_ERR_NOTFOUND_MODULE' => 'yaf/yaf.stub', 'YAF_ERR_NOTFOUND_VIEW' => 'yaf/yaf.stub', 'YAF_ERR_ROUTE_FAILED' => 'yaf/yaf.stub', 'YAF_ERR_STARTUP_FAILED' => 'yaf/yaf.stub', 'YAF_ERR_TYPE_ERROR' => 'yaf/yaf.stub', 'YAF_VERSION' => 'yaf/yaf.stub', 'YAML_ANY_BREAK' => 'yaml/yaml.stub', 'YAML_ANY_ENCODING' => 'yaml/yaml.stub', 'YAML_ANY_SCALAR_STYLE' => 'yaml/yaml.stub', 'YAML_BINARY_TAG' => 'yaml/yaml.stub', 'YAML_BOOL_TAG' => 'yaml/yaml.stub', 'YAML_CRLN_BREAK' => 'yaml/yaml.stub', 'YAML_CR_BREAK' => 'yaml/yaml.stub', 'YAML_DOUBLE_QUOTED_SCALAR_STYLE' => 'yaml/yaml.stub', 'YAML_FLOAT_TAG' => 'yaml/yaml.stub', 'YAML_FOLDED_SCALAR_STYLE' => 'yaml/yaml.stub', 'YAML_INT_TAG' => 'yaml/yaml.stub', 'YAML_LITERAL_SCALAR_STYLE' => 'yaml/yaml.stub', 'YAML_LN_BREAK' => 'yaml/yaml.stub', 'YAML_MAP_TAG' => 'yaml/yaml.stub', 'YAML_MERGE_TAG' => 'yaml/yaml.stub', 'YAML_NULL_TAG' => 'yaml/yaml.stub', 'YAML_PHP_TAG' => 'yaml/yaml.stub', 'YAML_PLAIN_SCALAR_STYLE' => 'yaml/yaml.stub', 'YAML_SEQ_TAG' => 'yaml/yaml.stub', 'YAML_SINGLE_QUOTED_SCALAR_STYLE' => 'yaml/yaml.stub', 'YAML_STR_TAG' => 'yaml/yaml.stub', 'YAML_TIMESTAMP_TAG' => 'yaml/yaml.stub', 'YAML_UTF16BE_ENCODING' => 'yaml/yaml.stub', 'YAML_UTF16LE_ENCODING' => 'yaml/yaml.stub', 'YAML_UTF8_ENCODING' => 'yaml/yaml.stub', 'YAR_CLIENT_PROTOCOL_HTTP' => 'yar/yar.stub', 'YAR_CLIENT_PROTOCOL_TCP' => 'yar/yar.stub', 'YAR_CLIENT_PROTOCOL_UNIX' => 'yar/yar.stub', 'YAR_ERR_EXCEPTION' => 'yar/yar.stub', 'YAR_ERR_OKEY' => 'yar/yar.stub', 'YAR_ERR_OUTPUT' => 'yar/yar.stub', 'YAR_ERR_PACKAGER' => 'yar/yar.stub', 'YAR_ERR_PROTOCOL' => 'yar/yar.stub', 'YAR_ERR_REQUEST' => 'yar/yar.stub', 'YAR_ERR_TRANSPORT' => 'yar/yar.stub', 'YAR_OPT_CONNECT_TIMEOUT' => 'yar/yar.stub', 'YAR_OPT_HEADER' => 'yar/yar.stub', 'YAR_OPT_PACKAGER' => 'yar/yar.stub', 'YAR_OPT_PERSISTENT' => 'yar/yar.stub', 'YAR_OPT_RESOLVE' => 'yar/yar.stub', 'YAR_OPT_TIMEOUT' => 'yar/yar.stub', 'YAR_PACKAGER_JSON' => 'yar/yar.stub', 'YAR_PACKAGER_PHP' => 'yar/yar.stub', 'YAR_VERSION' => 'yar/yar.stub', 'YELLOW' => 'winbinder/winbinder.stub', 'YESEXPR' => 'standard/standard_defines.stub', 'YESSTR' => 'standard/standard_defines.stub', 'ZEND_ACC_ABSTRACT' => 'uopz/uopz.stub', 'ZEND_ACC_FETCH' => 'uopz/uopz.stub', 'ZEND_ACC_FINAL' => 'uopz/uopz.stub', 'ZEND_ACC_PPP_MASK' => 'uopz/uopz.stub', 'ZEND_ACC_PRIVATE' => 'uopz/uopz.stub', 'ZEND_ACC_PROTECTED' => 'uopz/uopz.stub', 'ZEND_ACC_PUBLIC' => 'uopz/uopz.stub', 'ZEND_ACC_STATIC' => 'uopz/uopz.stub', 'ZEND_DEBUG_BUILD' => 'Core/Core_d.stub', 'ZEND_MULTIBYTE' => 'Core/Core_d.stub', 'ZEND_THREAD_SAFE' => 'Core/Core_d.stub', 'ZLIB_BLOCK' => 'zlib/zlib.stub', 'ZLIB_BUF_ERROR' => 'zlib/zlib.stub', 'ZLIB_DATA_ERROR' => 'zlib/zlib.stub', 'ZLIB_DEFAULT_STRATEGY' => 'zlib/zlib.stub', 'ZLIB_ENCODING_DEFLATE' => 'zlib/zlib.stub', 'ZLIB_ENCODING_GZIP' => 'zlib/zlib.stub', 'ZLIB_ENCODING_RAW' => 'zlib/zlib.stub', 'ZLIB_ERRNO' => 'zlib/zlib.stub', 'ZLIB_FILTERED' => 'zlib/zlib.stub', 'ZLIB_FINISH' => 'zlib/zlib.stub', 'ZLIB_FIXED' => 'zlib/zlib.stub', 'ZLIB_FULL_FLUSH' => 'zlib/zlib.stub', 'ZLIB_HUFFMAN_ONLY' => 'zlib/zlib.stub', 'ZLIB_MEM_ERROR' => 'zlib/zlib.stub', 'ZLIB_NEED_DICT' => 'zlib/zlib.stub', 'ZLIB_NO_FLUSH' => 'zlib/zlib.stub', 'ZLIB_OK' => 'zlib/zlib.stub', 'ZLIB_PARTIAL_FLUSH' => 'zlib/zlib.stub', 'ZLIB_RLE' => 'zlib/zlib.stub', 'ZLIB_STREAM_END' => 'zlib/zlib.stub', 'ZLIB_STREAM_ERROR' => 'zlib/zlib.stub', 'ZLIB_SYNC_FLUSH' => 'zlib/zlib.stub', 'ZLIB_VERNUM' => 'zlib/zlib.stub', 'ZLIB_VERSION' => 'zlib/zlib.stub', 'ZLIB_VERSION_ERROR' => 'zlib/zlib.stub', 'ZSTD_COMPRESS_LEVEL_DEFAULT' => 'zstd/zstd.stub', 'ZSTD_COMPRESS_LEVEL_MAX' => 'zstd/zstd.stub', 'ZSTD_COMPRESS_LEVEL_MIN' => 'zstd/zstd.stub', '__CLASS__' => 'standard/basic.stub', '__COMPILER_HALT_OFFSET__' => 'standard/_standard_manual.stub', '__DIR__' => 'standard/basic.stub', '__FILE__' => 'standard/basic.stub', '__FUNCTION__' => 'standard/basic.stub', '__LINE__' => 'standard/basic.stub', '__METHOD__' => 'standard/basic.stub', '__NAMESPACE__' => 'standard/basic.stub', '__TRAIT__' => 'standard/basic.stub', '__class__' => 'standard/basic.stub', '__dir__' => 'standard/basic.stub', '__file__' => 'standard/basic.stub', '__function__' => 'standard/basic.stub', '__line__' => 'standard/basic.stub', '__method__' => 'standard/basic.stub', '__namespace__' => 'standard/basic.stub', '__trait__' => 'standard/basic.stub', 'ast\\AST_ARG_LIST' => 'ast/ast.stub', 'ast\\AST_ARRAY' => 'ast/ast.stub', 'ast\\AST_ARRAY_ELEM' => 'ast/ast.stub', 'ast\\AST_ARROW_FUNC' => 'ast/ast.stub', 'ast\\AST_ASSIGN' => 'ast/ast.stub', 'ast\\AST_ASSIGN_OP' => 'ast/ast.stub', 'ast\\AST_ASSIGN_REF' => 'ast/ast.stub', 'ast\\AST_ATTRIBUTE' => 'ast/ast.stub', 'ast\\AST_ATTRIBUTE_GROUP' => 'ast/ast.stub', 'ast\\AST_ATTRIBUTE_LIST' => 'ast/ast.stub', 'ast\\AST_BINARY_OP' => 'ast/ast.stub', 'ast\\AST_BREAK' => 'ast/ast.stub', 'ast\\AST_CALL' => 'ast/ast.stub', 'ast\\AST_CAST' => 'ast/ast.stub', 'ast\\AST_CATCH' => 'ast/ast.stub', 'ast\\AST_CATCH_LIST' => 'ast/ast.stub', 'ast\\AST_CLASS' => 'ast/ast.stub', 'ast\\AST_CLASS_CONST' => 'ast/ast.stub', 'ast\\AST_CLASS_CONST_DECL' => 'ast/ast.stub', 'ast\\AST_CLASS_CONST_GROUP' => 'ast/ast.stub', 'ast\\AST_CLASS_NAME' => 'ast/ast.stub', 'ast\\AST_CLONE' => 'ast/ast.stub', 'ast\\AST_CLOSURE' => 'ast/ast.stub', 'ast\\AST_CLOSURE_USES' => 'ast/ast.stub', 'ast\\AST_CLOSURE_VAR' => 'ast/ast.stub', 'ast\\AST_CONDITIONAL' => 'ast/ast.stub', 'ast\\AST_CONST' => 'ast/ast.stub', 'ast\\AST_CONST_DECL' => 'ast/ast.stub', 'ast\\AST_CONST_ELEM' => 'ast/ast.stub', 'ast\\AST_CONTINUE' => 'ast/ast.stub', 'ast\\AST_DECLARE' => 'ast/ast.stub', 'ast\\AST_DIM' => 'ast/ast.stub', 'ast\\AST_DO_WHILE' => 'ast/ast.stub', 'ast\\AST_ECHO' => 'ast/ast.stub', 'ast\\AST_EMPTY' => 'ast/ast.stub', 'ast\\AST_ENCAPS_LIST' => 'ast/ast.stub', 'ast\\AST_EXIT' => 'ast/ast.stub', 'ast\\AST_EXPR_LIST' => 'ast/ast.stub', 'ast\\AST_FOR' => 'ast/ast.stub', 'ast\\AST_FOREACH' => 'ast/ast.stub', 'ast\\AST_FUNC_DECL' => 'ast/ast.stub', 'ast\\AST_GLOBAL' => 'ast/ast.stub', 'ast\\AST_GOTO' => 'ast/ast.stub', 'ast\\AST_GROUP_USE' => 'ast/ast.stub', 'ast\\AST_HALT_COMPILER' => 'ast/ast.stub', 'ast\\AST_IF' => 'ast/ast.stub', 'ast\\AST_IF_ELEM' => 'ast/ast.stub', 'ast\\AST_INCLUDE_OR_EVAL' => 'ast/ast.stub', 'ast\\AST_INSTANCEOF' => 'ast/ast.stub', 'ast\\AST_ISSET' => 'ast/ast.stub', 'ast\\AST_LABEL' => 'ast/ast.stub', 'ast\\AST_LIST' => 'ast/ast.stub', 'ast\\AST_MAGIC_CONST' => 'ast/ast.stub', 'ast\\AST_MATCH' => 'ast/ast.stub', 'ast\\AST_MATCH_ARM' => 'ast/ast.stub', 'ast\\AST_MATCH_ARM_LIST' => 'ast/ast.stub', 'ast\\AST_METHOD' => 'ast/ast.stub', 'ast\\AST_METHOD_CALL' => 'ast/ast.stub', 'ast\\AST_METHOD_REFERENCE' => 'ast/ast.stub', 'ast\\AST_NAME' => 'ast/ast.stub', 'ast\\AST_NAMED_ARG' => 'ast/ast.stub', 'ast\\AST_NAMESPACE' => 'ast/ast.stub', 'ast\\AST_NAME_LIST' => 'ast/ast.stub', 'ast\\AST_NEW' => 'ast/ast.stub', 'ast\\AST_NULLABLE_TYPE' => 'ast/ast.stub', 'ast\\AST_NULLSAFE_METHOD_CALL' => 'ast/ast.stub', 'ast\\AST_NULLSAFE_PROP' => 'ast/ast.stub', 'ast\\AST_PARAM' => 'ast/ast.stub', 'ast\\AST_PARAM_LIST' => 'ast/ast.stub', 'ast\\AST_POST_DEC' => 'ast/ast.stub', 'ast\\AST_POST_INC' => 'ast/ast.stub', 'ast\\AST_PRE_DEC' => 'ast/ast.stub', 'ast\\AST_PRE_INC' => 'ast/ast.stub', 'ast\\AST_PRINT' => 'ast/ast.stub', 'ast\\AST_PROP' => 'ast/ast.stub', 'ast\\AST_PROP_DECL' => 'ast/ast.stub', 'ast\\AST_PROP_ELEM' => 'ast/ast.stub', 'ast\\AST_PROP_GROUP' => 'ast/ast.stub', 'ast\\AST_REF' => 'ast/ast.stub', 'ast\\AST_RETURN' => 'ast/ast.stub', 'ast\\AST_SHELL_EXEC' => 'ast/ast.stub', 'ast\\AST_STATIC' => 'ast/ast.stub', 'ast\\AST_STATIC_CALL' => 'ast/ast.stub', 'ast\\AST_STATIC_PROP' => 'ast/ast.stub', 'ast\\AST_STMT_LIST' => 'ast/ast.stub', 'ast\\AST_SWITCH' => 'ast/ast.stub', 'ast\\AST_SWITCH_CASE' => 'ast/ast.stub', 'ast\\AST_SWITCH_LIST' => 'ast/ast.stub', 'ast\\AST_THROW' => 'ast/ast.stub', 'ast\\AST_TRAIT_ADAPTATIONS' => 'ast/ast.stub', 'ast\\AST_TRAIT_ALIAS' => 'ast/ast.stub', 'ast\\AST_TRAIT_PRECEDENCE' => 'ast/ast.stub', 'ast\\AST_TRY' => 'ast/ast.stub', 'ast\\AST_TYPE' => 'ast/ast.stub', 'ast\\AST_TYPE_UNION' => 'ast/ast.stub', 'ast\\AST_UNARY_OP' => 'ast/ast.stub', 'ast\\AST_UNPACK' => 'ast/ast.stub', 'ast\\AST_UNSET' => 'ast/ast.stub', 'ast\\AST_USE' => 'ast/ast.stub', 'ast\\AST_USE_ELEM' => 'ast/ast.stub', 'ast\\AST_USE_TRAIT' => 'ast/ast.stub', 'ast\\AST_VAR' => 'ast/ast.stub', 'ast\\AST_WHILE' => 'ast/ast.stub', 'ast\\AST_YIELD' => 'ast/ast.stub', 'ast\\AST_YIELD_FROM' => 'ast/ast.stub', 'ast\\flags\\ARRAY_ELEM_REF' => 'ast/ast.stub', 'ast\\flags\\ARRAY_SYNTAX_LIST' => 'ast/ast.stub', 'ast\\flags\\ARRAY_SYNTAX_LONG' => 'ast/ast.stub', 'ast\\flags\\ARRAY_SYNTAX_SHORT' => 'ast/ast.stub', 'ast\\flags\\BINARY_ADD' => 'ast/ast.stub', 'ast\\flags\\BINARY_BITWISE_AND' => 'ast/ast.stub', 'ast\\flags\\BINARY_BITWISE_OR' => 'ast/ast.stub', 'ast\\flags\\BINARY_BITWISE_XOR' => 'ast/ast.stub', 'ast\\flags\\BINARY_BOOL_AND' => 'ast/ast.stub', 'ast\\flags\\BINARY_BOOL_OR' => 'ast/ast.stub', 'ast\\flags\\BINARY_BOOL_XOR' => 'ast/ast.stub', 'ast\\flags\\BINARY_COALESCE' => 'ast/ast.stub', 'ast\\flags\\BINARY_CONCAT' => 'ast/ast.stub', 'ast\\flags\\BINARY_DIV' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_EQUAL' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_GREATER' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_GREATER_OR_EQUAL' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_IDENTICAL' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_NOT_EQUAL' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_NOT_IDENTICAL' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_SMALLER' => 'ast/ast.stub', 'ast\\flags\\BINARY_IS_SMALLER_OR_EQUAL' => 'ast/ast.stub', 'ast\\flags\\BINARY_MOD' => 'ast/ast.stub', 'ast\\flags\\BINARY_MUL' => 'ast/ast.stub', 'ast\\flags\\BINARY_POW' => 'ast/ast.stub', 'ast\\flags\\BINARY_SHIFT_LEFT' => 'ast/ast.stub', 'ast\\flags\\BINARY_SHIFT_RIGHT' => 'ast/ast.stub', 'ast\\flags\\BINARY_SPACESHIP' => 'ast/ast.stub', 'ast\\flags\\BINARY_SUB' => 'ast/ast.stub', 'ast\\flags\\CLASS_ABSTRACT' => 'ast/ast.stub', 'ast\\flags\\CLASS_ANONYMOUS' => 'ast/ast.stub', 'ast\\flags\\CLASS_FINAL' => 'ast/ast.stub', 'ast\\flags\\CLASS_INTERFACE' => 'ast/ast.stub', 'ast\\flags\\CLASS_TRAIT' => 'ast/ast.stub', 'ast\\flags\\CLOSURE_USE_REF' => 'ast/ast.stub', 'ast\\flags\\DIM_ALTERNATIVE_SYNTAX' => 'ast/ast.stub', 'ast\\flags\\EXEC_EVAL' => 'ast/ast.stub', 'ast\\flags\\EXEC_INCLUDE' => 'ast/ast.stub', 'ast\\flags\\EXEC_INCLUDE_ONCE' => 'ast/ast.stub', 'ast\\flags\\EXEC_REQUIRE' => 'ast/ast.stub', 'ast\\flags\\EXEC_REQUIRE_ONCE' => 'ast/ast.stub', 'ast\\flags\\FUNC_GENERATOR' => 'ast/ast.stub', 'ast\\flags\\FUNC_RETURNS_REF' => 'ast/ast.stub', 'ast\\flags\\MAGIC_CLASS' => 'ast/ast.stub', 'ast\\flags\\MAGIC_DIR' => 'ast/ast.stub', 'ast\\flags\\MAGIC_FILE' => 'ast/ast.stub', 'ast\\flags\\MAGIC_FUNCTION' => 'ast/ast.stub', 'ast\\flags\\MAGIC_LINE' => 'ast/ast.stub', 'ast\\flags\\MAGIC_METHOD' => 'ast/ast.stub', 'ast\\flags\\MAGIC_NAMESPACE' => 'ast/ast.stub', 'ast\\flags\\MAGIC_TRAIT' => 'ast/ast.stub', 'ast\\flags\\MODIFIER_ABSTRACT' => 'ast/ast.stub', 'ast\\flags\\MODIFIER_FINAL' => 'ast/ast.stub', 'ast\\flags\\MODIFIER_PRIVATE' => 'ast/ast.stub', 'ast\\flags\\MODIFIER_PROTECTED' => 'ast/ast.stub', 'ast\\flags\\MODIFIER_PUBLIC' => 'ast/ast.stub', 'ast\\flags\\MODIFIER_STATIC' => 'ast/ast.stub', 'ast\\flags\\NAME_FQ' => 'ast/ast.stub', 'ast\\flags\\NAME_NOT_FQ' => 'ast/ast.stub', 'ast\\flags\\NAME_RELATIVE' => 'ast/ast.stub', 'ast\\flags\\PARAM_MODIFIER_PRIVATE' => 'ast/ast.stub', 'ast\\flags\\PARAM_MODIFIER_PROTECTED' => 'ast/ast.stub', 'ast\\flags\\PARAM_MODIFIER_PUBLIC' => 'ast/ast.stub', 'ast\\flags\\PARAM_REF' => 'ast/ast.stub', 'ast\\flags\\PARAM_VARIADIC' => 'ast/ast.stub', 'ast\\flags\\PARENTHESIZED_CONDITIONAL' => 'ast/ast.stub', 'ast\\flags\\RETURNS_REF' => 'ast/ast.stub', 'ast\\flags\\TYPE_ARRAY' => 'ast/ast.stub', 'ast\\flags\\TYPE_BOOL' => 'ast/ast.stub', 'ast\\flags\\TYPE_CALLABLE' => 'ast/ast.stub', 'ast\\flags\\TYPE_DOUBLE' => 'ast/ast.stub', 'ast\\flags\\TYPE_FALSE' => 'ast/ast.stub', 'ast\\flags\\TYPE_ITERABLE' => 'ast/ast.stub', 'ast\\flags\\TYPE_LONG' => 'ast/ast.stub', 'ast\\flags\\TYPE_MIXED' => 'ast/ast.stub', 'ast\\flags\\TYPE_NULL' => 'ast/ast.stub', 'ast\\flags\\TYPE_OBJECT' => 'ast/ast.stub', 'ast\\flags\\TYPE_STATIC' => 'ast/ast.stub', 'ast\\flags\\TYPE_STRING' => 'ast/ast.stub', 'ast\\flags\\TYPE_VOID' => 'ast/ast.stub', 'ast\\flags\\UNARY_BITWISE_NOT' => 'ast/ast.stub', 'ast\\flags\\UNARY_BOOL_NOT' => 'ast/ast.stub', 'ast\\flags\\UNARY_MINUS' => 'ast/ast.stub', 'ast\\flags\\UNARY_PLUS' => 'ast/ast.stub', 'ast\\flags\\UNARY_SILENCE' => 'ast/ast.stub', 'ast\\flags\\USE_CONST' => 'ast/ast.stub', 'ast\\flags\\USE_FUNCTION' => 'ast/ast.stub', 'ast\\flags\\USE_NORMAL' => 'ast/ast.stub', 'bgrBLACK' => 'winbinder/winbinder.stub', 'bgrBLUE' => 'winbinder/winbinder.stub', 'bgrCYAN' => 'winbinder/winbinder.stub', 'bgrDARKBLUE' => 'winbinder/winbinder.stub', 'bgrDARKCYAN' => 'winbinder/winbinder.stub', 'bgrDARKGRAY' => 'winbinder/winbinder.stub', 'bgrDARKGREEN' => 'winbinder/winbinder.stub', 'bgrDARKMAGENTA' => 'winbinder/winbinder.stub', 'bgrDARKRED' => 'winbinder/winbinder.stub', 'bgrDARKYELLOW' => 'winbinder/winbinder.stub', 'bgrGREEN' => 'winbinder/winbinder.stub', 'bgrLIGHTGRAY' => 'winbinder/winbinder.stub', 'bgrMAGENTA' => 'winbinder/winbinder.stub', 'bgrNOCOLOR' => 'winbinder/winbinder.stub', 'bgrRED' => 'winbinder/winbinder.stub', 'bgrWHITE' => 'winbinder/winbinder.stub', 'bgrYELLOW' => 'winbinder/winbinder.stub', 'false' => 'Core/Core_d.stub', 'http\\Client\\Curl\\AUTH_ANY' => 'http/http3.stub', 'http\\Client\\Curl\\AUTH_BASIC' => 'http/http3.stub', 'http\\Client\\Curl\\AUTH_DIGEST' => 'http/http3.stub', 'http\\Client\\Curl\\AUTH_DIGEST_IE' => 'http/http3.stub', 'http\\Client\\Curl\\AUTH_GSSNEG' => 'http/http3.stub', 'http\\Client\\Curl\\AUTH_NTLM' => 'http/http3.stub', 'http\\Client\\Curl\\AUTH_SPNEGO' => 'http/http3.stub', 'http\\Client\\Curl\\FEATURES' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\ASYNCHDNS' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\GSSAPI' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\GSSNEGOTIATE' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\HTTP2' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\IDN' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\IPV6' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\KERBEROS4' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\KERBEROS5' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\LARGEFILE' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\LIBZ' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\NTLM' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\NTLM_WB' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\PSL' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\SPNEGO' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\SSL' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\SSPI' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\TLSAUTH_SRP' => 'http/http3.stub', 'http\\Client\\Curl\\Features\\UNIX_SOCKETS' => 'http/http3.stub', 'http\\Client\\Curl\\HTTP_VERSION_1_0' => 'http/http3.stub', 'http\\Client\\Curl\\HTTP_VERSION_1_1' => 'http/http3.stub', 'http\\Client\\Curl\\HTTP_VERSION_2TLS' => 'http/http3.stub', 'http\\Client\\Curl\\HTTP_VERSION_2_0' => 'http/http3.stub', 'http\\Client\\Curl\\HTTP_VERSION_ANY' => 'http/http3.stub', 'http\\Client\\Curl\\IPRESOLVE_ANY' => 'http/http3.stub', 'http\\Client\\Curl\\IPRESOLVE_V4' => 'http/http3.stub', 'http\\Client\\Curl\\IPRESOLVE_V6' => 'http/http3.stub', 'http\\Client\\Curl\\POSTREDIR_301' => 'http/http3.stub', 'http\\Client\\Curl\\POSTREDIR_302' => 'http/http3.stub', 'http\\Client\\Curl\\POSTREDIR_303' => 'http/http3.stub', 'http\\Client\\Curl\\POSTREDIR_ALL' => 'http/http3.stub', 'http\\Client\\Curl\\PROXY_HTTP' => 'http/http3.stub', 'http\\Client\\Curl\\PROXY_HTTP_1_0' => 'http/http3.stub', 'http\\Client\\Curl\\PROXY_SOCKS4' => 'http/http3.stub', 'http\\Client\\Curl\\PROXY_SOCKS4A' => 'http/http3.stub', 'http\\Client\\Curl\\PROXY_SOCKS5' => 'http/http3.stub', 'http\\Client\\Curl\\PROXY_SOCKS5_HOSTNAME' => 'http/http3.stub', 'http\\Client\\Curl\\SSL_VERSION_ANY' => 'http/http3.stub', 'http\\Client\\Curl\\SSL_VERSION_SSLv2' => 'http/http3.stub', 'http\\Client\\Curl\\SSL_VERSION_SSLv3' => 'http/http3.stub', 'http\\Client\\Curl\\SSL_VERSION_TLSv1' => 'http/http3.stub', 'http\\Client\\Curl\\SSL_VERSION_TLSv1_0' => 'http/http3.stub', 'http\\Client\\Curl\\SSL_VERSION_TLSv1_1' => 'http/http3.stub', 'http\\Client\\Curl\\SSL_VERSION_TLSv1_2' => 'http/http3.stub', 'http\\Client\\Curl\\TLSAUTH_SRP' => 'http/http3.stub', 'http\\Client\\Curl\\VERSIONS' => 'http/http3.stub', 'http\\Client\\Curl\\Versions\\ARES' => 'http/http3.stub', 'http\\Client\\Curl\\Versions\\CURL' => 'http/http3.stub', 'http\\Client\\Curl\\Versions\\IDN' => 'http/http3.stub', 'http\\Client\\Curl\\Versions\\LIBZ' => 'http/http3.stub', 'http\\Client\\Curl\\Versions\\SSL' => 'http/http3.stub', 'null' => 'Core/Core_d.stub', 'pcov\\all' => 'pcov/pcov.stub', 'pcov\\exclusive' => 'pcov/pcov.stub', 'pcov\\inclusive' => 'pcov/pcov.stub', 'pcov\\version' => 'pcov/pcov.stub', 'true' => 'Core/Core_d.stub', 'yaf\\environ' => 'yaf/yaf_namespace.stub', 'yaf\\err\\autoload\\failed' => 'yaf/yaf_namespace.stub', 'yaf\\err\\call\\failed' => 'yaf/yaf_namespace.stub', 'yaf\\err\\dispatch\\failed' => 'yaf/yaf_namespace.stub', 'yaf\\err\\notfound\\action' => 'yaf/yaf_namespace.stub', 'yaf\\err\\notfound\\controller' => 'yaf/yaf_namespace.stub', 'yaf\\err\\notfound\\module' => 'yaf/yaf_namespace.stub', 'yaf\\err\\notfound\\view' => 'yaf/yaf_namespace.stub', 'yaf\\err\\route\\failed' => 'yaf/yaf_namespace.stub', 'yaf\\err\\startup\\failed' => 'yaf/yaf_namespace.stub', 'yaf\\err\\type\\error' => 'yaf/yaf_namespace.stub', 'yaf\\version' => 'yaf/yaf_namespace.stub', 'yaf_environ' => 'yaf/yaf.stub', 'yaf_err_autoload_failed' => 'yaf/yaf.stub', 'yaf_err_call_failed' => 'yaf/yaf.stub', 'yaf_err_dispatch_failed' => 'yaf/yaf.stub', 'yaf_err_notfound_action' => 'yaf/yaf.stub', 'yaf_err_notfound_controller' => 'yaf/yaf.stub', 'yaf_err_notfound_module' => 'yaf/yaf.stub', 'yaf_err_notfound_view' => 'yaf/yaf.stub', 'yaf_err_route_failed' => 'yaf/yaf.stub', 'yaf_err_startup_failed' => 'yaf/yaf.stub', 'yaf_err_type_error' => 'yaf/yaf.stub', 'yaf_version' => 'yaf/yaf.stub');
}
 ***NOTE***:
     *   If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row.
     *
     * @param string $name The identifying name of the cursor.
     * @param int $flags Any combination of pq\Cursor constants.
     * @param string $query The query for which to open a cursor.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\BadMethodCallException
     * @return \pq\Cursor an open cursor instance.
     */
    public function declareAsync(string $name, int $flags, string $query) {}

    /**
     * Escape binary data for use within a query with the type bytea.
     *
     * ***NOTE:***
     * The result is not wrapped in single quotes.
     *
     * @param string $binary The binary data to escape.
     * @throws \pq\Exception\BadMethodCallException
     * @return string|false string the escaped binary data.
     * 		 or FALSE if escaping fails.
     */
    public function escapeBytea(string $binary) {}

    /**
     * [Execute one or multiple SQL queries](pq/Connection/: Executing Queries) on the connection.
     *
     * ***NOTE:***
     * Only the last result will be returned, if the query string contains more than one SQL query.
     *
     * @param string $query The queries to send to the server, separated by semi-colon.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     * @return \pq\Result
     */
    public function exec(string $query) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) [execute an SQL query](pq/Connection: Executing Queries) on the connection.
     *
     * > ***NOTE***:
     *   If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row.
     *
     * @param string $query The query to send to the server.
     * @param callable $callback as function(pq\Result $res)
     *   The callback to execute when the query finishes.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function execAsync(string $query, callable $callback = null) {}

    /**
     * [Execute an SQL query](pq/Connection: Executing Queries) with properly escaped parameters substituted.
     *
     * @param string $query The query to execute.
     * @param array $params The parameter list to substitute.
     * @param array $types Corresponding list of type OIDs for the parameters.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     * @return \pq\Result
     */
    public function execParams(string $query, array $params, array $types = null) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) [execute an SQL query](pq/Connection: Executing Queries) with properly escaped parameters substituted.
     *
     * > ***NOTE***:
     *   If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row.
     *
     * @param string $query The query to execute.
     * @param array $params The parameter list to substitute.
     * @param array $types Corresponding list of type OIDs for the parameters.
     * @param callable $cb as function(\pq\Result $res) : void
     *   Result handler callback.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\BadMethodCallException
     */
    public function execParamsAsync(string $query, array $params, array $types = null, callable $cb = null) {}

    /**
     * Flush pending writes on the connection.
     * Call after sending any command or data on a nonblocking connection.
     *
     * If it returns FALSE, wait for the socket to become read or write-ready.
     * If it becomes write-ready, call pq\Connection::flush() again.
     * If it becomes read-ready, call pq\Connection::poll(), then call pq\Connection::flush() again.
     * Repeat until pq\Connection::flush() returns TRUE.
     *
     * ***NOTE:***
     * This method was added in v1.1.0, resp. v2.1.0.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\RuntimeException
     * @return bool whether everything has been flushed.
     */
    public function flush() {}

    /**
     * Fetch the result of an [asynchronous](pq/Connection/: Asynchronous Usage) query.
     *
     * If the query hasn't finished yet, the call will block until the result is available.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @return \pq\Result|null NULL if there has not been a query
     * 		 or \pq\Result when the query has finished
     */
    public function getResult() {}

    /**
     * Listen on $channel for notifications.
     * See pq\Connection::unlisten().
     *
     * @param string $channel The channel to listen on.
     * @param callable $listener as function(string $channel, string $message, int $pid)
     *   A callback automatically called whenever a notification on $channel arrives.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function listen(string $channel, callable $listener) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) start listening on $channel for notifications.
     * See pq\Connection::listen().
     *
     * @param string $channel The channel to listen on.
     * @param callable $listener as function(string $channel, string $message, int $pid)
     *   A callback automatically called whenever a notification on $channel arrives.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function listenAsync(string $channel, callable $listener) {}

    /**
     * Notify all listeners on $channel with $message.
     *
     * @param string $channel The channel to notify.
     * @param string $message The message to send.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function notify(string $channel, string $message) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) start notifying all listeners on $channel with $message.
     *
     * @param string $channel The channel to notify.
     * @param string $message The message to send.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function notifyAsync(string $channel, string $message) {}

    /**
     * Stops listening for an event type.
     *
     * @param string $event Any pq\Connection::EVENT_*.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @return bool success.
     */
    public function off(string $event) {}

    /**
     * Listen for an event.
     *
     * @param string $event Any pq\Connection::EVENT_*.
     * @param callable $callback as function(pq\Connection $c[, pq\Result $r)
     *   The callback to invoke on event.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @return int number of previously attached event listeners.
     */
    public function on(string $event, callable $callback) {}

    /**
     * Poll an [asynchronously](pq/Connection/: Asynchronous Usage) operating connection.
     * See pq\Connection::resetAsync() for an usage example.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\BadMethodCallException
     * @return int pq\Connection::POLLING_* constant
     */
    public function poll() {}

    /**
     * Prepare a named statement for later execution with pq\Statement::execute().
     *
     * @param string $name The identifying name of the prepared statement.
     * @param string $query The query to prepare.
     * @param array $types An array of type OIDs for the substitution parameters.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\Statement a prepared statement instance.
     */
    public function prepare(string $name, string $query, array $types = null) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) prepare a named statement for later execution with pq\Statement::exec().
     *
     * > ***NOTE***:
     *   If pq\Connection::$unbuffered is TRUE, each call to pq\Connection::getResult() will generate a distinct pq\Result containing exactly one row.
     *
     * @param string $name The identifying name of the prepared statement.
     * @param string $query The query to prepare.
     * @param array $types An array of type OIDs for the substitution parameters.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\Statement a prepared statement instance.
     */
    public function prepareAsync(string $name, string $query, array $types = null) {}

    /**
     * Quote a string for safe use in a query.
     * The result is truncated at any zero byte and wrapped in single quotes.
     *
     * ***NOTE:***
     * Beware of matching character encodings.
     *
     * @param string $payload The payload to quote for use in a query.
     * @throws \pq\Exception\BadMethodCallException
     * @return string|false string a single-quote wrapped string safe for literal use in a query.
     * 		 or FALSE if quoting fails.
     */
    public function quote(string $payload) {}

    /**
     * Quote an identifier for safe usage as name.
     *
     * ***NOTE:***
     * Beware of case-sensitivity.
     *
     * @param string $name The name to quote.
     * @throws \pq\Exception\BadMethodCallException
     * @return string|false string the quoted identifier.
     * 		 or FALSE if quoting fails.
     */
    public function quoteName(string $name) {}

    /**
     * Attempt to reset a possibly broken connection to a working state.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function reset() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) reset a possibly broken connection to a working state.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function resetAsync() {}

    /**
     * Set a data type converter.
     *
     * @param \pq\Converter $converter An instance implementing pq\Converter.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     */
    public function setConverter(Converter $converter) {}

    /**
     * Begin a transaction.
     *
     * @param int $isolation Any pq\Transaction isolation level constant
     *   (defaults to pq\Connection::$defaultTransactionIsolation).
     * @param bool $readonly Whether the transaction executes only reads
     *   (defaults to pq\Connection::$defaultTransactionReadonly).
     * @param bool $deferrable Whether the transaction is deferrable
     *   (defaults to pq\Connection::$defaultTransactionDeferrable).
     *
     * ***NOTE:***
     * A transaction can only be deferrable if it also is readonly and serializable.
     * See the official [PostgreSQL documentation](http://www.postgresql.org/docs/current/static/sql-set-transaction.html) for further information.
     *
     * @return \pq\Transaction a begun transaction instance.
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\InvalidArgumentException
     */
    public function startTransaction(int $isolation = \pq\Transaction::READ_COMMITTED, bool $readonly = false, bool $deferrable = false) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) begin a transaction.
     *
     * @param int $isolation Any pq\Transaction isolation level constant
     *   (defaults to pq\Connection::$defaultTransactionIsolation).
     * @param bool $readonly Whether the transaction executes only reads
     *   (defaults to pq\Connection::$defaultTransactionReadonly).
     * @param bool $deferrable Whether the transaction is deferrable
     *   (defaults to pq\Connection::$defaultTransactionDeferrable).
     *
     * ***NOTE:***
     * A transaction can only be deferrable if it also is readonly and serializable.
     * See the official [PostgreSQL documentation](http://www.postgresql.org/docs/current/static/sql-set-transaction.html) for further information.
     *
     * @return \pq\Transaction an asynchronously begun transaction instance.
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\InvalidArgumentException
     */
    public function startTransactionAsync(int $isolation = \pq\Transaction::READ_COMMITTED, bool $readonly = false, bool $deferrable = false) {}

    /**
     * Trace protocol communication with the server.
     *
     * ***NOTE:***
     * Calling pq\Connection::trace() without argument or NULL stops tracing.
     *
     * @param resource $stream The resource to which the protocol trace will be output.
     *   (The stream must be castable to STDIO).
     * @throws \pq\Exception\BadMethodCallException
     * @return bool success.
     */
    public function trace($stream = null) {}

    /**
     * Unescape bytea data retrieved from the server.
     *
     * @param string $bytea Bytea data retrieved from the server.
     * @throws \pq\Exception\BadMethodCallException
     * @return string|false string unescaped binary data.
     * 		 or FALSE if unescaping fails.
     */
    public function unescapeBytea(string $bytea) {}

    /**
     * Stop listening for notifications on channel $channel.
     * See pq\Connection::listen().
     *
     * @param string $channel The name of a channel which is currently listened on.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function unlisten(string $channel) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) stop listening for notifications on channel $channel.
     * See pq\Connection::unlisten() and pq\Connection::listenAsync().
     *
     * @param string $channel The name of a channel which is currently listened on.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function unlistenAsync(string $channel) {}

    /**
     * Stop applying a data type converter.
     *
     * @param \pq\Converter $converter A converter previously set with pq\Connection::setConverter().
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     */
    public function unsetConverter(Converter $converter) {}
}
/**
 * Interface for type conversions.
 */
interface Converter
{
    /**
     * Convert a string received from the PostgreSQL server back to a PHP type.
     *
     * @param string $data String data received from the server.
     * @param int $type The type OID of the data. Irrelevant for single-type converters.
     * @return mixed the value converted to a PHP type.
     */
    public function convertFromString(string $data, int $type);

    /**
     * Convert a value to a string for use in a query.
     *
     * @param mixed $value The PHP value which should be converted to a string.
     * @param int $type The type OID the converter should handle. Irrelevant for singly-type converters.
     * @return string a textual representation of the value accepted by the PostgreSQL server.
     */
    public function convertToString($value, int $type);

    /**
     * Announce which types the implementing converter can handle.
     *
     * @return array OIDs of handled types.
     */
    public function convertTypes();
}
/**
 * Declare a cursor.
 */
class Cursor
{
    /**
     * Causes the cursor to return data in binary rather than in text format. You probably do not want to use that.
     */
    public const BINARY = 1;

    /**
     * The data returned by the cursor should be unaffected by updates to the tables underlying the cursor that take place after the cursor was opened.
     */
    public const INSENSITIVE = 2;

    /**
     * The cursor should stay usable after the transaction that created it was successfully committed.
     */
    public const WITH_HOLD = 4;

    /**
     * Force that rows can be retrieved in any order from the cursor.
     */
    public const SCROLL = 16;

    /**
     * Force that rows are only retrievable in sequiential order.
     *
     * ***NOTE:***
     * See the [notes in the official PostgreSQL documentation](http://www.postgresql.org/docs/current/static/sql-declare.html#SQL-DECLARE-NOTES) for more information.
     */
    public const NO_SCROLL = 32;

    /**
     * The connection the cursor was declared on.
     *
     * @public
     * @readonly
     * @var \pq\Connection
     */
    public $connection;

    /**
     * The identifying name of the cursor.
     *
     * @public
     * @readonly
     * @var string
     */
    public $name;

    /**
     * Declare a cursor.
     * See pq\Connection::declare().
     *
     * @param \pq\Connection $connection The connection on which the cursor should be declared.
     * @param string $name The name of the cursor.
     * @param int $flags See pq\Cursor constants.
     * @param string $query The query for which the cursor should be opened.
     * @param bool $async Whether to declare the cursor [asynchronously](pq/Connection/: Asynchronous Usage).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function __construct(Connection $connection, string $name, int $flags, string $query, bool $async) {}

    /**
     * Close an open cursor.
     * This is a no-op on already closed cursors.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function close() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) close an open cursor.
     * See pq\Cursor::close().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function closeAsync() {}

    /**
     * Fetch rows from the cursor.
     * See pq\Cursor::move().
     *
     * @param string $spec What to fetch.
     *
     * ### Fetch argument:
     *
     * FETCH and MOVE usually accepts arguments like the following, where `count` is the number of rows:
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\Result the fetched row(s).
     */
    public function fetch(string $spec = "1") {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) fetch rows from the cursor.
     * See pq\Cursor::fetch().
     *
     * @param string $spec What to fetch.
     * @param callable $callback as function(pq\Result $res)
     *   A callback to execute when the result is ready.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function fetchAsync(string $spec = "1", callable $callback = null) {}

    /**
     * Move the cursor.
     * See pq\Cursor::fetch().
     *
     * @param string $spec What to fetch.
     *
     * ### Fetch argument:
     *
     * FETCH and MOVE usually accepts arguments like the following, where `count` is the number of rows:
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\Result command status.
     */
    public function move(string $spec = "1") {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) move the cursor.
     * See pq\Cursor::move().
     *
     * @param string $spec What to fetch.
     * @param callable $callback as function(pq\Result $res)
     *   A callback to execute when the command completed.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function moveAsync(string $spec = "1", callable $callback = null) {}

    /**
     * Reopen a cursor.
     * This is a no-op on already open cursors.
     *
     * ***NOTE:***
     * Only cursors closed by pq\Cursor::close() will be reopened.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function open() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) reopen a cursor.
     * See pq\Cursor::open().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function openAsync() {}
}
/**
 * A simple DateTime wrapper with predefined formats which supports stringification and JSON.
 */
class DateTime extends \DateTime implements \JsonSerializable
{
    /**
     * The default format of any date/time type automatically converted by pq\Result (depends on the actual type of the column).
     *
     * @public
     * @var string
     */
    public $format = "Y-m-d H:i:s.uO";

    /**
     * Stringify the DateTime instance according to pq\DateTime::$format.
     *
     * @return string the DateTime as string.
     */
    public function __toString() {}

    /**
     * Serialize to JSON.
     * Alias of pq\DateTime::__toString().
     *
     * @return string the DateTime stringified according to pq\DateTime::$format.
     */
    public function jsonSerialize() {}
}
/**
 * A base interface for all pq\Exception classes.
 */
interface Exception
{
    /**
     * An invalid argument was passed to a method (pq\Exception\InvalidArgumentException).
     */
    public const INVALID_ARGUMENT = 0;

    /**
     * A runtime exception occurred (pq\Exception\RuntimeException).
     */
    public const RUNTIME = 1;

    /**
     * The connection failed (pq\Exception\RuntimeException).
     */
    public const CONNECTION_FAILED = 2;

    /**
     * An input/output exception occurred (pq\Exception\RuntimeException).
     */
    public const IO = 3;

    /**
     * Escaping an argument or identifier failed internally (pq\Exception\RuntimeException).
     */
    public const ESCAPE = 4;

    /**
     * An object's constructor was not called (pq\Exception\BadMethodCallException).
     */
    public const UNINITIALIZED = 6;

    /**
     * Calling this method was not expected (yet) (pq\Exception\BadMethodCallException).
     */
    public const BAD_METHODCALL = 5;

    /**
     * SQL syntax error (pq\Exception\DomainException).
     */
    public const SQL = 8;

    /**
     * Implementation domain error (pq\Exception\DomainException).
     */
    public const DOMAIN = 7;
}
/**
 * A *large object*.
 *
 * ***NOTE:***
 * Working with *large objects* requires an active transaction.
 */
class LOB
{
    /**
     * 0, representing an invalid OID.
     */
    public const INVALID_OID = 0;

    /**
     * Read/write mode.
     */
    public const RW = 393216;

    /**
     * The transaction wrapping the operations on the *large object*.
     *
     * @public
     * @readonly
     * @var \pq\Transaction
     */
    public $transaction;

    /**
     * The OID of the *large object*.
     *
     * @public
     * @readonly
     * @var int
     */
    public $oid;

    /**
     * The stream connected to the *large object*.
     *
     * @public
     * @readonly
     * @var resource
     */
    public $stream;

    /**
     * Open or create a *large object*.
     * See pq\Transaction::openLOB() and pq\Transaction::createLOB().
     *
     * @param \pq\Transaction $txn The transaction which wraps the *large object* operations.
     * @param int $oid The OID of the existing *large object* to open.
     * @param int $mode Access mode (read, write or read/write).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function __construct(Transaction $txn, int $oid = \pq\LOB::INVALID_OID, int $mode = \pq\LOB::RW) {}

    /**
     * Read a string of data from the current position of the *large object*.
     *
     * @param int $length The amount of bytes to read from the *large object*.
     * @param int &$read The amount of bytes actually read from the *large object*.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return string the data read.
     */
    public function read(int $length = 0x1000, int &$read = null) {}

    /**
     * Seek to a position within the *large object*.
     *
     * @param int $offset The position to seek to.
     * @param int $whence From where to seek (SEEK_SET, SEEK_CUR or SEEK_END).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return int the new position.
     */
    public function seek(int $offset, int $whence = SEEK_SET) {}

    /**
     * Retrieve the current position within the *large object*.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return int the current position.
     */
    public function tell() {}

    /**
     * Truncate the *large object*.
     *
     * @param int $length The length to truncate to.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function truncate(int $length = 0) {}

    /**
     * Write data to the *large object*.
     *
     * @param string $data The data that should be written to the current position.
     * @return int the number of bytes written.
     */
    public function write(string $data) {}
}
/**
 * A query result.
 *
 * See [Fetching Results](pq/Result/: Fetching Results) for a general overview.
 */
class Result implements \Traversable, \Countable
{
    /**
     * The query sent to the server was empty.
     */
    public const EMPTY_QUERY = 0;

    /**
     * The query did not generate a result set and completed successfully.
     */
    public const COMMAND_OK = 1;

    /**
     * The query successfully generated a result set.
     */
    public const TUPLES_OK = 2;

    /**
     * The result contains a single row of the result set when using pq\Connection::$unbuffered.
     */
    public const SINGLE_TUPLE = 9;

    /**
     * COPY data can be received from the server.
     */
    public const COPY_OUT = 3;

    /**
     * COPY data can be sent to the server.
     */
    public const COPY_IN = 4;

    /**
     * COPY in/out data transfer in progress.
     */
    public const COPY_BOTH = 8;

    /**
     * The server sent a bad response.
     */
    public const BAD_RESPONSE = 5;

    /**
     * A nonfatal error (notice or warning) occurred.
     */
    public const NONFATAL_ERROR = 6;

    /**
     * A fatal error occurred.
     */
    public const FATAL_ERROR = 7;

    /**
     * Fetch rows numerically indexed, where the index start with 0.
     */
    public const FETCH_ARRAY = 0;

    /**
     * Fetch rows associatively indexed by column name.
     */
    public const FETCH_ASSOC = 1;

    /**
     * Fetch rows as stdClass instance, where the column names are the property names.
     */
    public const FETCH_OBJECT = 2;

    /**
     * Automatically convert 'f' and 't' to FALSE and TRUE and vice versa.
     */
    public const CONV_BOOL = 1;

    /**
     * Automatically convert integral strings to either int if it fits into maximum integer size or else to float and vice versa.
     */
    public const CONV_INT = 2;

    /**
     * Automatically convert floating point numbers.
     */
    public const CONV_FLOAT = 4;

    /**
     * Do all scalar conversions listed above.
     */
    public const CONV_SCALAR = 15;

    /**
     * Automatically convert arrays.
     */
    public const CONV_ARRAY = 16;

    /**
     * Automatically convert date strings to pq\DateTime and vice versa.
     */
    public const CONV_DATETIME = 32;

    /**
     * Automatically convert JSON.
     */
    public const CONV_JSON = 256;

    /**
     * Do all of the above.
     */
    public const CONV_ALL = 65535;

    /**
     * A [status constant](pq/Result#Status.values:).
     *
     * @public
     * @readonly
     * @var int
     */
    public $status;

    /**
     * The accompanying status message.
     *
     * @public
     * @readonly
     * @var string
     */
    public $statusMessage;

    /**
     * Any error message if $status indicates an error.
     *
     * @public
     * @readonly
     * @var string
     */
    public $errorMessage;

    /**
     * The number of rows in the result set.
     *
     * @public
     * @readonly
     * @var int
     */
    public $numRows;

    /**
     * The number of fields in a single tuple of the result set.
     *
     * @public
     * @readonly
     * @var int
     */
    public $numCols;

    /**
     * The number of rows affected by a statement.
     *
     * @public
     * @readonly
     * @var int
     */
    public $affectedRows;

    /**
     * Error details. See [PQresultErrorField](https://www.postgresql.org/docs/current/static/libpq-exec.html#LIBPQ-PQRESULTERRORFIELD) docs.
     *
     * @public
     * @readonly
     * @var array
     */
    public $diag;

    /**
     * The [type of return value](pq/Result#Fetch.types:) the fetch methods should return when no fetch type argument was given. Defaults to pq\Connection::$defaultFetchType.
     *
     * @public
     * @var int
     */
    public $fetchType = \pq\Result::FETCH_ARRAY;

    /**
     * What [type of conversions](pq/Result#Conversion.bits:) to perform automatically.
     *
     * @public
     * @var int
     */
    public $autoConvert = \pq\Result::CONV_ALL;

    /**
     * Bind a variable to a result column.
     * See pq\Result::fetchBound().
     *
     * @param mixed $col The column name or index to bind to.
     * @param mixed $var The variable reference.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @return bool success.
     */
    public function bind($col, $var) {}

    /**
     * Count number of rows in this result set.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @return int the number of rows.
     */
    public function count() {}

    /**
     * Describe a prepared statement.
     *
     * ***NOTE:***
     * This will only return meaningful information for a result of pq\Statement::desc().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @return array list of parameter type OIDs for the prepared statement.
     */
    public function desc() {}

    /**
     * Fetch all rows at once.
     *
     * @param int $fetch_type The type the return value should have, see pq\Result::FETCH_* constants, defaults to pq\Result::$fetchType.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @return array all fetched rows.
     */
    public function fetchAll(int $fetch_type = null) {}

    /**
     * Fetch all rows of a single column.
     *
     * @param int $col The column name or index to fetch.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return array list of column values.
     */
    public function fetchAllCols(int $col = 0) {}

    /**
     * Iteratively fetch a row into bound variables.
     * See pq\Result::bind().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return array|null array the fetched row as numerically indexed array.
     * 		 or NULL when iteration ends.
     */
    public function fetchBound() {}

    /**
     * Iteratively fetch a single column.
     *
     * @param mixed $ref The variable where the column value will be stored in.
     * @param mixed $col The column name or index.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return bool|null bool success.
     * 		 or NULL when iteration ends.
     */
    public function fetchCol($ref, $col = 0) {}

    /**
     * Iteratively fetch a row.
     *
     * @param int $fetch_type The type the return value should have, see pq\Result::FETCH_* constants, defaults to pq\Result::$fetchType.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return array|array|object|null array numerically indexed for pq\Result::FETCH_ARRAY
     * 		 or array associatively indexed for pq\Result::FETCH_ASSOC
     * 		 or object stdClass instance for pq\Result::FETCH_OBJECT
     * 		 or NULL when iteration ends.
     */
    public function fetchRow(int $fetch_type = null) {}

    /**
     * Fetch the complete result set as a simple map, a *multi dimensional array*, each dimension indexed by a column.
     *
     * @param mixed $keys The the column indices/names used to index the map.
     * @param mixed $vals The column indices/names which should build up the leaf entry of the map.
     * @param int $fetch_type The type the return value should have, see pq\Result::FETCH_* constants, defaults to pq\Result::$fetchType.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return array|object the mapped columns.
     */
    public function map($keys = 0, $vals = null, int $fetch_type = null) {}
}
/**
 * A named prepared statement.
 * See pq\Connection::prepare().
 */
class Statement
{
    /**
     * The connection to the server.
     *
     * @public
     * @readonly
     * @var \pq\Connection
     */
    public $connection;

    /**
     * The identifiying name of the prepared statement.
     *
     * @public
     * @readonly
     * @var string
     */
    public $name;

    /**
     * The query string used to prepare the statement.
     *
     * @public
     * @readonly
     * @var string
     */
    public $query;

    /**
     * List of corresponding query parameter type OIDs for the prepared statement.
     *
     * @public
     * @readonly
     * @var array
     */
    public $types;

    /**
     * Prepare a new statement.
     * See pq\Connection::prepare().
     *
     * @param \pq\Connection $conn The connection to prepare the statement on.
     * @param string $name The name identifying this statement.
     * @param string $query The actual query to prepare.
     * @param array $types A list of corresponding query parameter type OIDs.
     * @param bool $async Whether to prepare the statement [asynchronously](pq/Connection/: Asynchronous Usage).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     */
    public function __construct(Connection $conn, string $name, string $query, array $types = null, bool $async = false) {}

    /**
     * Bind a variable to an input parameter.
     *
     * @param int $param_no The parameter index to bind to.
     * @param mixed &$param_ref The variable to bind.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     */
    public function bind(int $param_no, &$param_ref) {}

    /**
     * Free the server resources used by the prepared statement, so it can no longer be executed.
     * This is done implicitly when the object is destroyed.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function deallocate() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) free the server resources used by the
     * prepared statement, so it can no longer be executed.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function deallocateAsync() {}

    /**
     * Describe the parameters of the prepared statement.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     * @return array list of type OIDs of the substitution parameters.
     */
    public function desc() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) describe the parameters of the prepared statement.
     *
     * @param callable $callback as function(array $oids)
     *   A callback to receive list of type OIDs of the substitution parameters.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function descAsync(callable $callback) {}

    /**
     * Execute the prepared statement.
     *
     * @param array $params Any parameters to substitute in the prepared statement (defaults to any bou
     *   nd variables).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\Result the result of the execution of the prepared statement.
     */
    public function exec(array $params = null) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) execute the prepared statement.
     *
     * @param array $params Any parameters to substitute in the prepared statement (defaults to any bou
     *   nd variables).
     * @param callable $cb as function(\pq\Result $res) : void
     *   Result handler callback.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function execAsync(array $params = null, callable $cb = null) {}

    /**
     * Re-prepare a statement that has been deallocated. This is a no-op on already open statements.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function prepare() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) re-prepare a statement that has been
     * deallocated. This is a no-op on already open statements.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function prepareAsync() {}
}
/**
 * A database transaction.
 *
 * ***NOTE:***
 * Transactional properties like pq\Transaction::$isolation, pq\Transaction::$readonly and pq\Transaction::$deferrable can be changed after the transaction begun and the first query has been executed. Doing this will lead to appropriate `SET TRANSACTION` queries.
 */
class Transaction
{
    /**
     * Transaction isolation level where only rows committed before the transaction began can be seen.
     */
    public const READ_COMMITTED = 0;

    /**
     * Transaction isolation level where only rows committed before the first query was executed in this transaction.
     */
    public const REPEATABLE_READ = 1;

    /**
     * Transaction isolation level that guarantees serializable repeatability which might lead to serialization_failure on high concurrency.
     */
    public const SERIALIZABLE = 2;

    /**
     * The connection the transaction was started on.
     *
     * @public
     * @readonly
     * @var \pq\Connection
     */
    public $connection;

    /**
     * The transaction isolation level.
     *
     * @public
     * @var int
     */
    public $isolation = \pq\Transaction::READ_COMMITTED;

    /**
     * Whether this transaction performs read only queries.
     *
     * @public
     * @var bool
     */
    public $readonly = false;

    /**
     * Whether the transaction is deferrable. See pq\Connection::startTransaction().
     *
     * @public
     * @var bool
     */
    public $deferrable = false;

    /**
     * Start a transaction.
     * See pq\Connection::startTransaction().
     *
     * @param \pq\Connection $conn The connection to start the transaction on.
     * @param bool $async Whether to start the transaction [asynchronously](pq/Connection/: Asynchronous Usage).
     * @param int $isolation The transaction isolation level (defaults to pq\Connection::$defaultTransactionIsolation).
     * @param bool $readonly Whether the transaction is readonly (defaults to pq\Connection::$defaultTransactionReadonly).
     * @param bool $deferrable Whether the transaction is deferrable (defaults to pq\Connection::$defaultTransactionDeferrable).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function __construct(Connection $conn, bool $async = false, int $isolation = \pq\Transaction::READ_COMMITTED, bool $readonly = false, bool $deferrable = false) {}

    /**
     * Commit the transaction or release the previous savepoint.
     * See pq\Transaction::savepoint().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     */
    public function commit() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) commit the transaction or release the previous savepoint.
     * See pq\Transaction::commit() and pq\Transaction::savepoint().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function commitAsync() {}

    /**
     * Create a new *large object* and open it.
     * See pq\Transaction::openLOB().
     *
     * @param int $mode How to open the *large object* (read, write or both; see pq\LOB constants).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\LOB instance of the new *large object*.
     */
    public function createLOB(int $mode = \pq\LOB::RW) {}

    /**
     * Export a *large object* to a local file.
     * See pq\Transaction::importLOB().
     *
     * @param int $oid The OID of the *large object*.
     * @param string $path The path of a local file to export to.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function exportLOB(int $oid, string $path) {}

    /**
     * Export a snapshot for transaction synchronization.
     * See pq\Transaction::importSnapshot().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     * @return string the snapshot identifier usable with pq\Transaction::importSnapshot().
     */
    public function exportSnapshot() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) export a snapshot for transaction synchronization.
     * See pq\Transaction::exportSnapshot().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function exportSnapshotAsync() {}

    /**
     * Import a local file into a *large object*.
     *
     * @param string $local_path A path to a local file to import.
     * @param int $oid The target OID. A new *large object* will be created if INVALID_OID.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return int the (new) OID of the *large object*.
     */
    public function importLOB(string $local_path, int $oid = \pq\LOB::INVALID_OID) {}

    /**
     * Import a snapshot from another transaction to synchronize with.
     * See pq\Transaction::exportSnapshot().
     *
     * ***NOTE:***
     * The transaction must have an isolation level of at least pq\Transaction::REPEATABLE_READ.
     *
     * @param string $snapshot_id The snapshot identifier obtained by exporting a snapshot from a transaction.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     */
    public function importSnapshot(string $snapshot_id) {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) import a snapshot from another transaction to synchronize with.
     * See pq\Transaction::importSnapshot().
     *
     * ***NOTE:***
     * The transaction must have an isolation level of at least pq\Transaction::REPEATABLE_READ.
     *
     * @param string $snapshot_id The snapshot identifier obtained by exporting a snapshot from a transaction.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function importSnapshotAsync(string $snapshot_id) {}

    /**
     * Open a *large object*.
     * See pq\Transaction::createLOB().
     *
     * @param int $oid The OID of the *large object*.
     * @param int $mode Operational mode; read, write or both.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\LOB instance of the opened *large object*.
     */
    public function openLOB(int $oid, int $mode = \pq\LOB::RW) {}

    /**
     * Rollback the transaction or to the previous savepoint within this transaction.
     * See pq\Transaction::commit() and pq\Transaction::savepoint().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @throws \pq\Exception\DomainException
     */
    public function rollback() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) rollback the transaction or to the previous savepoint within this transaction.
     * See pq\Transaction::rollback() and pq\Transaction::savepoint().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function rollbackAsync() {}

    /**
     * Create a `SAVEPOINT` within this transaction.
     *
     * ***NOTE:***
     * pq\Transaction tracks an internal counter as savepoint identifier.
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function savepoint() {}

    /**
     * [Asynchronously](pq/Connection/: Asynchronous Usage) create a `SAVEPOINT` within this transaction.
     * See pq\Transaction::savepoint().
     *
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function savepointAsync() {}

    /**
     * Unlink a *large object*.
     * See pq\Transaction::createLOB().
     *
     * @param int $oid The OID of the *large object*.
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     * @return \pq\LOB instance of the opened *large object*.
     */
    public function unlinkLOB(int $oid) {}
}
/**
 * Accessor to the PostgreSQL `pg_type` relation.
 * See [here for an overview](pq/Types/: Overview).
 */
class Types implements \ArrayAccess
{
    /**
     * OID of the `bool` type.
     */
    public const BOOL = 16;

    /**
     * OID of the `bytea` type.
     */
    public const BYTEA = 17;

    /**
     * OID of the `char` type.
     */
    public const CHAR = 18;

    /**
     * OID of the `name` type.
     */
    public const NAME = 19;

    /**
     * OID of the `int8` type.
     */
    public const INT8 = 20;

    /**
     * OID of the `int2` type.
     */
    public const INT2 = 21;

    /**
     * OID of the `int2vector` type.
     */
    public const INT2VECTOR = 22;

    /**
     * OID of the `int4` type.
     */
    public const INT4 = 23;

    /**
     * OID of the `regproc` type.
     */
    public const REGPROC = 24;

    /**
     * OID of the `text` type.
     */
    public const TEXT = 25;

    /**
     * OID of the `oid` type.
     */
    public const OID = 26;

    /**
     * OID of the `tid` type.
     */
    public const TID = 27;

    /**
     * OID of the `xid` type.
     */
    public const XID = 28;

    /**
     * OID of the `cid` type.
     */
    public const CID = 29;

    /**
     * OID of the `oidvector` type.
     */
    public const OIDVECTOR = 30;

    /**
     * OID of the `pg_type` type.
     */
    public const PG_TYPE = 71;

    /**
     * OID of the `pg_attribute` type.
     */
    public const PG_ATTRIBUTE = 75;

    /**
     * OID of the `pg_proc` type.
     */
    public const PG_PROC = 81;

    /**
     * OID of the `pg_class` type.
     */
    public const PG_CLASS = 83;

    /**
     * OID of the `json` type.
     */
    public const JSON = 114;

    /**
     * OID of the `xml` type.
     */
    public const XML = 142;

    /**
     * OID of the `xmlarray` type.
     */
    public const XMLARRAY = 143;

    /**
     * OID of the `jsonarray` type.
     */
    public const JSONARRAY = 199;

    /**
     * OID of the `pg_node_tree` type.
     */
    public const PG_NODE_TREE = 194;

    /**
     * OID of the `smgr` type.
     */
    public const SMGR = 210;

    /**
     * OID of the `point` type.
     */
    public const POINT = 600;

    /**
     * OID of the `lseg` type.
     */
    public const LSEG = 601;

    /**
     * OID of the `path` type.
     */
    public const PATH = 602;

    /**
     * OID of the `box` type.
     */
    public const BOX = 603;

    /**
     * OID of the `polygon` type.
     */
    public const POLYGON = 604;

    /**
     * OID of the `line` type.
     */
    public const LINE = 628;

    /**
     * OID of the `linearray` type.
     */
    public const LINEARRAY = 629;

    /**
     * OID of the `float4` type.
     */
    public const FLOAT4 = 700;

    /**
     * OID of the `float8` type.
     */
    public const FLOAT8 = 701;

    /**
     * OID of the `abstime` type.
     */
    public const ABSTIME = 702;

    /**
     * OID of the `reltime` type.
     */
    public const RELTIME = 703;

    /**
     * OID of the `tinterval` type.
     */
    public const TINTERVAL = 704;

    /**
     * OID of the `unknown` type.
     */
    public const UNKNOWN = 705;

    /**
     * OID of the `circle` type.
     */
    public const CIRCLE = 718;

    /**
     * OID of the `circlearray` type.
     */
    public const CIRCLEARRAY = 719;

    /**
     * OID of the `money` type.
     */
    public const MONEY = 790;

    /**
     * OID of the `moneyarray` type.
     */
    public const MONEYARRAY = 791;

    /**
     * OID of the `macaddr` type.
     */
    public const MACADDR = 829;

    /**
     * OID of the `inet` type.
     */
    public const INET = 869;

    /**
     * OID of the `cidr` type.
     */
    public const CIDR = 650;

    /**
     * OID of the `boolarray` type.
     */
    public const BOOLARRAY = 1000;

    /**
     * OID of the `byteaarray` type.
     */
    public const BYTEAARRAY = 1001;

    /**
     * OID of the `chararray` type.
     */
    public const CHARARRAY = 1002;

    /**
     * OID of the `namearray` type.
     */
    public const NAMEARRAY = 1003;

    /**
     * OID of the `int2array` type.
     */
    public const INT2ARRAY = 1005;

    /**
     * OID of the `int2vectorarray` type.
     */
    public const INT2VECTORARRAY = 1006;

    /**
     * OID of the `int4array` type.
     */
    public const INT4ARRAY = 1007;

    /**
     * OID of the `regprocarray` type.
     */
    public const REGPROCARRAY = 1008;

    /**
     * OID of the `textarray` type.
     */
    public const TEXTARRAY = 1009;

    /**
     * OID of the `oidarray` type.
     */
    public const OIDARRAY = 1028;

    /**
     * OID of the `tidarray` type.
     */
    public const TIDARRAY = 1010;

    /**
     * OID of the `xidarray` type.
     */
    public const XIDARRAY = 1011;

    /**
     * OID of the `cidarray` type.
     */
    public const CIDARRAY = 1012;

    /**
     * OID of the `oidvectorarray` type.
     */
    public const OIDVECTORARRAY = 1013;

    /**
     * OID of the `bpchararray` type.
     */
    public const BPCHARARRAY = 1014;

    /**
     * OID of the `varchararray` type.
     */
    public const VARCHARARRAY = 1015;

    /**
     * OID of the `int8array` type.
     */
    public const INT8ARRAY = 1016;

    /**
     * OID of the `pointarray` type.
     */
    public const POINTARRAY = 1017;

    /**
     * OID of the `lsegarray` type.
     */
    public const LSEGARRAY = 1018;

    /**
     * OID of the `patharray` type.
     */
    public const PATHARRAY = 1019;

    /**
     * OID of the `boxarray` type.
     */
    public const BOXARRAY = 1020;

    /**
     * OID of the `float4array` type.
     */
    public const FLOAT4ARRAY = 1021;

    /**
     * OID of the `float8array` type.
     */
    public const FLOAT8ARRAY = 1022;

    /**
     * OID of the `abstimearray` type.
     */
    public const ABSTIMEARRAY = 1023;

    /**
     * OID of the `reltimearray` type.
     */
    public const RELTIMEARRAY = 1024;

    /**
     * OID of the `tintervalarray` type.
     */
    public const TINTERVALARRAY = 1025;

    /**
     * OID of the `polygonarray` type.
     */
    public const POLYGONARRAY = 1027;

    /**
     * OID of the `aclitem` type.
     */
    public const ACLITEM = 1033;

    /**
     * OID of the `aclitemarray` type.
     */
    public const ACLITEMARRAY = 1034;

    /**
     * OID of the `macaddrarray` type.
     */
    public const MACADDRARRAY = 1040;

    /**
     * OID of the `inetarray` type.
     */
    public const INETARRAY = 1041;

    /**
     * OID of the `cidrarray` type.
     */
    public const CIDRARRAY = 651;

    /**
     * OID of the `cstringarray` type.
     */
    public const CSTRINGARRAY = 1263;

    /**
     * OID of the `bpchar` type.
     */
    public const BPCHAR = 1042;

    /**
     * OID of the `varchar` type.
     */
    public const VARCHAR = 1043;

    /**
     * OID of the `date` type.
     */
    public const DATE = 1082;

    /**
     * OID of the `time` type.
     */
    public const TIME = 1083;

    /**
     * OID of the `timestamp` type.
     */
    public const TIMESTAMP = 1114;

    /**
     * OID of the `timestamparray` type.
     */
    public const TIMESTAMPARRAY = 1115;

    /**
     * OID of the `datearray` type.
     */
    public const DATEARRAY = 1182;

    /**
     * OID of the `timearray` type.
     */
    public const TIMEARRAY = 1183;

    /**
     * OID of the `timestamptz` type.
     */
    public const TIMESTAMPTZ = 1184;

    /**
     * OID of the `timestamptzarray` type.
     */
    public const TIMESTAMPTZARRAY = 1185;

    /**
     * OID of the `interval` type.
     */
    public const INTERVAL = 1186;

    /**
     * OID of the `intervalarray` type.
     */
    public const INTERVALARRAY = 1187;

    /**
     * OID of the `numericarray` type.
     */
    public const NUMERICARRAY = 1231;

    /**
     * OID of the `timetz` type.
     */
    public const TIMETZ = 1266;

    /**
     * OID of the `timetzarray` type.
     */
    public const TIMETZARRAY = 1270;

    /**
     * OID of the `bit` type.
     */
    public const BIT = 1560;

    /**
     * OID of the `bitarray` type.
     */
    public const BITARRAY = 1561;

    /**
     * OID of the `varbit` type.
     */
    public const VARBIT = 1562;

    /**
     * OID of the `varbitarray` type.
     */
    public const VARBITARRAY = 1563;

    /**
     * OID of the `numeric` type.
     */
    public const NUMERIC = 1700;

    /**
     * OID of the `refcursor` type.
     */
    public const REFCURSOR = 1790;

    /**
     * OID of the `refcursorarray` type.
     */
    public const REFCURSORARRAY = 2201;

    /**
     * OID of the `regprocedure` type.
     */
    public const REGPROCEDURE = 2202;

    /**
     * OID of the `regoper` type.
     */
    public const REGOPER = 2203;

    /**
     * OID of the `regoperator` type.
     */
    public const REGOPERATOR = 2204;

    /**
     * OID of the `regclass` type.
     */
    public const REGCLASS = 2205;

    /**
     * OID of the `regtype` type.
     */
    public const REGTYPE = 2206;

    /**
     * OID of the `regprocedurearray` type.
     */
    public const REGPROCEDUREARRAY = 2207;

    /**
     * OID of the `regoperarray` type.
     */
    public const REGOPERARRAY = 2208;

    /**
     * OID of the `regoperatorarray` type.
     */
    public const REGOPERATORARRAY = 2209;

    /**
     * OID of the `regclassarray` type.
     */
    public const REGCLASSARRAY = 2210;

    /**
     * OID of the `regtypearray` type.
     */
    public const REGTYPEARRAY = 2211;

    /**
     * OID of the `uuid` type.
     */
    public const UUID = 2950;

    /**
     * OID of the `uuidarray` type.
     */
    public const UUIDARRAY = 2951;

    /**
     * OID of the `tsvector` type.
     */
    public const TSVECTOR = 3614;

    /**
     * OID of the `gtsvector` type.
     */
    public const GTSVECTOR = 3642;

    /**
     * OID of the `tsquery` type.
     */
    public const TSQUERY = 3615;

    /**
     * OID of the `regconfig` type.
     */
    public const REGCONFIG = 3734;

    /**
     * OID of the `regdictionary` type.
     */
    public const REGDICTIONARY = 3769;

    /**
     * OID of the `tsvectorarray` type.
     */
    public const TSVECTORARRAY = 3643;

    /**
     * OID of the `gtsvectorarray` type.
     */
    public const GTSVECTORARRAY = 3644;

    /**
     * OID of the `tsqueryarray` type.
     */
    public const TSQUERYARRAY = 3645;

    /**
     * OID of the `regconfigarray` type.
     */
    public const REGCONFIGARRAY = 3735;

    /**
     * OID of the `regdictionaryarray` type.
     */
    public const REGDICTIONARYARRAY = 3770;

    /**
     * OID of the `txid_snapshot` type.
     */
    public const TXID_SNAPSHOT = 2970;

    /**
     * OID of the `txid_snapshotarray` type.
     */
    public const TXID_SNAPSHOTARRAY = 2949;

    /**
     * OID of the `int4range` type.
     */
    public const INT4RANGE = 3904;

    /**
     * OID of the `int4rangearray` type.
     */
    public const INT4RANGEARRAY = 3905;

    /**
     * OID of the `numrange` type.
     */
    public const NUMRANGE = 3906;

    /**
     * OID of the `numrangearray` type.
     */
    public const NUMRANGEARRAY = 3907;

    /**
     * OID of the `tsrange` type.
     */
    public const TSRANGE = 3908;

    /**
     * OID of the `tsrangearray` type.
     */
    public const TSRANGEARRAY = 3909;

    /**
     * OID of the `tstzrange` type.
     */
    public const TSTZRANGE = 3910;

    /**
     * OID of the `tstzrangearray` type.
     */
    public const TSTZRANGEARRAY = 3911;

    /**
     * OID of the `daterange` type.
     */
    public const DATERANGE = 3912;

    /**
     * OID of the `daterangearray` type.
     */
    public const DATERANGEARRAY = 3913;

    /**
     * OID of the `int8range` type.
     */
    public const INT8RANGE = 3926;

    /**
     * OID of the `int8rangearray` type.
     */
    public const INT8RANGEARRAY = 3927;

    /**
     * OID of the `record` type.
     */
    public const RECORD = 2249;

    /**
     * OID of the `recordarray` type.
     */
    public const RECORDARRAY = 2287;

    /**
     * OID of the `cstring` type.
     */
    public const CSTRING = 2275;

    /**
     * OID of the `any` type.
     */
    public const ANY = 2276;

    /**
     * OID of the `anyarray` type.
     */
    public const ANYARRAY = 2277;

    /**
     * OID of the `void` type.
     */
    public const VOID = 2278;

    /**
     * OID of the `trigger` type.
     */
    public const TRIGGER = 2279;

    /**
     * OID of the `event_trigger` type.
     */
    public const EVENT_TRIGGER = 3838;

    /**
     * OID of the `language_handler` type.
     */
    public const LANGUAGE_HANDLER = 2280;

    /**
     * OID of the `internal` type.
     */
    public const INTERNAL = 2281;

    /**
     * OID of the `opaque` type.
     */
    public const OPAQUE = 2282;

    /**
     * OID of the `anyelement` type.
     */
    public const ANYELEMENT = 2283;

    /**
     * OID of the `anynonarray` type.
     */
    public const ANYNONARRAY = 2776;

    /**
     * OID of the `anyenum` type.
     */
    public const ANYENUM = 3500;

    /**
     * OID of the `fdw_handler` type.
     */
    public const FDW_HANDLER = 3115;

    /**
     * OID of the `anyrange` type.
     */
    public const ANYRANGE = 3831;

    /**
     * The connection which was used to obtain type information.
     *
     * @public
     * @readonly
     * @var \pq\Connection
     */
    public $connection;

    /**
     * Create a new instance populated with information obtained from the `pg_type` relation.
     *
     * @param \pq\Connection $conn The connection to use.
     * @param array $namespaces Which namespaces to query (defaults to `public` and `pg_catalog`).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function __construct(Connection $conn, array $namespaces = null) {}

    /**
     * Refresh type information from `pg_type`.
     *
     * @param array $namespaces Which namespaces to query (defaults to `public` and `pg_catalog`).
     * @throws \pq\Exception\InvalidArgumentException
     * @throws \pq\Exception\BadMethodCallException
     * @throws \pq\Exception\RuntimeException
     */
    public function refresh(array $namespaces = null) {}
}

namespace pq\Exception;

/**
 * A method call was not expected.
 */
class BadMethodCallException extends \BadMethodCallException implements \pq\Exception {}
/**
 * Implementation or SQL syntax error.
 */
class DomainException extends \DomainException implements \pq\Exception
{
    /**
     * The SQLSTATE code, see the [official documentation](http://www.postgresql.org/docs/current/static/errcodes-appendix.html) for further information.
     *
     * @public
     * @readonly
     * @var string
     */
    public $sqlstate;
}
/**
 * An invalid argument was passed to a method.
 */
class InvalidArgumentException extends \InvalidArgumentException implements \pq\Exception {}
/**
 * A runtime exception occurred.
 */
class RuntimeException extends \RuntimeException implements \pq\Exception {}

 * The tested string.
 * 

 * @return bool TRUE if every character in text is either
 * a letter or a digit, FALSE otherwise.
 */
#[Pure]
function ctype_alnum(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for alphabetic character(s)
 * @link https://php.net/manual/en/function.ctype-alpha.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text is
 * a letter from the current locale, FALSE otherwise.
 */
#[Pure]
function ctype_alpha(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for control character(s)
 * @link https://php.net/manual/en/function.ctype-cntrl.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text is
 * a control character from the current locale, FALSE otherwise.
 */
#[Pure]
function ctype_cntrl(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for numeric character(s)
 * @link https://php.net/manual/en/function.ctype-digit.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in the string
 * text is a decimal digit, FALSE otherwise.
 */
#[Pure]
function ctype_digit(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for lowercase character(s)
 * @link https://php.net/manual/en/function.ctype-lower.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text is
 * a lowercase letter in the current locale.
 */
#[Pure]
function ctype_lower(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for any printable character(s) except space
 * @link https://php.net/manual/en/function.ctype-graph.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text is
 * printable and actually creates visible output (no white space), FALSE
 * otherwise.
 */
#[Pure]
function ctype_graph(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for printable character(s)
 * @link https://php.net/manual/en/function.ctype-print.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text
 * will actually create output (including blanks). Returns FALSE if
 * text contains control characters or characters
 * that do not have any output or control function at all.
 */
#[Pure]
function ctype_print(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for any printable character which is not whitespace or an
 * alphanumeric character
 * @link https://php.net/manual/en/function.ctype-punct.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text
 * is printable, but neither letter, digit or blank, FALSE otherwise.
 */
#[Pure]
function ctype_punct(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for whitespace character(s)
 * @link https://php.net/manual/en/function.ctype-space.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text
 * creates some sort of white space, FALSE otherwise. Besides the
 * blank character this also includes tab, vertical tab, line feed,
 * carriage return and form feed characters.
 */
#[Pure]
function ctype_space(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for uppercase character(s)
 * @link https://php.net/manual/en/function.ctype-upper.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text is
 * an uppercase letter in the current locale.
 */
#[Pure]
function ctype_upper(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}

/**
 * Check for character(s) representing a hexadecimal digit
 * @link https://php.net/manual/en/function.ctype-xdigit.php
 * @param string $text 

 * The tested string.
 * 
 * @return bool TRUE if every character in text is
 * a hexadecimal 'digit', that is a decimal digit or a character from
 * [A-Fa-f] , FALSE otherwise.
 */
#[Pure]
function ctype_xdigit(#[LanguageLevelTypeAware(['8.1' => 'string'], default: 'mixed')] mixed $text): bool {}
next() method.
 *
 * @return void
 */
function ms_ResetErrorList() {}

/**
 * Class Objects can be returned by the `layerObj`_ class, or can be
 * created using:
 */
final class classObj
{
    /**
     * @var string
     */
    public $group;

    /**
     * @var string
     */
    public $keyimage;

    /**
     * Removed (6.2) - use addLabel, getLabel, ...
     *
     * @var labelObj
     */
    public $label;

    /**
     * @var float
     */
    public $maxscaledenom;

    /**
     * @var hashTableObj
     */
    public $metadata;

    /**
     * @var float
     */
    public $minscaledenom;

    /**
     * @var string
     */
    public $name;

    /**
     * read-only (since 6.2)
     *
     * @var int
     */
    public $numlabels;

    /**
     * read-only
     *
     * @var int
     */
    public $numstyles;

    /**
     * MS_ON, MS_OFF or MS_DELETE
     *
     * @var int
     */
    public $status;

    /**
     * @var string
     */
    public $template;

    /**
     * @var string
     */
    public $title;

    /**
     * @var int
     */
    public $type;

    /**
     * The second argument class is optional. If given, the new class
     * created will be a copy of this class.
     *
     * @param layerObj $layer
     * @param classObj $class
     */
    final public function __construct(layerObj $layer, classObj $class) {}

    /**
     * Old style constructor
     *
     * @param layerObj $layer
     * @param classObj $class
     * @return classObj
     */
    final public function ms_newClassObj(layerObj $layer, classObj $class) {}

    /**
     * Add a labelObj to the classObj and return its index in the labels
     * array.
     * .. versionadded:: 6.2
     *
     * @param labelObj $label
     * @return int
     */
    final public function addLabel(labelObj $label) {}

    /**
     * Saves the object to a string.  Provides the inverse option for
     * updateFromString.
     *
     * @return string
     */
    final public function convertToString() {}

    /**
     * Draw the legend icon and return a new imageObj.
     *
     * @param int $width
     * @param int $height
     * @return imageObj
     */
    final public function createLegendIcon($width, $height) {}

    /**
     * Delete the style specified by the style index. If there are any
     * style that follow the deleted style, their index will decrease by 1.
     *
     * @param int $index
     * @return int
     */
    final public function deletestyle($index) {}

    /**
     * Draw the legend icon on im object at dstX, dstY.
     * Returns MS_SUCCESS/MS_FAILURE.
     *
     * @param int $width
     * @param int $height
     * @param imageObj $im
     * @param int $dstX
     * @param int $dstY
     * @return int
     */
    final public function drawLegendIcon($width, $height, imageObj $im, $dstX, $dstY) {}

    /**
     * Free the object properties and break the internal references.
     * Note that you have to unset the php variable to free totally the
     * resources.
     *
     * @return void
     */
    final public function free() {}

    /**
     * Returns the :ref:`expression ` string for the class
     * object.
     *
     * @return string
     */
    final public function getExpressionString() {}

    /**
     * Return a reference to the labelObj at *index* in the labels array.
     * See the labelObj_ section for more details on multiple class
     * labels.
     * .. versionadded:: 6.2
     *
     * @param int $index
     * @return labelObj
     */
    final public function getLabel($index) {}

    /**
     * Fetch class metadata entry by name.  Returns "" if no entry
     * matches the name.  Note that the search is case sensitive.
     * .. note::
     * getMetaData's query is case sensitive.
     *
     * @param string $name
     * @return int
     */
    final public function getMetaData($name) {}

    /**
     * Return the style object using an index. index >= 0 &&
     * index < class->numstyles.
     *
     * @param int $index
     * @return styleObj
     */
    final public function getStyle($index) {}

    /**
     * Returns the text string for the class object.
     *
     * @return string
     */
    final public function getTextString() {}

    /**
     * The style specified by the style index will be moved down into
     * the array of classes. Returns MS_SUCCESS or MS_FAILURE.
     * ex class->movestyledown(0) will have the effect of moving style 0
     * up to position 1, and the style at position 1 will be moved
     * to position 0.
     *
     * @param int $index
     * @return int
     */
    final public function movestyledown($index) {}

    /**
     * The style specified by the style index will be moved up into
     * the array of classes. Returns MS_SUCCESS or MS_FAILURE.
     * ex class->movestyleup(1) will have the effect of moving style 1
     * up to position 0, and the style at position 0 will be moved
     * to position 1.
     *
     * @param int $index
     * @return int
     */
    final public function movestyleup($index) {}

    /**
     * Remove the labelObj at *index* from the labels array and return a
     * reference to the labelObj.  numlabels is decremented, and the
     * array is updated.
     * .. versionadded:: 6.2
     *
     * @param int $index
     * @return labelObj
     */
    final public function removeLabel($index) {}

    /**
     * Remove a metadata entry for the class.  Returns MS_SUCCESS/MS_FAILURE.
     *
     * @param string $name
     * @return int
     */
    final public function removeMetaData($name) {}

    /**
     * Set object property to a new value.
     *
     * @param string $property_name
     * @param  $new_value
     * @return int
     */
    final public function set($property_name, $new_value) {}

    /**
     * Set the :ref:`expression ` string for the class
     * object.
     *
     * @param string $expression
     * @return int
     */
    final public function setExpression($expression) {}

    /**
     * Set a metadata entry for the class.  Returns MS_SUCCESS/MS_FAILURE.
     *
     * @param string $name
     * @param string $value
     * @return int
     */
    final public function setMetaData($name, $value) {}

    /**
     * Set the text string for the class object.
     *
     * @param string $text
     * @return int
     */
    final public function settext($text) {}

    /**
     * Update a class from a string snippet. Returns MS_SUCCESS/MS_FAILURE.
     * .. code-block:: php
     * set the color
     * $oClass->updateFromString('CLASS STYLE COLOR 255 0 255 END END');
     *
     * @param string $snippet
     * @return int
     */
    final public function updateFromString($snippet) {}
}

/**
 * Instance of clusterObj is always embedded inside the `layerObj`_.
 */
final class clusterObj
{
    /**
     * @var float
     */
    public $buffer;

    /**
     * @var float
     */
    public $maxdistance;

    /**
     * @var string
     */
    public $region;

    /**
     * Saves the object to a string.  Provides the inverse option for
     * updateFromString.
     *
     * @return string
     */
    final public function convertToString() {}

    /**
     * Returns the :ref:`expression ` for this cluster
     * filter or NULL on error.
     *
     * @return string
     */
    final public function getFilterString() {}

    /**
     * Returns the :ref:`expression ` for this cluster group
     * or NULL on error.
     *
     * @return string
     */
    final public function getGroupString() {}

    /**
     * Set layer filter :ref:`expression `.
     *
     * @param string $expression
     * @return int
     */
    final public function setFilter($expression) {}

    /**
     * Set layer group :ref:`expression `.
     *
     * @param string $expression
     * @return int
     */
    final public function setGroup($expression) {}
}

/**
 * Instances of colorObj are always embedded inside other classes.
 */
final class colorObj
{
    /**
     * @var int
     */
    public $red;

    /**
     * @var int
     */
    public $green;

    /**
     * @var int
     */
    public $blue;

    /**
     * @var int
     */
    public $alpha;

    /**
     * Get the color as a hex string "#rrggbb" or (if alpha is not 255)
     * "#rrggbbaa".
     *
     * @return string
     */
    final public function toHex() {}

    /**
     * Set red, green, blue and alpha values. The hex string should have the form
     * "#rrggbb" (alpha will be set to 255) or "#rrggbbaa". Returns MS_SUCCESS.
     *
     * @param string $hex
     * @return int
     */
    final public function setHex($hex) {}
}

final class errorObj
{
    /**
     * //See error code constants above
     *
     * @var int
     */
    public $code;

    /**
     * @var string
     */
    public $message;

    /**
     * @var string
     */
    public $routine;
}

/**
 * The grid is always embedded inside a layer object defined as
 * a grid (layer->connectiontype = MS_GRATICULE)
 * (for more docs : https://github.com/mapserver/mapserver/wiki/MapServerGrid)
 * A layer can become a grid layer by adding a grid object to it using :
 * ms_newGridObj(layerObj layer)
 * $oLayer = ms_newlayerobj($oMap);
 * $oLayer->set("name", "GRID");
 * ms_newgridobj($oLayer);
 * $oLayer->grid->set("labelformat", "DDMMSS");
 */
final class gridObj
{
    /**
     * @var string
     */
    public $labelformat;

    /**
     * @var float
     */
    public $maxacrs;

    /**
     * @var float
     */
    public $maxinterval;

    /**
     * @var float
     */
    public $maxsubdivide;

    /**
     * @var float
     */
    public $minarcs;

    /**
     * @var float
     */
    public $mininterval;

    /**
     * @var float
     */
    public $minsubdivide;

    /**
     * Set object property to a new value.
     *
     * @param string $property_name
     * @param  $new_value
     * @return int
     */
    final public function set($property_name, $new_value) {}
}

/**
 * Instance of hashTableObj is always embedded inside the `classObj`_,
 * `layerObj`_, `mapObj`_ and `webObj`_. It is uses a read only.
 * $hashTable = $oLayer->metadata;
 * $key = null;
 * while ($key = $hashTable->nextkey($key))
 * echo "Key: ".$key." value: ".$hashTable->get($key)."
";
 */
final class hashTableObj
{
    /**
     * Clear all items in the hashTable (To NULL).
     *
     * @return void
     */
    final public function clear() {}

    /**
     * Fetch class metadata entry by name.  Returns "" if no entry
     * matches the name.  Note that the search is case sensitive.
     *
     * @param string $key
     * @return string
     */
    final public function get($key) {}

    /**
     * Return the next key or first key if previousKey = NULL.
     * Return NULL if no item is in the hashTable or end of hashTable is
     * reached
     *
     * @param string $previousKey
     * @return string
     */
    final public function nextkey($previousKey) {}

    /**
     * Remove a metadata entry in the hashTable.  Returns MS_SUCCESS/MS_FAILURE.
     *
     * @param string $key
     * @return int
     */
    final public function remove($key) {}

    /**
     * Set a metadata entry in the hashTable. Returns MS_SUCCESS/MS_FAILURE.
     *
     * @param string $key
     * @param string $value
     * @return int
     */
    final public function set($key, $value) {}
}

/**
 * Instances of imageObj are always created by the `mapObj`_ class methods.
 */
final class imageObj
{
    /**
     * read-only
     *
     * @var int
     */
    public $width;

    /**
     * read-only
     *
     * @var int
     */
    public $height;

    /**
     * read-only
     *
     * @var int
     */
    public $resolution;

    /**
     * read-only
     *
     * @var int
     */
    public $resolutionfactor;

    /**
     * @var string
     */
    public $imagepath;

    /**
     * @var string
     */
    public $imageurl;

    /**
     * Copy srcImg on top of the current imageObj.
     * transparentColorHex is the color (in 0xrrggbb format) from srcImg
     * that should be considered transparent (i.e. those pixels won't
     * be copied).  Pass -1 if you don't want any transparent color.
     * If optional dstx,dsty are provided then it defines the position
     * where the image should be copied (dstx,dsty = top-left corner
     * position).
     * The optional angle is a value between 0 and 360 degrees to rotate
     * the source image counterclockwise.  Note that if an angle is specified
     * (even if its value is zero) then the dstx and dsty coordinates
     * specify the CENTER of the destination area.
     * Note: this function works only with 8 bits GD images (PNG or GIF).
     *
     * @param imageObj $srcImg
     * @param int $transparentColorHex
     * @param int $dstX
     * @param int $dstY
     * @param int $angle
     * @return void
     */
    final public function pasteImage(imageObj $srcImg, $transparentColorHex, $dstX, $dstY, $angle) {}

    /**
     * Writes image object to specified filename.
     * Passing no filename or an empty filename sends output to stdout.  In
     * this case, the PHP header() function should be used to set the
     * document's content-type prior to calling saveImage().  The output
     * format is the one that is currently selected in the map file.  The
     * second argument oMap is not manadatory. It is usful when saving to
     * formats like GTIFF that needs georeference information contained in
     * the map file. On success, it returns either MS_SUCCESS if writing to an
     * external file, or the number of bytes written if output is sent to
     * stdout.
     *
     * @param string $filename
     * @param mapObj $oMap
     * @return int
     */
    final public function saveImage($filename, mapObj $oMap) {}

    /**
     * Writes image to temp directory.  Returns image URL.
     * The output format is the one that is currently selected in the
     * map file.
     *
     * @return string
     */
    final public function saveWebImage() {}
}

final class labelcacheMemberObj
{
    /**
     * read-only
     *
     * @var int
     */
    public $classindex;

    /**
     * read-only
     *
     * @var int
     */
    public $featuresize;

    /**
     * read-only
     *
     * @var int
     */
    public $layerindex;

    /**
     * read-only
     *
     * @var int
     */
    public $markerid;

    /**
     * read-only
     *
     * @var int
     */
    public $numstyles;

    /**
     * read-only
     *
     * @var int
     */
    public $shapeindex;

    /**
     * read-only
     *
     * @var int
     */
    public $status;

    /**
     * read-only
     *
     * @var string
     */
    public $text;

    /**
     * read-only
     *
     * @var int
     */
    public $tileindex;
}

final class labelcacheObj
{
    /**
     * Free the label cache. Always returns MS_SUCCESS.
     * Ex : map->labelcache->freeCache();
     *
     * @return bool
     */
    final public function freeCache() {}
}

/**
 * labelObj are always embedded inside other classes.
 */
final class labelObj
{
    /**
     * @var int
     */
    public $align;

    /**
     * @var float
     */
    public $angle;

    /**
     * @var int
     */
    public $anglemode;

    /**
     * @var int
     */
    public $antialias;

    /**
     * @var int
     */
    public $autominfeaturesize;

    /**
     * (deprecated since 6.0)
     *
     * @var colorObj
     */
    public $backgroundcolor;

    /**
     * (deprecated since 6.0)
     *
     * @var colorObj
     */
    public $backgroundshadowcolor;

    /**
     * (deprecated since 6.0)
     *
     * @var int
     */
    public $backgroundshadowsizex;

    /**
     * (deprecated since 6.0)
     *
     * @var int
     */
    public $backgroundshadowsizey;

    /**
     * @var int
     */
    public $buffer;

    /**
     * @var colorObj
     */
    public $color;

    /**
     * @var string
     */
    public $encoding;

    /**
     * @var string
     */
    public $font;

    /**
     * @var int
     */
    public $force;

    /**
     * @var int
     */
    public $maxlength;

    /**
     * @var int
     */
    public $maxsize;

    /**
     * @var int
     */
    public $mindistance;

    /**
     * @var int
     */
    public $minfeaturesize;

    /**
     * @var int
     */
    public $minlength;

    /**
     * @var int
     */
    public $minsize;

    /**
     * @var int
     */
    public $numstyles;

    /**
     * @var int
     */
    public $offsetx;

    /**
     * @var int
     */
    public $offsety;

    /**
     * @var colorObj
     */
    public $outlinecolor;

    /**
     * @var int
     */
    public $outlinewidth;

    /**
     * @var int
     */
    public $partials;

    /**
     * @var int
     */
    public $position;

    /**
     * @var int
     */
    public $priority;

    /**
     * @var int
     */
    public $repeatdistance;

    /**
     * @var colorObj
     */
    public $shadowcolor;

    /**
     * @var int
     */
    public $shadowsizex;

    /**
     * @var int
     */
    public $shadowsizey;

    /**
     * @var int
     */
    public $size;

    /**
     * @var int
     */
    public $wrap;

    final public function __construct() {}

    /**
     * Saves the object to a string.  Provides the inverse option for
     * updateFromString.
     *
     * @return string
     */
    final public function convertToString() {}

    /**
     * Delete the style specified by the style index. If there are any
     * style that follow the deleted style, their index will decrease by 1.
     *
     * @param int $index
     * @return int
     */
    final public function deleteStyle($index) {}

    /**
     * Free the object properties and break the internal references.
     * Note that you have to unset the php variable to free totally the
     * resources.
     *
     * @return void
     */
    final public function free() {}

    /**
     * Get the attribute binding for a specified label property. Returns
     * NULL if there is no binding for this property.
     * Example:
     * .. code-block:: php
     * $oLabel->setbinding(MS_LABEL_BINDING_COLOR, "FIELD_NAME_COLOR");
     * echo $oLabel->getbinding(MS_LABEL_BINDING_COLOR); // FIELD_NAME_COLOR
     *
     * @param mixed $labelbinding
     * @return string
     */
    final public function getBinding($labelbinding) {}

    /**
     * Returns the label expression string.
     *
     * @return string
     */
    final public function getExpressionString() {}

    /**
     * Return the style object using an index. index >= 0 &&
     * index < label->numstyles.
     *
     * @param int $index
     * @return styleObj
     */
    final public function getStyle($index) {}

    /**
     * Returns the label text string.
     *
     * @return string
     */
    final public function getTextString() {}

    /**
     * The style specified by the style index will be moved down into
     * the array of classes. Returns MS_SUCCESS or MS_FAILURE.
     * ex label->movestyledown(0) will have the effect of moving style 0
     * up to position 1, and the style at position 1 will be moved
     * to position 0.
     *
     * @param int $index
     * @return int
     */
    final public function moveStyleDown($index) {}

    /**
     * The style specified by the style index will be moved up into
     * the array of classes. Returns MS_SUCCESS or MS_FAILURE.
     * ex label->movestyleup(1) will have the effect of moving style 1
     * up to position 0, and the style at position 0 will be moved
     * to position 1.
     *
     * @param int $index
     * @return int
     */
    final public function moveStyleUp($index) {}

    /**
     * Remove the attribute binding for a specfiled style property.
     * Example:
     * .. code-block:: php
     * $oStyle->removebinding(MS_LABEL_BINDING_COLOR);
     *
     * @param mixed $labelbinding
     * @return int
     */
    final public function removeBinding($labelbinding) {}

    /**
     * Set object property to a new value.
     *
     * @param string $property_name
     * @param  $new_value
     * @return int
     */
    final public function set($property_name, $new_value) {}

    /**
     * Set the attribute binding for a specified label property.
     * Example:
     * .. code-block:: php
     * $oLabel->setbinding(MS_LABEL_BINDING_COLOR, "FIELD_NAME_COLOR");
     * This would bind the color parameter with the data (ie will extract
     * the value of the color from the field called "FIELD_NAME_COLOR"
     *
     * @param mixed $labelbinding
     * @param string $value
     * @return int
     */
    final public function setBinding($labelbinding, $value) {}

    /**
     * Set the label expression.
     *
     * @param string $expression
     * @return int
     */
    final public function setExpression($expression) {}

    /**
     * Set the label text.
     *
     * @param string $text
     * @return int
     */
    final public function setText($text) {}

    /**
     * Update a label from a string snippet. Returns MS_SUCCESS/MS_FAILURE.
     *
     * @param string $snippet
     * @return int
     */
    final public function updateFromString($snippet) {}
}

/**
 * Layer Objects can be returned by the `mapObj`_ class, or can be
 * created using:
 * A second optional argument can be given to ms_newLayerObj() to create
 * the new layer as a copy of an existing layer. If a layer is given as
 * argument then all members of a this layer will be copied in the new
 * layer created.
 */
final class layerObj
{
    /**
     * @var int
     */
    public $annotate;

    /**
     * @var hashTableObj
     */
    public $bindvals;

    /**
     * @var string
     */
    public $classgroup;

    /**
     * @var string
     */
    public $classitem;

    /**
     * @var clusterObj
     */
    public $cluster;

    /**
     * @var string
     */
    public $connection;

    /**
     * read-only, use setConnectionType() to set it
     *
     * @var int
     */
    public $connectiontype;

    /**
     * @var string
     */
    public $data;

    /**
     * @var int
     */
    public $debug;

    /**
     * deprecated since 6.0
     *
     * @var int
     */
    public $dump;

    /**
     * @var string
     */
    public $filteritem;

    /**
     * @var string
     */
    public $footer;

    /**
     * only available on a layer defined as grid (MS_GRATICULE)
     *
     * @var gridObj
     */
    public $grid;

    /**
     * @var string
     */
    public $group;

    /**
     * @var string
     */
    public $header;

    /**
     * read-only
     *
     * @var int
     */
    public $index;

    /**
     * @var int
     */
    public $labelcache;

    /**
     * @var string
     */
    public $labelitem;

    /**
     * @var float
     */
    public $labelmaxscaledenom;

    /**
     * @var float
     */
    public $labelminscaledenom;

    /**
     * @var string
     */
    public $labelrequires;

    /**
     * @var string
     */
    public $mask;

    /**
     * @var int
     */
    public $maxfeatures;

    /**
     * @var float
     */
    public $maxscaledenom;

    /**
     * @var hashTableObj
     */
    public $metadata;

    /**
     * @var float
     */
    public $minscaledenom;

    /**
     * @var string
     */
    public $name;

    /**
     * @var int
     */
    public $num_processing;

    /**
     * read-only
     *
     * @var int
     */
    public $numclasses;

    /**
     * @var colorObj
     */
    public $offsite;

    /**
     * @var int
     */
    public $opacity;

    /**
     * @var projectionObj
     */
    public $projection;

    /**
     * @var int
     */
    public $postlabelcache;

    /**
     * @var string
     */
    public $requires;

    /**
     * @var int
     */
    public $sizeunits;

    /**
     * @var int
     */
    public $startindex;

    /**
     * MS_ON, MS_OFF, MS_DEFAULT or MS_DELETE
     *
     * @var int
     */
    public $status;

    /**
     * @var string
     */
    public $styleitem;

    /**
     * @var float
     */
    public $symbolscaledenom;

    /**
     * @var string
     */
    public $template;

    /**
     * @var string
     */
    public $tileindex;

    /**
     * @var string
     */
    public $tileitem;

    /**
     * @var float
     */
    public $tolerance;

    /**
     * @var int
     */
    public $toleranceunits;

    /**
     * @var int
     */
    public $transform;

    /**
     * @var int
     */
    public $type;

    /**
     * Old style constructor
     *
     * @param mapObj $map
     * @param layerObj $layer
     * @return layerObj
     */
    final public function ms_newLayerObj(mapObj $map, layerObj $layer) {}

    /**
     * Add a new feature in a layer. Returns MS_SUCCESS or MS_FAILURE on
     * error.
     *
     * @param shapeObj $shape
     * @return int
     */
    final public function addFeature(shapeObj $shape) {}

    /**
     * Apply the :ref:`SLD ` document to the layer object.
     * The matching between the sld document and the layer will be done
     * using the layer's name.
     * If a namedlayer argument is passed (argument is optional),
     * the NamedLayer in the sld that matchs it will be used to style
     * the layer.
     * See :ref:`SLD HowTo ` for more information on the SLD support.
     *
     * @param string $sldxml
     * @param string $namedlayer
     * @return int
     */
    final public function applySLD($sldxml, $namedlayer) {}

    /**
     * Apply the :ref:`SLD ` document pointed by the URL to the
     * layer object. The matching between the sld document and the layer
     * will be done using the layer's name.  If a namedlayer argument is
     * passed (argument is optional), the NamedLayer in the sld that
     * matchs it will be used to style the layer.  See :ref:`SLD HowTo `
     * for more information on the SLD support.
     *
     * @param string $sldurl
     * @param string $namedlayer
     * @return int
     */
    final public function applySLDURL($sldurl, $namedlayer) {}

    /**
     * Clears all the processing strings.
     *
     * @return void
     */
    final public function clearProcessing() {}

    /**
     * Close layer previously opened with open().
     *
     * @return void
     */
    final public function close() {}

    /**
     * Saves the object to a string.  Provides the inverse option for
     * updateFromString.
     *
     * @return string
     */
    final public function convertToString() {}

    /**
     * Draw a single layer, add labels to cache if required.
     * Returns MS_SUCCESS or MS_FAILURE on error.
     *
     * @param imageObj $image
     * @return int
     */
    final public function draw(imageObj $image) {}

    /**
     * Draw query map for a single layer.
     * string   executeWFSGetfeature()
     * Executes a GetFeature request on a WFS layer and returns the
     * name of the temporary GML file created. Returns an empty
     * string on error.
     *
     * @param imageObj $image
     * @return int
     */
    final public function drawQuery(imageObj $image) {}

    /**
     * Free the object properties and break the internal references.
     * Note that you have to unset the php variable to free totally the
     * resources.
     *
     * @return void
     */
    final public function free() {}

    /**
     * Returns an SLD XML string based on all the classes found in the
     * layer (the layer must have `STATUS` `on`).
     *
     * @return string
     */
    final public function generateSLD() {}

    /**
     * Returns a classObj from the layer given an index value (0=first class)
     *
     * @param int $classIndex
     * @return classObj
     */
    final public function getClass($classIndex) {}

    /**
     * Get the class index of a shape for a given scale. Returns -1 if no
     * class matches. classgroup is an array of class ids to check
     * (Optional). numclasses is the number of classes that the classgroup
     * array contains. By default, all the layer classes will be checked.
     *
     * @param  $shape
     * @param  $classgroup
     * @param  $numclasses
     * @return int
     */
    final public function getClassIndex($shape, $classgroup, $numclasses) {}

    /**
     * Returns the layer's data extents or NULL on error.
     * If the layer's EXTENT member is set then this value is used,
     * otherwise this call opens/closes the layer to read the
     * extents. This is quick on shapefiles, but can be
     * an expensive operation on some file formats or data sources.
     * This function is safe to use on both opened or closed layers: it
     * is not necessary to call open()/close() before/after calling it.
     *
     * @return rectObj
     */
    final public function getExtent() {}

    /**
     * Returns the :ref:`expression ` for this layer or NULL
     * on error.
     *
     * @return string|null
     */
    final public function getFilterString() {}

    /**
     * Returns an array containing the grid intersection coordinates. If
     * there are no coordinates, it returns an empty array.
     *
     * @return array
     */
    final public function getGridIntersectionCoordinates() {}

    /**
     * Returns an array containing the items. Must call open function first.
     * If there are no items, it returns an empty array.
     *
     * @return array
     */
    final public function getItems() {}

    /**
     * Fetch layer metadata entry by name.  Returns "" if no entry
     * matches the name.  Note that the search is case sensitive.
     * .. note::
     * getMetaData's query is case sensitive.
     *
     * @param string $name
     * @return int
     */
    final public function getMetaData($name) {}

    /**
     * Returns the number of results in the last query.
     *
     * @return int
     */
    final public function getNumResults() {}

    /**
     * Returns an array containing the processing strings.
     * If there are no processing strings, it returns an empty array.
     *
     * @return array
     */
    final public function getProcessing() {}

    /**
     * Returns a string representation of the :ref:`projection `.
     * Returns NULL on error or if no projection is set.
     *
     * @return string
     */
    final public function getProjection() {}

    /**
     * Returns a resultObj by index from a layer object with
     * index in the range 0 to numresults-1.
     * Returns a valid object or FALSE(0) if index is invalid.
     *
     * @param int $index
     * @return resultObj
     */
    final public function getResult($index) {}

    /**
     * Returns the bounding box of the latest result.
     *
     * @return rectObj
     */
    final public function getResultsBounds() {}

    /**
     * If the resultObj passed has a valid resultindex, retrieve shapeObj from
     * a layer's resultset. (You get it from the resultObj returned by
     * getResult() for instance). Otherwise, it will do a single query on
     * the layer to fetch the shapeindex
     * .. code-block:: php
     * $map = new mapObj("gmap75.map");
     * $l = $map->getLayerByName("popplace");
     * $l->queryByRect($map->extent);
     * for ($i = 0; $i < $l->getNumResults(); $i++) {
     *     $s = $l->getShape($l->getResult($i));
     *     echo $s->getValue($l,"Name");
     *     echo "\n";
     * }
     *
     * @param resultObj $result
     * @return shapeObj
     */
    final public function getShape(resultObj $result) {}

    /**
     * Returns a WMS GetFeatureInfo URL (works only for WMS layers)
     * clickX, clickY is the location of to query in pixel coordinates
     * with (0,0) at the top left of the image.
     * featureCount is the number of results to return.
     * infoFormat is the format the format in which the result should be
     * requested.  Depends on remote server's capabilities.  MapServer
     * WMS servers support only "MIME" (and should support "GML.1" soon).
     * Returns "" and outputs a warning if layer is not a WMS layer
     * or if it is not queriable.
     *
     * @param int $clickX
     * @param int $clickY
     * @param int $featureCount
     * @param string $infoFormat
     * @return string
     */
    final public function getWMSFeatureInfoURL($clickX, $clickY, $featureCount, $infoFormat) {}

    /**
     * Returns MS_TRUE/MS_FALSE depending on whether the layer is
     * currently visible in the map (i.e. turned on, in scale, etc.).
     *
     * @return bool
     */
    final public function isVisible() {}

    /**
     * The class specified by the class index will be moved down into
     * the array of layers. Returns MS_SUCCESS or MS_FAILURE.
     * ex layer->moveclassdown(0) will have the effect of moving class 0
     * up to position 1, and the class at position 1 will be moved
     * to position 0.
     *
     * @param int $index
     * @return int
     */
    final public function moveclassdown($index) {}

    /**
     * The class specified by the class index will be moved up into
     * the array of layers. Returns MS_SUCCESS or MS_FAILURE.
     * ex layer->moveclassup(1) will have the effect of moving class 1
     * up to position 0, and the class at position 0 will be moved
     * to position 1.
     *
     * @param int $index
     * @return int
     */
    final public function moveclassup($index) {}

    /**
     * Open the layer for use with getShape().
     * Returns MS_SUCCESS/MS_FAILURE.
     *
     * @return int
     */
    final public function open() {}

    /**
     * Called after msWhichShapes has been called to actually retrieve
     * shapes within a given area. Returns a shape object or NULL on
     * error.
     * .. code-block:: php
     * $map = ms_newmapobj("d:/msapps/gmap-ms40/htdocs/gmap75.map");
     * $layer = $map->getLayerByName('road');
     * $status = $layer->open();
     * $status = $layer->whichShapes($map->extent);
     * while ($shape = $layer->nextShape())
     * {
     * echo $shape->index ."
\n";
     * }
     * $layer->close();
     *
     * @return shapeObj
     */
    final public function nextShape() {}

    /**
     * Query layer for shapes that intersect current map extents.  qitem
     * is the item (attribute) on which the query is performed, and
     * qstring is the expression to match.  The query is performed on all
     * the shapes that are part of a :ref:`CLASS` that contains a
     * :ref:`TEMPLATE