interop.headers source code

1 module interop.headers;
2 import core.stdc.config;
3 import core.stdc.stdarg: va_list;
4 static import core.simd;
5 static import std.conv;
6 
7 struct Int128 { long lower; long upper; }
8 struct UInt128 { ulong lower; ulong upper; }
9 
10 struct __locale_data { int dummy; }
11 
12 
13 
14 alias _Bool = bool;
15 struct dpp {
16     static struct Opaque(int N) {
17         void[N] bytes;
18     }
19 
20     static bool isEmpty(T)() {
21         return T.tupleof.length == 0;
22     }
23     static struct Move(T) {
24         T* ptr;
25     }
26 
27 
28     static auto move(T)(ref T value) {
29         return Move!T(&value);
30     }
31     mixin template EnumD(string name, T, string prefix) if(is(T == enum)) {
32         private static string _memberMixinStr(string member) {
33             import std.conv: text;
34             import std.array: replace;
35             return text(` `, member.replace(prefix, ""), ` = `, T.stringof, `.`, member, `,`);
36         }
37         private static string _enumMixinStr() {
38             import std.array: join;
39             string[] ret;
40             ret ~= "enum " ~ name ~ "{";
41             static foreach(member; __traits(allMembers, T)) {
42                 ret ~= _memberMixinStr(member);
43             }
44             ret ~= "}";
45             return ret.join("\n");
46         }
47         mixin(_enumMixinStr());
48     }
49 }
50 
51 extern(C)
52 {
53     alias wchar_t = int;
54     alias size_t = c_ulong;
55     alias ptrdiff_t = c_long;
56     struct max_align_t
57     {
58         long __clang_max_align_nonce1;
59         real __clang_max_align_nonce2;
60     }
61     int getdate_r(const(char)*, tm*) @nogc nothrow;
62     tm* getdate(const(char)*) @nogc nothrow;
63     extern __gshared int getdate_err;
64     int timespec_get(timespec*, int) @nogc nothrow;
65     int timer_getoverrun(void*) @nogc nothrow;
66     int timer_gettime(void*, itimerspec*) @nogc nothrow;
67     int timer_settime(void*, int, const(itimerspec)*, itimerspec*) @nogc nothrow;
68     int timer_delete(void*) @nogc nothrow;
69     int timer_create(int, sigevent*, void**) @nogc nothrow;
70     int clock_getcpuclockid(int, int*) @nogc nothrow;
71     int clock_nanosleep(int, int, const(timespec)*, timespec*) @nogc nothrow;
72     int clock_settime(int, const(timespec)*) @nogc nothrow;
73     int clock_gettime(int, timespec*) @nogc nothrow;
74     int clock_getres(int, timespec*) @nogc nothrow;
75     int nanosleep(const(timespec)*, timespec*) @nogc nothrow;
76     int dysize(int) @nogc nothrow;
77     c_long timelocal(tm*) @nogc nothrow;
78     c_long timegm(tm*) @nogc nothrow;
79     extern __gshared c_long timezone;
80     extern __gshared int daylight;
81     void tzset() @nogc nothrow;
82     extern __gshared char*[2] tzname;
83     extern __gshared c_long __timezone;
84     extern __gshared int __daylight;
85     extern __gshared char*[2] __tzname;
86     char* ctime_r(const(c_long)*, char*) @nogc nothrow;
87     char* asctime_r(const(tm)*, char*) @nogc nothrow;
88     char* ctime(const(c_long)*) @nogc nothrow;
89     char* asctime(const(tm)*) @nogc nothrow;
90     tm* localtime_r(const(c_long)*, tm*) @nogc nothrow;
91     tm* gmtime_r(const(c_long)*, tm*) @nogc nothrow;
92     tm* localtime(const(c_long)*) @nogc nothrow;
93     tm* gmtime(const(c_long)*) @nogc nothrow;
94     char* strptime_l(const(char)*, const(char)*, tm*, __locale_struct*) @nogc nothrow;
95     c_ulong strftime_l(char*, c_ulong, const(char)*, const(tm)*, __locale_struct*) @nogc nothrow;
96     char* strptime(const(char)*, const(char)*, tm*) @nogc nothrow;
97     c_ulong strftime(char*, c_ulong, const(char)*, const(tm)*) @nogc nothrow;
98     c_long mktime(tm*) @nogc nothrow;
99     double difftime(c_long, c_long) @nogc nothrow;
100     c_long time(c_long*) @nogc nothrow;
101     c_long clock() @nogc nothrow;
102     struct sigevent;
103     alias fsfilcnt64_t = c_ulong;
104     alias fsblkcnt64_t = c_ulong;
105     alias blkcnt64_t = c_long;
106     alias fsfilcnt_t = c_ulong;
107     alias fsblkcnt_t = c_ulong;
108     alias blkcnt_t = c_long;
109     alias blksize_t = c_long;
110     alias register_t = c_long;
111     alias u_int64_t = c_ulong;
112     alias u_int32_t = uint;
113     alias u_int16_t = ushort;
114     alias u_int8_t = ubyte;
115     alias suseconds_t = c_long;
116     alias useconds_t = uint;
117     alias key_t = int;
118     alias caddr_t = char*;
119     alias daddr_t = int;
120     alias ssize_t = c_long;
121     alias id_t = uint;
122     alias off64_t = c_long;
123     alias off_t = c_long;
124     alias uid_t = uint;
125     alias nlink_t = c_ulong;
126     alias mode_t = uint;
127     alias gid_t = uint;
128     alias dev_t = c_ulong;
129     alias ino64_t = c_ulong;
130     alias ino_t = c_ulong;
131     alias loff_t = c_long;
132     alias fsid_t = __fsid_t;
133     alias u_quad_t = c_ulong;
134     alias quad_t = c_long;
135     alias u_long = c_ulong;
136     alias u_int = uint;
137     alias u_short = ushort;
138     alias u_char = ubyte;
139     int pselect(int, fd_set*, fd_set*, fd_set*, const(timespec)*, const(__sigset_t)*) @nogc nothrow;
140     int select(int, fd_set*, fd_set*, fd_set*, timeval*) @nogc nothrow;
141     alias fd_mask = c_long;
142     struct fd_set
143     {
144         c_long[16] fds_bits;
145     }
146     alias __fd_mask = c_long;
147     pragma(mangle, "alloca") void* alloca_(c_ulong) @nogc nothrow;
148     static ushort __bswap_16(ushort) @nogc nothrow;
149     static uint __bswap_32(uint) @nogc nothrow;
150     static c_ulong __bswap_64(c_ulong) @nogc nothrow;
151     int getloadavg(double*, int) @nogc nothrow;
152     alias __cpu_mask = c_ulong;
153     int getpt() @nogc nothrow;
154     struct cpu_set_t
155     {
156         c_ulong[16] __bits;
157     }
158     int ptsname_r(int, char*, c_ulong) @nogc nothrow;
159     char* ptsname(int) @nogc nothrow;
160     int unlockpt(int) @nogc nothrow;
161     int grantpt(int) @nogc nothrow;
162     int __sched_cpucount(c_ulong, const(cpu_set_t)*) @nogc nothrow;
163     cpu_set_t* __sched_cpualloc(c_ulong) @nogc nothrow;
164     void __sched_cpufree(cpu_set_t*) @nogc nothrow;
165     int posix_openpt(int) @nogc nothrow;
166     int getsubopt(char**, char**, char**) @nogc nothrow;
167     int rpmatch(const(char)*) @nogc nothrow;
168     c_ulong wcstombs(char*, const(int)*, c_ulong) @nogc nothrow;
169     c_ulong mbstowcs(int*, const(char)*, c_ulong) @nogc nothrow;
170     int wctomb(char*, int) @nogc nothrow;
171     int mbtowc(int*, const(char)*, c_ulong) @nogc nothrow;
172     int mblen(const(char)*, c_ulong) @nogc nothrow;
173     int qfcvt_r(real, int, int*, int*, char*, c_ulong) @nogc nothrow;
174     alias _Float32 = float;
175     int qecvt_r(real, int, int*, int*, char*, c_ulong) @nogc nothrow;
176     int fcvt_r(double, int, int*, int*, char*, c_ulong) @nogc nothrow;
177     alias _Float64 = double;
178     int ecvt_r(double, int, int*, int*, char*, c_ulong) @nogc nothrow;
179     alias _Float32x = double;
180     char* qgcvt(real, int, char*) @nogc nothrow;
181     alias _Float64x = real;
182     char* qfcvt(real, int, int*, int*) @nogc nothrow;
183     char* qecvt(real, int, int*, int*) @nogc nothrow;
184     char* gcvt(double, int, char*) @nogc nothrow;
185     char* fcvt(double, int, int*, int*) @nogc nothrow;
186     char* ecvt(double, int, int*, int*) @nogc nothrow;
187     lldiv_t lldiv(long, long) @nogc nothrow;
188     ldiv_t ldiv(c_long, c_long) @nogc nothrow;
189     div_t div(int, int) @nogc nothrow;
190     long llabs(long) @nogc nothrow;
191     alias pthread_t = c_ulong;
192     union pthread_mutexattr_t
193     {
194         char[4] __size;
195         int __align;
196     }
197     union pthread_condattr_t
198     {
199         char[4] __size;
200         int __align;
201     }
202     alias pthread_key_t = uint;
203     alias pthread_once_t = int;
204     union pthread_attr_t
205     {
206         char[56] __size;
207         c_long __align;
208     }
209     union pthread_mutex_t
210     {
211         __pthread_mutex_s __data;
212         char[40] __size;
213         c_long __align;
214     }
215     union pthread_cond_t
216     {
217         __pthread_cond_s __data;
218         char[48] __size;
219         long __align;
220     }
221     union pthread_rwlock_t
222     {
223         __pthread_rwlock_arch_t __data;
224         char[56] __size;
225         c_long __align;
226     }
227     union pthread_rwlockattr_t
228     {
229         char[8] __size;
230         c_long __align;
231     }
232     alias pthread_spinlock_t = int;
233     union pthread_barrier_t
234     {
235         char[32] __size;
236         c_long __align;
237     }
238     union pthread_barrierattr_t
239     {
240         char[4] __size;
241         int __align;
242     }
243     c_long labs(c_long) @nogc nothrow;
244     int abs(int) @nogc nothrow;
245     void qsort_r(void*, c_ulong, c_ulong, int function(const(void)*, const(void)*, void*), void*) @nogc nothrow;
246     void qsort(void*, c_ulong, c_ulong, int function(const(void)*, const(void)*)) @nogc nothrow;
247     void* bsearch(const(void)*, const(void)*, c_ulong, c_ulong, int function(const(void)*, const(void)*)) @nogc nothrow;
248     alias __compar_d_fn_t = int function(const(void)*, const(void)*, void*);
249     alias comparison_fn_t = int function(const(void)*, const(void)*);
250     alias __compar_fn_t = int function(const(void)*, const(void)*);
251     char* realpath(const(char)*, char*) @nogc nothrow;
252     char* canonicalize_file_name(const(char)*) @nogc nothrow;
253     int system(const(char)*) @nogc nothrow;
254     int mkostemps64(char*, int, int) @nogc nothrow;
255     int clone(int function(void*), void*, int, void*, ...) @nogc nothrow;
256     int unshare(int) @nogc nothrow;
257     int sched_getcpu() @nogc nothrow;
258     int getcpu(uint*, uint*) @nogc nothrow;
259     int setns(int, int) @nogc nothrow;
260     int mkostemps(char*, int, int) @nogc nothrow;
261     alias __jmp_buf = c_long[8];
262     int mkostemp64(char*, int) @nogc nothrow;
263     alias int8_t = byte;
264     alias int16_t = short;
265     alias int32_t = int;
266     alias int64_t = c_long;
267     alias uint8_t = ubyte;
268     alias uint16_t = ushort;
269     alias uint32_t = uint;
270     alias uint64_t = ulong;
271     struct __pthread_mutex_s
272     {
273         int __lock;
274         uint __count;
275         int __owner;
276         uint __nusers;
277         int __kind;
278         short __spins;
279         short __elision;
280         __pthread_internal_list __list;
281     }
282     int mkostemp(char*, int) @nogc nothrow;
283     struct __pthread_rwlock_arch_t
284     {
285         uint __readers;
286         uint __writers;
287         uint __wrphase_futex;
288         uint __writers_futex;
289         uint __pad3;
290         uint __pad4;
291         int __cur_writer;
292         int __shared;
293         byte __rwelision;
294         ubyte[7] __pad1;
295         c_ulong __pad2;
296         uint __flags;
297     }
298     alias __pthread_list_t = __pthread_internal_list;
299     struct __pthread_internal_list
300     {
301         __pthread_internal_list* __prev;
302         __pthread_internal_list* __next;
303     }
304     alias __pthread_slist_t = __pthread_internal_slist;
305     struct __pthread_internal_slist
306     {
307         __pthread_internal_slist* __next;
308     }
309     struct __pthread_cond_s
310     {
311         static union _Anonymous_0
312         {
313             ulong __wseq;
314             static struct _Anonymous_1
315             {
316                 uint __low;
317                 uint __high;
318             }
319             _Anonymous_1 __wseq32;
320         }
321         _Anonymous_0 _anonymous_2;
322         auto __wseq() @property @nogc pure nothrow { return _anonymous_2.__wseq; }
323         void __wseq(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_2.__wseq = val; }
324         auto __wseq32() @property @nogc pure nothrow { return _anonymous_2.__wseq32; }
325         void __wseq32(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_2.__wseq32 = val; }
326         static union _Anonymous_3
327         {
328             ulong __g1_start;
329             static struct _Anonymous_4
330             {
331                 uint __low;
332                 uint __high;
333             }
334             _Anonymous_4 __g1_start32;
335         }
336         _Anonymous_3 _anonymous_5;
337         auto __g1_start() @property @nogc pure nothrow { return _anonymous_5.__g1_start; }
338         void __g1_start(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_5.__g1_start = val; }
339         auto __g1_start32() @property @nogc pure nothrow { return _anonymous_5.__g1_start32; }
340         void __g1_start32(_T_)(auto ref _T_ val) @property @nogc pure nothrow { _anonymous_5.__g1_start32 = val; }
341         uint[2] __g_refs;
342         uint[2] __g_size;
343         uint __g1_orig_size;
344         uint __wrefs;
345         uint[2] __g_signals;
346     }
347     char* mkdtemp(char*) @nogc nothrow;
348     int mkstemps64(char*, int) @nogc nothrow;
349     int mkstemps(char*, int) @nogc nothrow;
350     int mkstemp64(char*) @nogc nothrow;
351     int clock_adjtime(int, timex*) @nogc nothrow;
352     int mkstemp(char*) @nogc nothrow;
353     struct timex
354     {
355         import std.bitmanip: bitfields;
356 
357         align(4):
358         uint modes;
359         c_long offset;
360         c_long freq;
361         c_long maxerror;
362         c_long esterror;
363         int status;
364         c_long constant;
365         c_long precision;
366         c_long tolerance;
367         timeval time;
368         c_long tick;
369         c_long ppsfreq;
370         c_long jitter;
371         int shift;
372         c_long stabil;
373         c_long jitcnt;
374         c_long calcnt;
375         c_long errcnt;
376         c_long stbcnt;
377         int tai;
378         mixin(bitfields!(
379             int, "_anonymous_6", 32,
380             int, "_anonymous_7", 32,
381         ));
382         mixin(bitfields!(
383             int, "_anonymous_8", 32,
384             int, "_anonymous_9", 32,
385         ));
386         mixin(bitfields!(
387             int, "_anonymous_10", 32,
388             int, "_anonymous_11", 32,
389         ));
390         mixin(bitfields!(
391             int, "_anonymous_12", 32,
392             int, "_anonymous_13", 32,
393         ));
394         mixin(bitfields!(
395             int, "_anonymous_14", 32,
396             int, "_anonymous_15", 32,
397         ));
398         mixin(bitfields!(
399             int, "_anonymous_16", 32,
400         ));
401     }
402     char* mktemp(char*) @nogc nothrow;
403     int clearenv() @nogc nothrow;
404     int unsetenv(const(char)*) @nogc nothrow;
405     int setenv(const(char)*, const(char)*, int) @nogc nothrow;
406     int putenv(char*) @nogc nothrow;
407     char* secure_getenv(const(char)*) @nogc nothrow;
408     char* getenv(const(char)*) @nogc nothrow;
409     void _Exit(int) @nogc nothrow;
410     void quick_exit(int) @nogc nothrow;
411     void exit(int) @nogc nothrow;
412     int on_exit(void function(int, void*), void*) @nogc nothrow;
413     alias __u_char = ubyte;
414     alias __u_short = ushort;
415     alias __u_int = uint;
416     alias __u_long = c_ulong;
417     alias __int8_t = byte;
418     alias __uint8_t = ubyte;
419     alias __int16_t = short;
420     alias __uint16_t = ushort;
421     alias __int32_t = int;
422     alias __uint32_t = uint;
423     alias __int64_t = c_long;
424     alias __uint64_t = c_ulong;
425     alias __int_least8_t = byte;
426     alias __uint_least8_t = ubyte;
427     alias __int_least16_t = short;
428     alias __uint_least16_t = ushort;
429     alias __int_least32_t = int;
430     alias __uint_least32_t = uint;
431     alias __int_least64_t = c_long;
432     alias __uint_least64_t = c_ulong;
433     alias __quad_t = c_long;
434     alias __u_quad_t = c_ulong;
435     alias __intmax_t = c_long;
436     alias __uintmax_t = c_ulong;
437     int at_quick_exit(void function()) @nogc nothrow;
438     int atexit(void function()) @nogc nothrow;
439     void abort() @nogc nothrow;
440     void* aligned_alloc(c_ulong, c_ulong) @nogc nothrow;
441     alias __dev_t = c_ulong;
442     alias __uid_t = uint;
443     alias __gid_t = uint;
444     alias __ino_t = c_ulong;
445     alias __ino64_t = c_ulong;
446     alias __mode_t = uint;
447     alias __nlink_t = c_ulong;
448     alias __off_t = c_long;
449     alias __off64_t = c_long;
450     alias __pid_t = int;
451     struct __fsid_t
452     {
453         int[2] __val;
454     }
455     alias __clock_t = c_long;
456     alias __rlim_t = c_ulong;
457     alias __rlim64_t = c_ulong;
458     alias __id_t = uint;
459     alias __time_t = c_long;
460     alias __useconds_t = uint;
461     alias __suseconds_t = c_long;
462     alias __daddr_t = int;
463     alias __key_t = int;
464     alias __clockid_t = int;
465     alias __timer_t = void*;
466     alias __blksize_t = c_long;
467     alias __blkcnt_t = c_long;
468     alias __blkcnt64_t = c_long;
469     alias __fsblkcnt_t = c_ulong;
470     alias __fsblkcnt64_t = c_ulong;
471     alias __fsfilcnt_t = c_ulong;
472     alias __fsfilcnt64_t = c_ulong;
473     alias __fsword_t = c_long;
474     alias __ssize_t = c_long;
475     alias __syscall_slong_t = c_long;
476     alias __syscall_ulong_t = c_ulong;
477     alias __loff_t = c_long;
478     alias __caddr_t = char*;
479     alias __intptr_t = c_long;
480     alias __socklen_t = uint;
481     alias __sig_atomic_t = int;
482     struct __locale_struct
483     {
484         __locale_data*[13] __locales;
485         const(ushort)* __ctype_b;
486         const(int)* __ctype_tolower;
487         const(int)* __ctype_toupper;
488         const(char)*[13] __names;
489     }
490     alias __locale_t = __locale_struct*;
491     struct __sigset_t
492     {
493         c_ulong[16] __val;
494     }
495     alias clock_t = c_long;
496     int posix_memalign(void**, c_ulong, c_ulong) @nogc nothrow;
497     alias clockid_t = int;
498     alias locale_t = __locale_struct*;
499     alias sigset_t = __sigset_t;
500     struct itimerspec
501     {
502         timespec it_interval;
503         timespec it_value;
504     }
505     struct sched_param
506     {
507         int sched_priority;
508     }
509     struct timespec
510     {
511         c_long tv_sec;
512         c_long tv_nsec;
513     }
514     void* valloc(c_ulong) @nogc nothrow;
515     struct timeval
516     {
517         c_long tv_sec;
518         c_long tv_usec;
519     }
520     struct tm
521     {
522         int tm_sec;
523         int tm_min;
524         int tm_hour;
525         int tm_mday;
526         int tm_mon;
527         int tm_year;
528         int tm_wday;
529         int tm_yday;
530         int tm_isdst;
531         c_long tm_gmtoff;
532         const(char)* tm_zone;
533     }
534     alias time_t = c_long;
535     alias timer_t = void*;
536     void free(void*) @nogc nothrow;
537     void* reallocarray(void*, c_ulong, c_ulong) @nogc nothrow;
538     void* realloc(void*, c_ulong) @nogc nothrow;
539     void* calloc(c_ulong, c_ulong) @nogc nothrow;
540     void* malloc(c_ulong) @nogc nothrow;
541     int lcong48_r(ushort*, drand48_data*) @nogc nothrow;
542     int seed48_r(ushort*, drand48_data*) @nogc nothrow;
543     int srand48_r(c_long, drand48_data*) @nogc nothrow;
544     int jrand48_r(ushort*, drand48_data*, c_long*) @nogc nothrow;
545     int mrand48_r(drand48_data*, c_long*) @nogc nothrow;
546     int nrand48_r(ushort*, drand48_data*, c_long*) @nogc nothrow;
547     static ushort __uint16_identity(ushort) @nogc nothrow;
548     static uint __uint32_identity(uint) @nogc nothrow;
549     static c_ulong __uint64_identity(c_ulong) @nogc nothrow;
550     int lrand48_r(drand48_data*, c_long*) @nogc nothrow;
551     int erand48_r(ushort*, drand48_data*, double*) @nogc nothrow;
552     int drand48_r(drand48_data*, double*) @nogc nothrow;
553     struct drand48_data
554     {
555         ushort[3] __x;
556         ushort[3] __old_x;
557         ushort __c;
558         ushort __init;
559         ulong __a;
560     }
561     void lcong48(ushort*) @nogc nothrow;
562     ushort* seed48(ushort*) @nogc nothrow;
563     void srand48(c_long) @nogc nothrow;
564     c_long jrand48(ushort*) @nogc nothrow;
565     c_long mrand48() @nogc nothrow;
566     c_long nrand48(ushort*) @nogc nothrow;
567     c_long lrand48() @nogc nothrow;
568     double erand48(ushort*) @nogc nothrow;
569     double drand48() @nogc nothrow;
570     int rand_r(uint*) @nogc nothrow;
571     void srand(uint) @nogc nothrow;
572     int rand() @nogc nothrow;
573     int setstate_r(char*, random_data*) @nogc nothrow;
574     int initstate_r(uint, char*, c_ulong, random_data*) @nogc nothrow;
575     int srandom_r(uint, random_data*) @nogc nothrow;
576     int random_r(random_data*, int*) @nogc nothrow;
577     struct random_data
578     {
579         int* fptr;
580         int* rptr;
581         int* state;
582         int rand_type;
583         int rand_deg;
584         int rand_sep;
585         int* end_ptr;
586     }
587     char* setstate(char*) @nogc nothrow;
588     char* initstate(uint, char*, c_ulong) @nogc nothrow;
589     void srandom(uint) @nogc nothrow;
590     c_long random() @nogc nothrow;
591     c_long a64l(const(char)*) @nogc nothrow;
592     char* l64a(c_long) @nogc nothrow;
593     real strtof64x_l(const(char)*, char**, __locale_struct*) @nogc nothrow;
594     double strtof32x_l(const(char)*, char**, __locale_struct*) @nogc nothrow;
595     double strtof64_l(const(char)*, char**, __locale_struct*) @nogc nothrow;
596     float strtof32_l(const(char)*, char**, __locale_struct*) @nogc nothrow;
597     real strtold_l(const(char)*, char**, __locale_struct*) @nogc nothrow;
598     float strtof_l(const(char)*, char**, __locale_struct*) @nogc nothrow;
599     double strtod_l(const(char)*, char**, __locale_struct*) @nogc nothrow;
600     ulong strtoull_l(const(char)*, char**, int, __locale_struct*) @nogc nothrow;
601     long strtoll_l(const(char)*, char**, int, __locale_struct*) @nogc nothrow;
602     c_ulong strtoul_l(const(char)*, char**, int, __locale_struct*) @nogc nothrow;
603     c_long strtol_l(const(char)*, char**, int, __locale_struct*) @nogc nothrow;
604     int strfromf64x(char*, c_ulong, const(char)*, real) @nogc nothrow;
605     void grpc_metadata_array_init(grpc_metadata_array*) @nogc nothrow;
606     void grpc_metadata_array_destroy(grpc_metadata_array*) @nogc nothrow;
607     void grpc_call_details_init(grpc_call_details*) @nogc nothrow;
608     void grpc_call_details_destroy(grpc_call_details*) @nogc nothrow;
609     void grpc_register_plugin(void function(), void function()) @nogc nothrow;
610     void grpc_init() @nogc nothrow;
611     void grpc_shutdown() @nogc nothrow;
612     int grpc_is_initialized() @nogc nothrow;
613     void grpc_shutdown_blocking() @nogc nothrow;
614     const(char)* grpc_version_string() @nogc nothrow;
615     const(char)* grpc_g_stands_for() @nogc nothrow;
616     const(grpc_completion_queue_factory)* grpc_completion_queue_factory_lookup(const(grpc_completion_queue_attributes)*) @nogc nothrow;
617     grpc_completion_queue* grpc_completion_queue_create_for_next(void*) @nogc nothrow;
618     grpc_completion_queue* grpc_completion_queue_create_for_pluck(void*) @nogc nothrow;
619     grpc_completion_queue* grpc_completion_queue_create_for_callback(grpc_experimental_completion_queue_functor*, void*) @nogc nothrow;
620     grpc_completion_queue* grpc_completion_queue_create(const(grpc_completion_queue_factory)*, const(grpc_completion_queue_attributes)*, void*) @nogc nothrow;
621     grpc_event grpc_completion_queue_next(grpc_completion_queue*, gpr_timespec, void*) @nogc nothrow;
622     grpc_event grpc_completion_queue_pluck(grpc_completion_queue*, void*, gpr_timespec, void*) @nogc nothrow;
623     void grpc_completion_queue_shutdown(grpc_completion_queue*) @nogc nothrow;
624     void grpc_completion_queue_destroy(grpc_completion_queue*) @nogc nothrow;
625     void grpc_completion_queue_thread_local_cache_init(grpc_completion_queue*) @nogc nothrow;
626     int grpc_completion_queue_thread_local_cache_flush(grpc_completion_queue*, void**, int*) @nogc nothrow;
627     grpc_connectivity_state grpc_channel_check_connectivity_state(grpc_channel*, int) @nogc nothrow;
628     int grpc_channel_num_external_connectivity_watchers(grpc_channel*) @nogc nothrow;
629     void grpc_channel_watch_connectivity_state(grpc_channel*, grpc_connectivity_state, gpr_timespec, grpc_completion_queue*, void*) @nogc nothrow;
630     int grpc_channel_support_connectivity_watcher(grpc_channel*) @nogc nothrow;
631     grpc_call* grpc_channel_create_call(grpc_channel*, grpc_call*, uint, grpc_completion_queue*, grpc_slice, const(grpc_slice)*, gpr_timespec, void*) @nogc nothrow;
632     void grpc_channel_ping(grpc_channel*, grpc_completion_queue*, void*, void*) @nogc nothrow;
633     void* grpc_channel_register_call(grpc_channel*, const(char)*, const(char)*, void*) @nogc nothrow;
634     grpc_call* grpc_channel_create_registered_call(grpc_channel*, grpc_call*, uint, grpc_completion_queue*, void*, gpr_timespec, void*) @nogc nothrow;
635     void* grpc_call_arena_alloc(grpc_call*, c_ulong) @nogc nothrow;
636     grpc_call_error grpc_call_start_batch(grpc_call*, const(grpc_op)*, c_ulong, void*, void*) @nogc nothrow;
637     char* grpc_call_get_peer(grpc_call*) @nogc nothrow;
638     struct census_context;
639     void grpc_census_call_set_context(grpc_call*, census_context*) @nogc nothrow;
640     census_context* grpc_census_call_get_context(grpc_call*) @nogc nothrow;
641     char* grpc_channel_get_target(grpc_channel*) @nogc nothrow;
642     void grpc_channel_get_info(grpc_channel*, const(grpc_channel_info)*) @nogc nothrow;
643     void grpc_channel_reset_connect_backoff(grpc_channel*) @nogc nothrow;
644     grpc_channel* grpc_insecure_channel_create(const(char)*, const(grpc_channel_args)*, void*) @nogc nothrow;
645     grpc_channel* grpc_lame_client_channel_create(const(char)*, grpc_status_code, const(char)*) @nogc nothrow;
646     void grpc_channel_destroy(grpc_channel*) @nogc nothrow;
647     grpc_call_error grpc_call_cancel(grpc_call*, void*) @nogc nothrow;
648     grpc_call_error grpc_call_cancel_with_status(grpc_call*, grpc_status_code, const(char)*, void*) @nogc nothrow;
649     void grpc_call_ref(grpc_call*) @nogc nothrow;
650     void grpc_call_unref(grpc_call*) @nogc nothrow;
651     grpc_call_error grpc_server_request_call(grpc_server*, grpc_call**, grpc_call_details*, grpc_metadata_array*, grpc_completion_queue*, grpc_completion_queue*, void*) @nogc nothrow;
652     alias grpc_server_register_method_payload_handling = _Anonymous_17;
653     enum _Anonymous_17
654     {
655         GRPC_SRM_PAYLOAD_NONE = 0,
656         GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER = 1,
657     }
658     enum GRPC_SRM_PAYLOAD_NONE = _Anonymous_17.GRPC_SRM_PAYLOAD_NONE;
659     enum GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER = _Anonymous_17.GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER;
660     void* grpc_server_register_method(grpc_server*, const(char)*, const(char)*, grpc_server_register_method_payload_handling, uint) @nogc nothrow;
661     grpc_call_error grpc_server_request_registered_call(grpc_server*, void*, grpc_call**, gpr_timespec*, grpc_metadata_array*, grpc_byte_buffer**, grpc_completion_queue*, grpc_completion_queue*, void*) @nogc nothrow;
662     grpc_server* grpc_server_create(const(grpc_channel_args)*, void*) @nogc nothrow;
663     void grpc_server_register_completion_queue(grpc_server*, grpc_completion_queue*, void*) @nogc nothrow;
664     int grpc_server_add_insecure_http2_port(grpc_server*, const(char)*) @nogc nothrow;
665     void grpc_server_start(grpc_server*) @nogc nothrow;
666     void grpc_server_shutdown_and_notify(grpc_server*, grpc_completion_queue*, void*) @nogc nothrow;
667     void grpc_server_cancel_all_calls(grpc_server*) @nogc nothrow;
668     void grpc_server_destroy(grpc_server*) @nogc nothrow;
669     int grpc_tracer_set_enabled(const(char)*, int) @nogc nothrow;
670     int grpc_header_key_is_legal(grpc_slice) @nogc nothrow;
671     int grpc_header_nonbin_value_is_legal(grpc_slice) @nogc nothrow;
672     int grpc_is_binary_header(grpc_slice) @nogc nothrow;
673     const(char)* grpc_call_error_to_string(grpc_call_error) @nogc nothrow;
674     grpc_resource_quota* grpc_resource_quota_create(const(char)*) @nogc nothrow;
675     void grpc_resource_quota_ref(grpc_resource_quota*) @nogc nothrow;
676     void grpc_resource_quota_unref(grpc_resource_quota*) @nogc nothrow;
677     void grpc_resource_quota_resize(grpc_resource_quota*, c_ulong) @nogc nothrow;
678     void grpc_resource_quota_set_max_threads(grpc_resource_quota*, int) @nogc nothrow;
679     const(grpc_arg_pointer_vtable)* grpc_resource_quota_arg_vtable() @nogc nothrow;
680     char* grpc_channelz_get_top_channels(c_long) @nogc nothrow;
681     char* grpc_channelz_get_servers(c_long) @nogc nothrow;
682     char* grpc_channelz_get_server(c_long) @nogc nothrow;
683     char* grpc_channelz_get_server_sockets(c_long, c_long, c_long) @nogc nothrow;
684     char* grpc_channelz_get_channel(c_long) @nogc nothrow;
685     char* grpc_channelz_get_subchannel(c_long) @nogc nothrow;
686     char* grpc_channelz_get_socket(c_long) @nogc nothrow;
687     struct grpc_auth_context;
688     struct grpc_auth_property_iterator
689     {
690         const(grpc_auth_context)* ctx;
691         c_ulong index;
692         const(char)* name;
693     }
694     struct grpc_auth_property
695     {
696         char* name;
697         char* value;
698         c_ulong value_length;
699     }
700     const(grpc_auth_property)* grpc_auth_property_iterator_next(grpc_auth_property_iterator*) @nogc nothrow;
701     grpc_auth_property_iterator grpc_auth_context_property_iterator(const(grpc_auth_context)*) @nogc nothrow;
702     grpc_auth_property_iterator grpc_auth_context_peer_identity(const(grpc_auth_context)*) @nogc nothrow;
703     grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(const(grpc_auth_context)*, const(char)*) @nogc nothrow;
704     const(char)* grpc_auth_context_peer_identity_property_name(const(grpc_auth_context)*) @nogc nothrow;
705     int grpc_auth_context_peer_is_authenticated(const(grpc_auth_context)*) @nogc nothrow;
706     grpc_auth_context* grpc_call_auth_context(grpc_call*) @nogc nothrow;
707     void grpc_auth_context_release(grpc_auth_context*) @nogc nothrow;
708     void grpc_auth_context_add_property(grpc_auth_context*, const(char)*, const(char)*, c_ulong) @nogc nothrow;
709     void grpc_auth_context_add_cstring_property(grpc_auth_context*, const(char)*, const(char)*) @nogc nothrow;
710     int grpc_auth_context_set_peer_identity_property_name(grpc_auth_context*, const(char)*) @nogc nothrow;
711     struct grpc_ssl_session_cache;
712     grpc_ssl_session_cache* grpc_ssl_session_cache_create_lru(c_ulong) @nogc nothrow;
713     void grpc_ssl_session_cache_destroy(grpc_ssl_session_cache*) @nogc nothrow;
714     grpc_arg grpc_ssl_session_cache_create_channel_arg(grpc_ssl_session_cache*) @nogc nothrow;
715     struct grpc_channel_credentials;
716     void grpc_channel_credentials_release(grpc_channel_credentials*) @nogc nothrow;
717     grpc_channel_credentials* grpc_google_default_credentials_create() @nogc nothrow;
718     alias grpc_ssl_roots_override_callback = grpc_ssl_roots_override_result function(char**);
719     void grpc_set_ssl_roots_override_callback(grpc_ssl_roots_override_result function(char**)) @nogc nothrow;
720     struct grpc_ssl_pem_key_cert_pair
721     {
722         const(char)* private_key;
723         const(char)* cert_chain;
724     }
725     struct verify_peer_options
726     {
727         int function(const(char)*, const(char)*, void*) verify_peer_callback;
728         void* verify_peer_callback_userdata;
729         void function(void*) verify_peer_destruct;
730     }
731     struct grpc_ssl_verify_peer_options
732     {
733         int function(const(char)*, const(char)*, void*) verify_peer_callback;
734         void* verify_peer_callback_userdata;
735         void function(void*) verify_peer_destruct;
736     }
737     grpc_channel_credentials* grpc_ssl_credentials_create(const(char)*, grpc_ssl_pem_key_cert_pair*, const(verify_peer_options)*, void*) @nogc nothrow;
738     grpc_channel_credentials* grpc_ssl_credentials_create_ex(const(char)*, grpc_ssl_pem_key_cert_pair*, const(grpc_ssl_verify_peer_options)*, void*) @nogc nothrow;
739     struct grpc_call_credentials;
740     void grpc_call_credentials_release(grpc_call_credentials*) @nogc nothrow;
741     grpc_channel_credentials* grpc_composite_channel_credentials_create(grpc_channel_credentials*, grpc_call_credentials*, void*) @nogc nothrow;
742     grpc_call_credentials* grpc_composite_call_credentials_create(grpc_call_credentials*, grpc_call_credentials*, void*) @nogc nothrow;
743     grpc_call_credentials* grpc_google_compute_engine_credentials_create(void*) @nogc nothrow;
744     gpr_timespec grpc_max_auth_token_lifetime() @nogc nothrow;
745     grpc_call_credentials* grpc_service_account_jwt_access_credentials_create(const(char)*, gpr_timespec, void*) @nogc nothrow;
746     grpc_call_credentials* grpc_google_refresh_token_credentials_create(const(char)*, void*) @nogc nothrow;
747     grpc_call_credentials* grpc_access_token_credentials_create(const(char)*, void*) @nogc nothrow;
748     grpc_call_credentials* grpc_google_iam_credentials_create(const(char)*, const(char)*, void*) @nogc nothrow;
749     struct grpc_sts_credentials_options
750     {
751         const(char)* token_exchange_service_uri;
752         const(char)* resource;
753         const(char)* audience;
754         const(char)* scope_;
755         const(char)* requested_token_type;
756         const(char)* subject_token_path;
757         const(char)* subject_token_type;
758         const(char)* actor_token_path;
759         const(char)* actor_token_type;
760     }
761     grpc_call_credentials* grpc_sts_credentials_create(const(grpc_sts_credentials_options)*, void*) @nogc nothrow;
762     alias grpc_credentials_plugin_metadata_cb = void function(void*, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*);
763     struct grpc_auth_metadata_context
764     {
765         const(char)* service_url;
766         const(char)* method_name;
767         const(grpc_auth_context)* channel_auth_context;
768         void* reserved;
769     }
770     int strfromf32x(char*, c_ulong, const(char)*, double) @nogc nothrow;
771     struct grpc_metadata_credentials_plugin
772     {
773         int function(void*, grpc_auth_metadata_context, void function(void*, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*), void*, grpc_metadata[4], c_ulong*, grpc_status_code*, const(char)**) get_metadata;
774         void function(void*) destroy;
775         void* state;
776         const(char)* type;
777     }
778     grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(grpc_metadata_credentials_plugin, grpc_security_level, void*) @nogc nothrow;
779     grpc_channel* grpc_secure_channel_create(grpc_channel_credentials*, const(char)*, const(grpc_channel_args)*, void*) @nogc nothrow;
780     struct grpc_server_credentials;
781     void grpc_server_credentials_release(grpc_server_credentials*) @nogc nothrow;
782     struct grpc_ssl_server_certificate_config;
783     grpc_ssl_server_certificate_config* grpc_ssl_server_certificate_config_create(const(char)*, const(grpc_ssl_pem_key_cert_pair)*, c_ulong) @nogc nothrow;
784     void grpc_ssl_server_certificate_config_destroy(grpc_ssl_server_certificate_config*) @nogc nothrow;
785     alias grpc_ssl_server_certificate_config_callback = grpc_ssl_certificate_config_reload_status function(void*, grpc_ssl_server_certificate_config**);
786     grpc_server_credentials* grpc_ssl_server_credentials_create(const(char)*, grpc_ssl_pem_key_cert_pair*, c_ulong, int, void*) @nogc nothrow;
787     grpc_server_credentials* grpc_ssl_server_credentials_create_ex(const(char)*, grpc_ssl_pem_key_cert_pair*, c_ulong, grpc_ssl_client_certificate_request_type, void*) @nogc nothrow;
788     struct grpc_ssl_server_credentials_options;
789     grpc_ssl_server_credentials_options* grpc_ssl_server_credentials_create_options_using_config(grpc_ssl_client_certificate_request_type, grpc_ssl_server_certificate_config*) @nogc nothrow;
790     grpc_ssl_server_credentials_options* grpc_ssl_server_credentials_create_options_using_config_fetcher(grpc_ssl_client_certificate_request_type, grpc_ssl_certificate_config_reload_status function(void*, grpc_ssl_server_certificate_config**), void*) @nogc nothrow;
791     void grpc_ssl_server_credentials_options_destroy(grpc_ssl_server_credentials_options*) @nogc nothrow;
792     grpc_server_credentials* grpc_ssl_server_credentials_create_with_options(grpc_ssl_server_credentials_options*) @nogc nothrow;
793     int grpc_server_add_secure_http2_port(grpc_server*, const(char)*, grpc_server_credentials*) @nogc nothrow;
794     grpc_call_error grpc_call_set_credentials(grpc_call*, grpc_call_credentials*) @nogc nothrow;
795     alias grpc_process_auth_metadata_done_cb = void function(void*, const(grpc_metadata)*, c_ulong, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*);
796     struct grpc_auth_metadata_processor
797     {
798         void function(void*, grpc_auth_context*, const(grpc_metadata)*, c_ulong, void function(void*, const(grpc_metadata)*, c_ulong, const(grpc_metadata)*, c_ulong, grpc_status_code, const(char)*), void*) process;
799         void function(void*) destroy;
800         void* state;
801     }
802     void grpc_server_credentials_set_auth_metadata_processor(grpc_server_credentials*, grpc_auth_metadata_processor) @nogc nothrow;
803     struct grpc_alts_credentials_options;
804     grpc_alts_credentials_options* grpc_alts_credentials_client_options_create() @nogc nothrow;
805     grpc_alts_credentials_options* grpc_alts_credentials_server_options_create() @nogc nothrow;
806     void grpc_alts_credentials_client_options_add_target_service_account(grpc_alts_credentials_options*, const(char)*) @nogc nothrow;
807     void grpc_alts_credentials_options_destroy(grpc_alts_credentials_options*) @nogc nothrow;
808     grpc_channel_credentials* grpc_alts_credentials_create(const(grpc_alts_credentials_options)*) @nogc nothrow;
809     grpc_server_credentials* grpc_alts_server_credentials_create(const(grpc_alts_credentials_options)*) @nogc nothrow;
810     grpc_channel_credentials* grpc_local_credentials_create(grpc_local_connect_type) @nogc nothrow;
811     grpc_server_credentials* grpc_local_server_credentials_create(grpc_local_connect_type) @nogc nothrow;
812     struct grpc_tls_key_materials_config;
813     struct grpc_tls_credential_reload_config;
814     struct grpc_tls_server_authorization_check_config;
815     struct grpc_tls_credentials_options;
816     grpc_tls_credentials_options* grpc_tls_credentials_options_create() @nogc nothrow;
817     int grpc_tls_credentials_options_set_cert_request_type(grpc_tls_credentials_options*, grpc_ssl_client_certificate_request_type) @nogc nothrow;
818     int grpc_tls_credentials_options_set_server_verification_option(grpc_tls_credentials_options*, grpc_tls_server_verification_option) @nogc nothrow;
819     int grpc_tls_credentials_options_set_key_materials_config(grpc_tls_credentials_options*, grpc_tls_key_materials_config*) @nogc nothrow;
820     int grpc_tls_credentials_options_set_credential_reload_config(grpc_tls_credentials_options*, grpc_tls_credential_reload_config*) @nogc nothrow;
821     int grpc_tls_credentials_options_set_server_authorization_check_config(grpc_tls_credentials_options*, grpc_tls_server_authorization_check_config*) @nogc nothrow;
822     grpc_tls_key_materials_config* grpc_tls_key_materials_config_create() @nogc nothrow;
823     int grpc_tls_key_materials_config_set_key_materials(grpc_tls_key_materials_config*, const(char)*, const(grpc_ssl_pem_key_cert_pair)**, c_ulong) @nogc nothrow;
824     int grpc_tls_key_materials_config_set_version(grpc_tls_key_materials_config*, int) @nogc nothrow;
825     int grpc_tls_key_materials_config_get_version(grpc_tls_key_materials_config*) @nogc nothrow;
826     struct grpc_tls_credential_reload_arg
827     {
828         void function(grpc_tls_credential_reload_arg*) cb;
829         void* cb_user_data;
830         grpc_tls_key_materials_config* key_materials_config;
831         grpc_ssl_certificate_config_reload_status status;
832         const(char)* error_details;
833         grpc_tls_credential_reload_config* config;
834         void* context;
835         void function(void*) destroy_context;
836     }
837     alias grpc_tls_on_credential_reload_done_cb = void function(grpc_tls_credential_reload_arg*);
838     grpc_tls_credential_reload_config* grpc_tls_credential_reload_config_create(const(void)*, int function(void*, grpc_tls_credential_reload_arg*), void function(void*, grpc_tls_credential_reload_arg*), void function(void*)) @nogc nothrow;
839     struct grpc_tls_server_authorization_check_arg
840     {
841         void function(grpc_tls_server_authorization_check_arg*) cb;
842         void* cb_user_data;
843         int success;
844         const(char)* target_name;
845         const(char)* peer_cert;
846         const(char)* peer_cert_full_chain;
847         grpc_status_code status;
848         const(char)* error_details;
849         grpc_tls_server_authorization_check_config* config;
850         void* context;
851         void function(void*) destroy_context;
852     }
853     alias grpc_tls_on_server_authorization_check_done_cb = void function(grpc_tls_server_authorization_check_arg*);
854     grpc_tls_server_authorization_check_config* grpc_tls_server_authorization_check_config_create(const(void)*, int function(void*, grpc_tls_server_authorization_check_arg*), void function(void*, grpc_tls_server_authorization_check_arg*), void function(void*)) @nogc nothrow;
855     grpc_channel_credentials* grpc_tls_credentials_create(grpc_tls_credentials_options*) @nogc nothrow;
856     grpc_server_credentials* grpc_tls_server_credentials_create(grpc_tls_credentials_options*) @nogc nothrow;
857     int strfromf64(char*, c_ulong, const(char)*, double) @nogc nothrow;
858     alias grpc_ssl_roots_override_result = _Anonymous_18;
859     enum _Anonymous_18
860     {
861         GRPC_SSL_ROOTS_OVERRIDE_OK = 0,
862         GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY = 1,
863         GRPC_SSL_ROOTS_OVERRIDE_FAIL = 2,
864     }
865     enum GRPC_SSL_ROOTS_OVERRIDE_OK = _Anonymous_18.GRPC_SSL_ROOTS_OVERRIDE_OK;
866     enum GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY = _Anonymous_18.GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY;
867     enum GRPC_SSL_ROOTS_OVERRIDE_FAIL = _Anonymous_18.GRPC_SSL_ROOTS_OVERRIDE_FAIL;
868     alias grpc_ssl_certificate_config_reload_status = _Anonymous_19;
869     enum _Anonymous_19
870     {
871         GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED = 0,
872         GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW = 1,
873         GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL = 2,
874     }
875     enum GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED = _Anonymous_19.GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
876     enum GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW = _Anonymous_19.GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW;
877     enum GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL = _Anonymous_19.GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL;
878     alias grpc_ssl_client_certificate_request_type = _Anonymous_20;
879     enum _Anonymous_20
880     {
881         GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE = 0,
882         GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = 1,
883         GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY = 2,
884         GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = 3,
885         GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY = 4,
886     }
887     enum GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE = _Anonymous_20.GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE;
888     enum GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY;
889     enum GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY;
890     enum GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY;
891     enum GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY = _Anonymous_20.GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY;
892     alias grpc_security_level = _Anonymous_21;
893     enum _Anonymous_21
894     {
895         GRPC_SECURITY_MIN = 0,
896         GRPC_SECURITY_NONE = 0,
897         GRPC_INTEGRITY_ONLY = 1,
898         GRPC_PRIVACY_AND_INTEGRITY = 2,
899         GRPC_SECURITY_MAX = 2,
900     }
901     enum GRPC_SECURITY_MIN = _Anonymous_21.GRPC_SECURITY_MIN;
902     enum GRPC_SECURITY_NONE = _Anonymous_21.GRPC_SECURITY_NONE;
903     enum GRPC_INTEGRITY_ONLY = _Anonymous_21.GRPC_INTEGRITY_ONLY;
904     enum GRPC_PRIVACY_AND_INTEGRITY = _Anonymous_21.GRPC_PRIVACY_AND_INTEGRITY;
905     enum GRPC_SECURITY_MAX = _Anonymous_21.GRPC_SECURITY_MAX;
906     alias grpc_tls_server_verification_option = _Anonymous_22;
907     enum _Anonymous_22
908     {
909         GRPC_TLS_SERVER_VERIFICATION = 0,
910         GRPC_TLS_SKIP_HOSTNAME_VERIFICATION = 1,
911         GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION = 2,
912     }
913     enum GRPC_TLS_SERVER_VERIFICATION = _Anonymous_22.GRPC_TLS_SERVER_VERIFICATION;
914     enum GRPC_TLS_SKIP_HOSTNAME_VERIFICATION = _Anonymous_22.GRPC_TLS_SKIP_HOSTNAME_VERIFICATION;
915     enum GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION = _Anonymous_22.GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION;
916     alias grpc_local_connect_type = _Anonymous_23;
917     enum _Anonymous_23
918     {
919         UDS = 0,
920         LOCAL_TCP = 1,
921     }
922     enum UDS = _Anonymous_23.UDS;
923     enum LOCAL_TCP = _Anonymous_23.LOCAL_TCP;
924     int strfromf32(char*, c_ulong, const(char)*, float) @nogc nothrow;
925     c_long gpr_atm_no_barrier_clamped_add(c_long*, c_long, c_long, c_long) @nogc nothrow;
926     alias gpr_atm = c_long;
927     int strfroml(char*, c_ulong, const(char)*, real) @nogc nothrow;
928     int strfromf(char*, c_ulong, const(char)*, float) @nogc nothrow;
929     static int gpr_atm_no_barrier_cas(c_long*, c_long, c_long) @nogc nothrow;
930     static int gpr_atm_acq_cas(c_long*, c_long, c_long) @nogc nothrow;
931     static int gpr_atm_rel_cas(c_long*, c_long, c_long) @nogc nothrow;
932     static int gpr_atm_full_cas(c_long*, c_long, c_long) @nogc nothrow;
933     int strfromd(char*, c_ulong, const(char)*, double) @nogc nothrow;
934     grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice*, c_ulong) @nogc nothrow;
935     grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(grpc_slice*, c_ulong, grpc_compression_algorithm) @nogc nothrow;
936     grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer*) @nogc nothrow;
937     c_ulong grpc_byte_buffer_length(grpc_byte_buffer*) @nogc nothrow;
938     void grpc_byte_buffer_destroy(grpc_byte_buffer*) @nogc nothrow;
939     int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader*, grpc_byte_buffer*) @nogc nothrow;
940     void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader*) @nogc nothrow;
941     int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader*, grpc_slice*) @nogc nothrow;
942     int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader*, grpc_slice**) @nogc nothrow;
943     grpc_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader*) @nogc nothrow;
944     grpc_byte_buffer* grpc_raw_byte_buffer_from_reader(grpc_byte_buffer_reader*) @nogc nothrow;
945     struct grpc_byte_buffer
946     {
947         void* reserved;
948         grpc_byte_buffer_type type;
949         union grpc_byte_buffer_data
950         {
951             static struct _Anonymous_24
952             {
953                 void*[8] reserved;
954             }
955             _Anonymous_24 reserved;
956             struct grpc_compressed_buffer
957             {
958                 grpc_compression_algorithm compression;
959                 grpc_slice_buffer slice_buffer;
960             }
961             grpc_compressed_buffer raw;
962         }
963         grpc_byte_buffer_data data;
964     }
965     struct grpc_byte_buffer_reader
966     {
967         grpc_byte_buffer* buffer_in;
968         grpc_byte_buffer* buffer_out;
969         union grpc_byte_buffer_reader_current
970         {
971             uint index;
972         }
973         grpc_byte_buffer_reader_current current;
974     }
975     ulong strtoull(const(char)*, char**, int) @nogc nothrow;
976     long strtoll(const(char)*, char**, int) @nogc nothrow;
977     alias grpc_compression_algorithm = _Anonymous_25;
978     enum _Anonymous_25
979     {
980         GRPC_COMPRESS_NONE = 0,
981         GRPC_COMPRESS_DEFLATE = 1,
982         GRPC_COMPRESS_GZIP = 2,
983         GRPC_COMPRESS_STREAM_GZIP = 3,
984         GRPC_COMPRESS_ALGORITHMS_COUNT = 4,
985     }
986     enum GRPC_COMPRESS_NONE = _Anonymous_25.GRPC_COMPRESS_NONE;
987     enum GRPC_COMPRESS_DEFLATE = _Anonymous_25.GRPC_COMPRESS_DEFLATE;
988     enum GRPC_COMPRESS_GZIP = _Anonymous_25.GRPC_COMPRESS_GZIP;
989     enum GRPC_COMPRESS_STREAM_GZIP = _Anonymous_25.GRPC_COMPRESS_STREAM_GZIP;
990     enum GRPC_COMPRESS_ALGORITHMS_COUNT = _Anonymous_25.GRPC_COMPRESS_ALGORITHMS_COUNT;
991     alias grpc_compression_level = _Anonymous_26;
992     enum _Anonymous_26
993     {
994         GRPC_COMPRESS_LEVEL_NONE = 0,
995         GRPC_COMPRESS_LEVEL_LOW = 1,
996         GRPC_COMPRESS_LEVEL_MED = 2,
997         GRPC_COMPRESS_LEVEL_HIGH = 3,
998         GRPC_COMPRESS_LEVEL_COUNT = 4,
999     }
1000     enum GRPC_COMPRESS_LEVEL_NONE = _Anonymous_26.GRPC_COMPRESS_LEVEL_NONE;
1001     enum GRPC_COMPRESS_LEVEL_LOW = _Anonymous_26.GRPC_COMPRESS_LEVEL_LOW;
1002     enum GRPC_COMPRESS_LEVEL_MED = _Anonymous_26.GRPC_COMPRESS_LEVEL_MED;
1003     enum GRPC_COMPRESS_LEVEL_HIGH = _Anonymous_26.GRPC_COMPRESS_LEVEL_HIGH;
1004     enum GRPC_COMPRESS_LEVEL_COUNT = _Anonymous_26.GRPC_COMPRESS_LEVEL_COUNT;
1005     struct grpc_compression_options
1006     {
1007         uint enabled_algorithms_bitset;
1008         struct grpc_compression_options_default_level
1009         {
1010             int is_set;
1011             grpc_compression_level level;
1012         }
1013         grpc_compression_options_default_level default_level;
1014         struct grpc_compression_options_default_algorithm
1015         {
1016             int is_set;
1017             grpc_compression_algorithm algorithm;
1018         }
1019         grpc_compression_options_default_algorithm default_algorithm;
1020     }
1021     alias grpc_connectivity_state = _Anonymous_27;
1022     enum _Anonymous_27
1023     {
1024         GRPC_CHANNEL_IDLE = 0,
1025         GRPC_CHANNEL_CONNECTING = 1,
1026         GRPC_CHANNEL_READY = 2,
1027         GRPC_CHANNEL_TRANSIENT_FAILURE = 3,
1028         GRPC_CHANNEL_SHUTDOWN = 4,
1029     }
1030     enum GRPC_CHANNEL_IDLE = _Anonymous_27.GRPC_CHANNEL_IDLE;
1031     enum GRPC_CHANNEL_CONNECTING = _Anonymous_27.GRPC_CHANNEL_CONNECTING;
1032     enum GRPC_CHANNEL_READY = _Anonymous_27.GRPC_CHANNEL_READY;
1033     enum GRPC_CHANNEL_TRANSIENT_FAILURE = _Anonymous_27.GRPC_CHANNEL_TRANSIENT_FAILURE;
1034     enum GRPC_CHANNEL_SHUTDOWN = _Anonymous_27.GRPC_CHANNEL_SHUTDOWN;
1035     ulong strtouq(const(char)*, char**, int) @nogc nothrow;
1036     long strtoq(const(char)*, char**, int) @nogc nothrow;
1037     c_ulong strtoul(const(char)*, char**, int) @nogc nothrow;
1038     c_long strtol(const(char)*, char**, int) @nogc nothrow;
1039     real strtof64x(const(char)*, char**) @nogc nothrow;
1040     double strtof32x(const(char)*, char**) @nogc nothrow;
1041     double strtof64(const(char)*, char**) @nogc nothrow;
1042     float strtof32(const(char)*, char**) @nogc nothrow;
1043     alias gpr_clock_type = _Anonymous_28;
1044     enum _Anonymous_28
1045     {
1046         GPR_CLOCK_MONOTONIC = 0,
1047         GPR_CLOCK_REALTIME = 1,
1048         GPR_CLOCK_PRECISE = 2,
1049         GPR_TIMESPAN = 3,
1050     }
1051     enum GPR_CLOCK_MONOTONIC = _Anonymous_28.GPR_CLOCK_MONOTONIC;
1052     enum GPR_CLOCK_REALTIME = _Anonymous_28.GPR_CLOCK_REALTIME;
1053     enum GPR_CLOCK_PRECISE = _Anonymous_28.GPR_CLOCK_PRECISE;
1054     enum GPR_TIMESPAN = _Anonymous_28.GPR_TIMESPAN;
1055     struct gpr_timespec
1056     {
1057         c_long tv_sec;
1058         int tv_nsec;
1059         gpr_clock_type clock_type;
1060     }
1061     alias grpc_byte_buffer_type = _Anonymous_29;
1062     enum _Anonymous_29
1063     {
1064         GRPC_BB_RAW = 0,
1065     }
1066     enum GRPC_BB_RAW = _Anonymous_29.GRPC_BB_RAW;
1067     struct grpc_completion_queue;
1068     struct grpc_alarm;
1069     struct grpc_channel;
1070     struct grpc_server;
1071     struct grpc_call;
1072     struct grpc_socket_mutator;
1073     struct grpc_socket_factory;
1074     alias grpc_arg_type = _Anonymous_30;
1075     enum _Anonymous_30
1076     {
1077         GRPC_ARG_STRING = 0,
1078         GRPC_ARG_INTEGER = 1,
1079         GRPC_ARG_POINTER = 2,
1080     }
1081     enum GRPC_ARG_STRING = _Anonymous_30.GRPC_ARG_STRING;
1082     enum GRPC_ARG_INTEGER = _Anonymous_30.GRPC_ARG_INTEGER;
1083     enum GRPC_ARG_POINTER = _Anonymous_30.GRPC_ARG_POINTER;
1084     struct grpc_arg_pointer_vtable
1085     {
1086         void* function(void*) copy;
1087         void function(void*) destroy;
1088         int function(void*, void*) cmp;
1089     }
1090     struct grpc_arg
1091     {
1092         grpc_arg_type type;
1093         char* key;
1094         union grpc_arg_value
1095         {
1096             char* string;
1097             int integer;
1098             struct grpc_arg_pointer
1099             {
1100                 void* p;
1101                 const(grpc_arg_pointer_vtable)* vtable;
1102             }
1103             grpc_arg_pointer pointer;
1104         }
1105         grpc_arg_value value;
1106     }
1107     struct grpc_channel_args
1108     {
1109         c_ulong num_args;
1110         grpc_arg* args;
1111     }
1112     real strtold(const(char)*, char**) @nogc nothrow;
1113     float strtof(const(char)*, char**) @nogc nothrow;
1114     double strtod(const(char)*, char**) @nogc nothrow;
1115     long atoll(const(char)*) @nogc nothrow;
1116     c_long atol(const(char)*) @nogc nothrow;
1117     int atoi(const(char)*) @nogc nothrow;
1118     double atof(const(char)*) @nogc nothrow;
1119     c_ulong __ctype_get_mb_cur_max() @nogc nothrow;
1120     struct lldiv_t
1121     {
1122         long quot;
1123         long rem;
1124     }
1125     struct ldiv_t
1126     {
1127         c_long quot;
1128         c_long rem;
1129     }
1130     struct div_t
1131     {
1132         int quot;
1133         int rem;
1134     }
1135     alias uintmax_t = c_ulong;
1136     alias intmax_t = c_long;
1137     alias uintptr_t = c_ulong;
1138     alias intptr_t = c_long;
1139     alias uint_fast64_t = c_ulong;
1140     alias uint_fast32_t = c_ulong;
1141     alias uint_fast16_t = c_ulong;
1142     alias uint_fast8_t = ubyte;
1143     alias int_fast64_t = c_long;
1144     alias int_fast32_t = c_long;
1145     alias int_fast16_t = c_long;
1146     alias int_fast8_t = byte;
1147     enum grpc_call_error
1148     {
1149         GRPC_CALL_OK = 0,
1150         GRPC_CALL_ERROR = 1,
1151         GRPC_CALL_ERROR_NOT_ON_SERVER = 2,
1152         GRPC_CALL_ERROR_NOT_ON_CLIENT = 3,
1153         GRPC_CALL_ERROR_ALREADY_ACCEPTED = 4,
1154         GRPC_CALL_ERROR_ALREADY_INVOKED = 5,
1155         GRPC_CALL_ERROR_NOT_INVOKED = 6,
1156         GRPC_CALL_ERROR_ALREADY_FINISHED = 7,
1157         GRPC_CALL_ERROR_TOO_MANY_OPERATIONS = 8,
1158         GRPC_CALL_ERROR_INVALID_FLAGS = 9,
1159         GRPC_CALL_ERROR_INVALID_METADATA = 10,
1160         GRPC_CALL_ERROR_INVALID_MESSAGE = 11,
1161         GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE = 12,
1162         GRPC_CALL_ERROR_BATCH_TOO_BIG = 13,
1163         GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH = 14,
1164         GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN = 15,
1165     }
1166     enum GRPC_CALL_OK = grpc_call_error.GRPC_CALL_OK;
1167     enum GRPC_CALL_ERROR = grpc_call_error.GRPC_CALL_ERROR;
1168     enum GRPC_CALL_ERROR_NOT_ON_SERVER = grpc_call_error.GRPC_CALL_ERROR_NOT_ON_SERVER;
1169     enum GRPC_CALL_ERROR_NOT_ON_CLIENT = grpc_call_error.GRPC_CALL_ERROR_NOT_ON_CLIENT;
1170     enum GRPC_CALL_ERROR_ALREADY_ACCEPTED = grpc_call_error.GRPC_CALL_ERROR_ALREADY_ACCEPTED;
1171     enum GRPC_CALL_ERROR_ALREADY_INVOKED = grpc_call_error.GRPC_CALL_ERROR_ALREADY_INVOKED;
1172     enum GRPC_CALL_ERROR_NOT_INVOKED = grpc_call_error.GRPC_CALL_ERROR_NOT_INVOKED;
1173     enum GRPC_CALL_ERROR_ALREADY_FINISHED = grpc_call_error.GRPC_CALL_ERROR_ALREADY_FINISHED;
1174     enum GRPC_CALL_ERROR_TOO_MANY_OPERATIONS = grpc_call_error.GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
1175     enum GRPC_CALL_ERROR_INVALID_FLAGS = grpc_call_error.GRPC_CALL_ERROR_INVALID_FLAGS;
1176     enum GRPC_CALL_ERROR_INVALID_METADATA = grpc_call_error.GRPC_CALL_ERROR_INVALID_METADATA;
1177     enum GRPC_CALL_ERROR_INVALID_MESSAGE = grpc_call_error.GRPC_CALL_ERROR_INVALID_MESSAGE;
1178     enum GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE = grpc_call_error.GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
1179     enum GRPC_CALL_ERROR_BATCH_TOO_BIG = grpc_call_error.GRPC_CALL_ERROR_BATCH_TOO_BIG;
1180     enum GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH = grpc_call_error.GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH;
1181     enum GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN = grpc_call_error.GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
1182     alias uint_least64_t = c_ulong;
1183     alias uint_least32_t = uint;
1184     alias uint_least16_t = ushort;
1185     alias uint_least8_t = ubyte;
1186     alias int_least64_t = c_long;
1187     alias int_least32_t = int;
1188     alias int_least16_t = short;
1189     alias int_least8_t = byte;
1190     struct grpc_metadata
1191     {
1192         grpc_slice key;
1193         grpc_slice value;
1194         uint flags;
1195         static struct _Anonymous_31
1196         {
1197             void*[4] obfuscated;
1198         }
1199         _Anonymous_31 internal_data;
1200     }
1201     enum grpc_completion_type
1202     {
1203         GRPC_QUEUE_SHUTDOWN = 0,
1204         GRPC_QUEUE_TIMEOUT = 1,
1205         GRPC_OP_COMPLETE = 2,
1206     }
1207     enum GRPC_QUEUE_SHUTDOWN = grpc_completion_type.GRPC_QUEUE_SHUTDOWN;
1208     enum GRPC_QUEUE_TIMEOUT = grpc_completion_type.GRPC_QUEUE_TIMEOUT;
1209     enum GRPC_OP_COMPLETE = grpc_completion_type.GRPC_OP_COMPLETE;
1210     struct grpc_event
1211     {
1212         grpc_completion_type type;
1213         int success;
1214         void* tag;
1215     }
1216     struct grpc_metadata_array
1217     {
1218         c_ulong count;
1219         c_ulong capacity;
1220         grpc_metadata* metadata;
1221     }
1222     struct grpc_call_details
1223     {
1224         grpc_slice method;
1225         grpc_slice host;
1226         gpr_timespec deadline;
1227         uint flags;
1228         void* reserved;
1229     }
1230     alias grpc_op_type = _Anonymous_32;
1231     enum _Anonymous_32
1232     {
1233         GRPC_OP_SEND_INITIAL_METADATA = 0,
1234         GRPC_OP_SEND_MESSAGE = 1,
1235         GRPC_OP_SEND_CLOSE_FROM_CLIENT = 2,
1236         GRPC_OP_SEND_STATUS_FROM_SERVER = 3,
1237         GRPC_OP_RECV_INITIAL_METADATA = 4,
1238         GRPC_OP_RECV_MESSAGE = 5,
1239         GRPC_OP_RECV_STATUS_ON_CLIENT = 6,
1240         GRPC_OP_RECV_CLOSE_ON_SERVER = 7,
1241     }
1242     enum GRPC_OP_SEND_INITIAL_METADATA = _Anonymous_32.GRPC_OP_SEND_INITIAL_METADATA;
1243     enum GRPC_OP_SEND_MESSAGE = _Anonymous_32.GRPC_OP_SEND_MESSAGE;
1244     enum GRPC_OP_SEND_CLOSE_FROM_CLIENT = _Anonymous_32.GRPC_OP_SEND_CLOSE_FROM_CLIENT;
1245     enum GRPC_OP_SEND_STATUS_FROM_SERVER = _Anonymous_32.GRPC_OP_SEND_STATUS_FROM_SERVER;
1246     enum GRPC_OP_RECV_INITIAL_METADATA = _Anonymous_32.GRPC_OP_RECV_INITIAL_METADATA;
1247     enum GRPC_OP_RECV_MESSAGE = _Anonymous_32.GRPC_OP_RECV_MESSAGE;
1248     enum GRPC_OP_RECV_STATUS_ON_CLIENT = _Anonymous_32.GRPC_OP_RECV_STATUS_ON_CLIENT;
1249     enum GRPC_OP_RECV_CLOSE_ON_SERVER = _Anonymous_32.GRPC_OP_RECV_CLOSE_ON_SERVER;
1250     struct grpc_op
1251     {
1252         grpc_op_type op;
1253         uint flags;
1254         void* reserved;
1255         union grpc_op_data
1256         {
1257             static struct _Anonymous_33
1258             {
1259                 void*[8] reserved;
1260             }
1261             _Anonymous_33 reserved;
1262             struct grpc_op_send_initial_metadata
1263             {
1264                 c_ulong count;
1265                 grpc_metadata* metadata;
1266                 struct grpc_op_send_initial_metadata_maybe_compression_level
1267                 {
1268                     ubyte is_set;
1269                     grpc_compression_level level;
1270                 }
1271                 grpc_op_send_initial_metadata_maybe_compression_level maybe_compression_level;
1272             }
1273             grpc_op_send_initial_metadata send_initial_metadata;
1274             struct grpc_op_send_message
1275             {
1276                 grpc_byte_buffer* send_message;
1277             }
1278             grpc_op_send_message send_message;
1279             struct grpc_op_send_status_from_server
1280             {
1281                 c_ulong trailing_metadata_count;
1282                 grpc_metadata* trailing_metadata;
1283                 grpc_status_code status;
1284                 grpc_slice* status_details;
1285             }
1286             grpc_op_send_status_from_server send_status_from_server;
1287             struct grpc_op_recv_initial_metadata
1288             {
1289                 grpc_metadata_array* recv_initial_metadata;
1290             }
1291             grpc_op_recv_initial_metadata recv_initial_metadata;
1292             struct grpc_op_recv_message
1293             {
1294                 grpc_byte_buffer** recv_message;
1295             }
1296             grpc_op_recv_message recv_message;
1297             struct grpc_op_recv_status_on_client
1298             {
1299                 grpc_metadata_array* trailing_metadata;
1300                 grpc_status_code* status;
1301                 grpc_slice* status_details;
1302                 const(char)** error_string;
1303             }
1304             grpc_op_recv_status_on_client recv_status_on_client;
1305             struct grpc_op_recv_close_on_server
1306             {
1307                 int* cancelled;
1308             }
1309             grpc_op_recv_close_on_server recv_close_on_server;
1310         }
1311         grpc_op_data data;
1312     }
1313     struct grpc_channel_info
1314     {
1315         char** lb_policy_name;
1316         char** service_config_json;
1317     }
1318     struct grpc_resource_quota;
1319     alias grpc_cq_polling_type = _Anonymous_34;
1320     enum _Anonymous_34
1321     {
1322         GRPC_CQ_DEFAULT_POLLING = 0,
1323         GRPC_CQ_NON_LISTENING = 1,
1324         GRPC_CQ_NON_POLLING = 2,
1325     }
1326     enum GRPC_CQ_DEFAULT_POLLING = _Anonymous_34.GRPC_CQ_DEFAULT_POLLING;
1327     enum GRPC_CQ_NON_LISTENING = _Anonymous_34.GRPC_CQ_NON_LISTENING;
1328     enum GRPC_CQ_NON_POLLING = _Anonymous_34.GRPC_CQ_NON_POLLING;
1329     alias grpc_cq_completion_type = _Anonymous_35;
1330     enum _Anonymous_35
1331     {
1332         GRPC_CQ_NEXT = 0,
1333         GRPC_CQ_PLUCK = 1,
1334         GRPC_CQ_CALLBACK = 2,
1335     }
1336     enum GRPC_CQ_NEXT = _Anonymous_35.GRPC_CQ_NEXT;
1337     enum GRPC_CQ_PLUCK = _Anonymous_35.GRPC_CQ_PLUCK;
1338     enum GRPC_CQ_CALLBACK = _Anonymous_35.GRPC_CQ_CALLBACK;
1339     struct grpc_experimental_completion_queue_functor
1340     {
1341         void function(grpc_experimental_completion_queue_functor*, int) functor_run;
1342         int inlineable;
1343         int internal_success;
1344         grpc_experimental_completion_queue_functor* internal_next;
1345     }
1346     struct grpc_completion_queue_attributes
1347     {
1348         int version_;
1349         grpc_cq_completion_type cq_completion_type;
1350         grpc_cq_polling_type cq_polling_type;
1351         grpc_experimental_completion_queue_functor* cq_shutdown_cb;
1352     }
1353     struct grpc_completion_queue_factory;
1354     enum gpr_log_severity
1355     {
1356         GPR_LOG_SEVERITY_DEBUG = 0,
1357         GPR_LOG_SEVERITY_INFO = 1,
1358         GPR_LOG_SEVERITY_ERROR = 2,
1359     }
1360     enum GPR_LOG_SEVERITY_DEBUG = gpr_log_severity.GPR_LOG_SEVERITY_DEBUG;
1361     enum GPR_LOG_SEVERITY_INFO = gpr_log_severity.GPR_LOG_SEVERITY_INFO;
1362     enum GPR_LOG_SEVERITY_ERROR = gpr_log_severity.GPR_LOG_SEVERITY_ERROR;
1363     const(char)* gpr_log_severity_string(gpr_log_severity) @nogc nothrow;
1364     int sched_getaffinity(int, c_ulong, cpu_set_t*) @nogc nothrow;
1365     int sched_setaffinity(int, c_ulong, const(cpu_set_t)*) @nogc nothrow;
1366     void gpr_log(const(char)*, int, gpr_log_severity, const(char)*, ...) @nogc nothrow;
1367     int gpr_should_log(gpr_log_severity) @nogc nothrow;
1368     void gpr_log_message(const(char)*, int, gpr_log_severity, const(char)*) @nogc nothrow;
1369     void gpr_set_log_verbosity(gpr_log_severity) @nogc nothrow;
1370     void gpr_log_verbosity_init() @nogc nothrow;
1371     struct gpr_log_func_args
1372     {
1373         const(char)* file;
1374         int line;
1375         gpr_log_severity severity;
1376         const(char)* message;
1377     }
1378     alias gpr_log_func = void function(gpr_log_func_args*);
1379     void gpr_set_log_function(void function(gpr_log_func_args*)) @nogc nothrow;
1380     int sched_rr_get_interval(int, timespec*) @nogc nothrow;
1381     int sched_get_priority_min(int) @nogc nothrow;
1382     int sched_get_priority_max(int) @nogc nothrow;
1383     int sched_yield() @nogc nothrow;
1384     int sched_getscheduler(int) @nogc nothrow;
1385     int sched_setscheduler(int, int, const(sched_param)*) @nogc nothrow;
1386     int sched_getparam(int, sched_param*) @nogc nothrow;
1387     int sched_setparam(int, const(sched_param)*) @nogc nothrow;
1388     alias pid_t = int;
1389     int pthread_atfork(void function(), void function(), void function()) @nogc nothrow;
1390     int pthread_getcpuclockid(c_ulong, int*) @nogc nothrow;
1391     int pthread_setspecific(uint, const(void)*) @nogc nothrow;
1392     void* pthread_getspecific(uint) @nogc nothrow;
1393     int pthread_key_delete(uint) @nogc nothrow;
1394     int pthread_key_create(uint*, void function(void*)) @nogc nothrow;
1395     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int) @nogc nothrow;
1396     int pthread_barrierattr_getpshared(const(pthread_barrierattr_t)*, int*) @nogc nothrow;
1397     int pthread_barrierattr_destroy(pthread_barrierattr_t*) @nogc nothrow;
1398     int pthread_barrierattr_init(pthread_barrierattr_t*) @nogc nothrow;
1399     int pthread_barrier_wait(pthread_barrier_t*) @nogc nothrow;
1400     struct grpc_slice
1401     {
1402         grpc_slice_refcount* refcount;
1403         union grpc_slice_data
1404         {
1405             struct grpc_slice_refcounted
1406             {
1407                 c_ulong length;
1408                 ubyte* bytes;
1409             }
1410             grpc_slice_refcounted refcounted;
1411             struct grpc_slice_inlined
1412             {
1413                 ubyte length;
1414                 ubyte[23] bytes;
1415             }
1416             grpc_slice_inlined inlined;
1417         }
1418         grpc_slice_data data;
1419     }
1420     struct grpc_slice_refcount;
1421     int pthread_barrier_destroy(pthread_barrier_t*) @nogc nothrow;
1422     struct grpc_slice_buffer
1423     {
1424         grpc_slice* base_slices;
1425         grpc_slice* slices;
1426         c_ulong count;
1427         c_ulong capacity;
1428         c_ulong length;
1429         grpc_slice[8] inlined;
1430     }
1431     int pthread_barrier_init(pthread_barrier_t*, const(pthread_barrierattr_t)*, uint) @nogc nothrow;
1432     int pthread_spin_unlock(int*) @nogc nothrow;
1433     int pthread_spin_trylock(int*) @nogc nothrow;
1434     alias grpc_status_code = _Anonymous_36;
1435     enum _Anonymous_36
1436     {
1437         GRPC_STATUS_OK = 0,
1438         GRPC_STATUS_CANCELLED = 1,
1439         GRPC_STATUS_UNKNOWN = 2,
1440         GRPC_STATUS_INVALID_ARGUMENT = 3,
1441         GRPC_STATUS_DEADLINE_EXCEEDED = 4,
1442         GRPC_STATUS_NOT_FOUND = 5,
1443         GRPC_STATUS_ALREADY_EXISTS = 6,
1444         GRPC_STATUS_PERMISSION_DENIED = 7,
1445         GRPC_STATUS_UNAUTHENTICATED = 16,
1446         GRPC_STATUS_RESOURCE_EXHAUSTED = 8,
1447         GRPC_STATUS_FAILED_PRECONDITION = 9,
1448         GRPC_STATUS_ABORTED = 10,
1449         GRPC_STATUS_OUT_OF_RANGE = 11,
1450         GRPC_STATUS_UNIMPLEMENTED = 12,
1451         GRPC_STATUS_INTERNAL = 13,
1452         GRPC_STATUS_UNAVAILABLE = 14,
1453         GRPC_STATUS_DATA_LOSS = 15,
1454         GRPC_STATUS__DO_NOT_USE = -1,
1455     }
1456     enum GRPC_STATUS_OK = _Anonymous_36.GRPC_STATUS_OK;
1457     enum GRPC_STATUS_CANCELLED = _Anonymous_36.GRPC_STATUS_CANCELLED;
1458     enum GRPC_STATUS_UNKNOWN = _Anonymous_36.GRPC_STATUS_UNKNOWN;
1459     enum GRPC_STATUS_INVALID_ARGUMENT = _Anonymous_36.GRPC_STATUS_INVALID_ARGUMENT;
1460     enum GRPC_STATUS_DEADLINE_EXCEEDED = _Anonymous_36.GRPC_STATUS_DEADLINE_EXCEEDED;
1461     enum GRPC_STATUS_NOT_FOUND = _Anonymous_36.GRPC_STATUS_NOT_FOUND;
1462     enum GRPC_STATUS_ALREADY_EXISTS = _Anonymous_36.GRPC_STATUS_ALREADY_EXISTS;
1463     enum GRPC_STATUS_PERMISSION_DENIED = _Anonymous_36.GRPC_STATUS_PERMISSION_DENIED;
1464     enum GRPC_STATUS_UNAUTHENTICATED = _Anonymous_36.GRPC_STATUS_UNAUTHENTICATED;
1465     enum GRPC_STATUS_RESOURCE_EXHAUSTED = _Anonymous_36.GRPC_STATUS_RESOURCE_EXHAUSTED;
1466     enum GRPC_STATUS_FAILED_PRECONDITION = _Anonymous_36.GRPC_STATUS_FAILED_PRECONDITION;
1467     enum GRPC_STATUS_ABORTED = _Anonymous_36.GRPC_STATUS_ABORTED;
1468     enum GRPC_STATUS_OUT_OF_RANGE = _Anonymous_36.GRPC_STATUS_OUT_OF_RANGE;
1469     enum GRPC_STATUS_UNIMPLEMENTED = _Anonymous_36.GRPC_STATUS_UNIMPLEMENTED;
1470     enum GRPC_STATUS_INTERNAL = _Anonymous_36.GRPC_STATUS_INTERNAL;
1471     enum GRPC_STATUS_UNAVAILABLE = _Anonymous_36.GRPC_STATUS_UNAVAILABLE;
1472     enum GRPC_STATUS_DATA_LOSS = _Anonymous_36.GRPC_STATUS_DATA_LOSS;
1473     enum GRPC_STATUS__DO_NOT_USE = _Anonymous_36.GRPC_STATUS__DO_NOT_USE;
1474     int pthread_spin_lock(int*) @nogc nothrow;
1475     struct gpr_event
1476     {
1477         c_long state;
1478     }
1479     struct gpr_refcount
1480     {
1481         c_long count;
1482     }
1483     struct gpr_stats_counter
1484     {
1485         c_long value;
1486     }
1487     int pthread_spin_destroy(int*) @nogc nothrow;
1488     alias gpr_mu = pthread_mutex_t;
1489     alias gpr_cv = pthread_cond_t;
1490     alias gpr_once = int;
1491     int pthread_spin_init(int*, int) @nogc nothrow;
1492     grpc_slice grpc_slice_ref(grpc_slice) @nogc nothrow;
1493     void grpc_slice_unref(grpc_slice) @nogc nothrow;
1494     grpc_slice grpc_slice_copy(grpc_slice) @nogc nothrow;
1495     grpc_slice grpc_slice_new(void*, c_ulong, void function(void*)) @nogc nothrow;
1496     grpc_slice grpc_slice_new_with_user_data(void*, c_ulong, void function(void*), void*) @nogc nothrow;
1497     grpc_slice grpc_slice_new_with_len(void*, c_ulong, void function(void*, c_ulong)) @nogc nothrow;
1498     grpc_slice grpc_slice_malloc(c_ulong) @nogc nothrow;
1499     grpc_slice grpc_slice_malloc_large(c_ulong) @nogc nothrow;
1500     grpc_slice grpc_slice_intern(grpc_slice) @nogc nothrow;
1501     grpc_slice grpc_slice_from_copied_string(const(char)*) @nogc nothrow;
1502     grpc_slice grpc_slice_from_copied_buffer(const(char)*, c_ulong) @nogc nothrow;
1503     grpc_slice grpc_slice_from_static_string(const(char)*) @nogc nothrow;
1504     grpc_slice grpc_slice_from_static_buffer(const(void)*, c_ulong) @nogc nothrow;
1505     grpc_slice grpc_slice_sub(grpc_slice, c_ulong, c_ulong) @nogc nothrow;
1506     grpc_slice grpc_slice_sub_no_ref(grpc_slice, c_ulong, c_ulong) @nogc nothrow;
1507     grpc_slice grpc_slice_split_tail(grpc_slice*, c_ulong) @nogc nothrow;
1508     alias grpc_slice_ref_whom = _Anonymous_37;
1509     enum _Anonymous_37
1510     {
1511         GRPC_SLICE_REF_TAIL = 1,
1512         GRPC_SLICE_REF_HEAD = 2,
1513         GRPC_SLICE_REF_BOTH = 3,
1514     }
1515     enum GRPC_SLICE_REF_TAIL = _Anonymous_37.GRPC_SLICE_REF_TAIL;
1516     enum GRPC_SLICE_REF_HEAD = _Anonymous_37.GRPC_SLICE_REF_HEAD;
1517     enum GRPC_SLICE_REF_BOTH = _Anonymous_37.GRPC_SLICE_REF_BOTH;
1518     grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice*, c_ulong, grpc_slice_ref_whom) @nogc nothrow;
1519     grpc_slice grpc_slice_split_head(grpc_slice*, c_ulong) @nogc nothrow;
1520     grpc_slice grpc_empty_slice() @nogc nothrow;
1521     uint grpc_slice_default_hash_impl(grpc_slice) @nogc nothrow;
1522     int grpc_slice_default_eq_impl(grpc_slice, grpc_slice) @nogc nothrow;
1523     int grpc_slice_eq(grpc_slice, grpc_slice) @nogc nothrow;
1524     int grpc_slice_cmp(grpc_slice, grpc_slice) @nogc nothrow;
1525     int grpc_slice_str_cmp(grpc_slice, const(char)*) @nogc nothrow;
1526     int grpc_slice_buf_start_eq(grpc_slice, const(void)*, c_ulong) @nogc nothrow;
1527     int grpc_slice_rchr(grpc_slice, char) @nogc nothrow;
1528     int grpc_slice_chr(grpc_slice, char) @nogc nothrow;
1529     int grpc_slice_slice(grpc_slice, grpc_slice) @nogc nothrow;
1530     uint grpc_slice_hash(grpc_slice) @nogc nothrow;
1531     int grpc_slice_is_equivalent(grpc_slice, grpc_slice) @nogc nothrow;
1532     grpc_slice grpc_slice_dup(grpc_slice) @nogc nothrow;
1533     char* grpc_slice_to_c_string(grpc_slice) @nogc nothrow;
1534     void grpc_slice_buffer_init(grpc_slice_buffer*) @nogc nothrow;
1535     void grpc_slice_buffer_destroy(grpc_slice_buffer*) @nogc nothrow;
1536     void grpc_slice_buffer_add(grpc_slice_buffer*, grpc_slice) @nogc nothrow;
1537     c_ulong grpc_slice_buffer_add_indexed(grpc_slice_buffer*, grpc_slice) @nogc nothrow;
1538     void grpc_slice_buffer_addn(grpc_slice_buffer*, grpc_slice*, c_ulong) @nogc nothrow;
1539     ubyte* grpc_slice_buffer_tiny_add(grpc_slice_buffer*, c_ulong) @nogc nothrow;
1540     void grpc_slice_buffer_pop(grpc_slice_buffer*) @nogc nothrow;
1541     void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer*) @nogc nothrow;
1542     void grpc_slice_buffer_swap(grpc_slice_buffer*, grpc_slice_buffer*) @nogc nothrow;
1543     void grpc_slice_buffer_move_into(grpc_slice_buffer*, grpc_slice_buffer*) @nogc nothrow;
1544     void grpc_slice_buffer_trim_end(grpc_slice_buffer*, c_ulong, grpc_slice_buffer*) @nogc nothrow;
1545     void grpc_slice_buffer_move_first(grpc_slice_buffer*, c_ulong, grpc_slice_buffer*) @nogc nothrow;
1546     void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer*, c_ulong, grpc_slice_buffer*) @nogc nothrow;
1547     void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer*, c_ulong, void*) @nogc nothrow;
1548     grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer*) @nogc nothrow;
1549     void grpc_slice_buffer_undo_take_first(grpc_slice_buffer*, grpc_slice) @nogc nothrow;
1550     int pthread_condattr_setclock(pthread_condattr_t*, int) @nogc nothrow;
1551     void* gpr_malloc(c_ulong) @nogc nothrow;
1552     void* gpr_zalloc(c_ulong) @nogc nothrow;
1553     void gpr_free(void*) @nogc nothrow;
1554     void* gpr_realloc(void*, c_ulong) @nogc nothrow;
1555     void* gpr_malloc_aligned(c_ulong, c_ulong) @nogc nothrow;
1556     void gpr_free_aligned(void*) @nogc nothrow;
1557     int pthread_condattr_getclock(const(pthread_condattr_t)*, int*) @nogc nothrow;
1558     char* gpr_strdup(const(char)*) @nogc nothrow;
1559     int gpr_asprintf(char**, const(char)*, ...) @nogc nothrow;
1560     void gpr_mu_init(pthread_mutex_t*) @nogc nothrow;
1561     void gpr_mu_destroy(pthread_mutex_t*) @nogc nothrow;
1562     void gpr_mu_lock(pthread_mutex_t*) @nogc nothrow;
1563     void gpr_mu_unlock(pthread_mutex_t*) @nogc nothrow;
1564     int gpr_mu_trylock(pthread_mutex_t*) @nogc nothrow;
1565     void gpr_cv_init(pthread_cond_t*) @nogc nothrow;
1566     void gpr_cv_destroy(pthread_cond_t*) @nogc nothrow;
1567     int gpr_cv_wait(pthread_cond_t*, pthread_mutex_t*, gpr_timespec) @nogc nothrow;
1568     void gpr_cv_signal(pthread_cond_t*) @nogc nothrow;
1569     void gpr_cv_broadcast(pthread_cond_t*) @nogc nothrow;
1570     void gpr_once_init(int*, void function()) @nogc nothrow;
1571     void gpr_event_init(gpr_event*) @nogc nothrow;
1572     void gpr_event_set(gpr_event*, void*) @nogc nothrow;
1573     void* gpr_event_get(gpr_event*) @nogc nothrow;
1574     void* gpr_event_wait(gpr_event*, gpr_timespec) @nogc nothrow;
1575     void gpr_ref_init(gpr_refcount*, int) @nogc nothrow;
1576     void gpr_ref(gpr_refcount*) @nogc nothrow;
1577     void gpr_ref_non_zero(gpr_refcount*) @nogc nothrow;
1578     void gpr_refn(gpr_refcount*, int) @nogc nothrow;
1579     int gpr_unref(gpr_refcount*) @nogc nothrow;
1580     int gpr_ref_is_unique(gpr_refcount*) @nogc nothrow;
1581     void gpr_stats_init(gpr_stats_counter*, c_long) @nogc nothrow;
1582     void gpr_stats_inc(gpr_stats_counter*, c_long) @nogc nothrow;
1583     c_long gpr_stats_read(const(gpr_stats_counter)*) @nogc nothrow;
1584     alias gpr_thd_id = c_ulong;
1585     c_ulong gpr_thd_currentid() @nogc nothrow;
1586     gpr_timespec gpr_time_0(gpr_clock_type) @nogc nothrow;
1587     gpr_timespec gpr_inf_future(gpr_clock_type) @nogc nothrow;
1588     gpr_timespec gpr_inf_past(gpr_clock_type) @nogc nothrow;
1589     int pthread_condattr_setpshared(pthread_condattr_t*, int) @nogc nothrow;
1590     int pthread_condattr_getpshared(const(pthread_condattr_t)*, int*) @nogc nothrow;
1591     void gpr_time_init() @nogc nothrow;
1592     gpr_timespec gpr_now(gpr_clock_type) @nogc nothrow;
1593     gpr_timespec gpr_convert_clock_type(gpr_timespec, gpr_clock_type) @nogc nothrow;
1594     int gpr_time_cmp(gpr_timespec, gpr_timespec) @nogc nothrow;
1595     gpr_timespec gpr_time_max(gpr_timespec, gpr_timespec) @nogc nothrow;
1596     gpr_timespec gpr_time_min(gpr_timespec, gpr_timespec) @nogc nothrow;
1597     gpr_timespec gpr_time_add(gpr_timespec, gpr_timespec) @nogc nothrow;
1598     gpr_timespec gpr_time_sub(gpr_timespec, gpr_timespec) @nogc nothrow;
1599     gpr_timespec gpr_time_from_micros(c_long, gpr_clock_type) @nogc nothrow;
1600     gpr_timespec gpr_time_from_nanos(c_long, gpr_clock_type) @nogc nothrow;
1601     gpr_timespec gpr_time_from_millis(c_long, gpr_clock_type) @nogc nothrow;
1602     gpr_timespec gpr_time_from_seconds(c_long, gpr_clock_type) @nogc nothrow;
1603     gpr_timespec gpr_time_from_minutes(c_long, gpr_clock_type) @nogc nothrow;
1604     gpr_timespec gpr_time_from_hours(c_long, gpr_clock_type) @nogc nothrow;
1605     int gpr_time_to_millis(gpr_timespec) @nogc nothrow;
1606     int gpr_time_similar(gpr_timespec, gpr_timespec, gpr_timespec) @nogc nothrow;
1607     void gpr_sleep_until(gpr_timespec) @nogc nothrow;
1608     double gpr_timespec_to_micros(gpr_timespec) @nogc nothrow;
1609     int pthread_condattr_destroy(pthread_condattr_t*) @nogc nothrow;
1610     enum _Anonymous_38
1611     {
1612         PTHREAD_CREATE_JOINABLE = 0,
1613         PTHREAD_CREATE_DETACHED = 1,
1614     }
1615     enum PTHREAD_CREATE_JOINABLE = _Anonymous_38.PTHREAD_CREATE_JOINABLE;
1616     enum PTHREAD_CREATE_DETACHED = _Anonymous_38.PTHREAD_CREATE_DETACHED;
1617     int pthread_condattr_init(pthread_condattr_t*) @nogc nothrow;
1618     enum _Anonymous_39
1619     {
1620         PTHREAD_MUTEX_TIMED_NP = 0,
1621         PTHREAD_MUTEX_RECURSIVE_NP = 1,
1622         PTHREAD_MUTEX_ERRORCHECK_NP = 2,
1623         PTHREAD_MUTEX_ADAPTIVE_NP = 3,
1624         PTHREAD_MUTEX_NORMAL = 0,
1625         PTHREAD_MUTEX_RECURSIVE = 1,
1626         PTHREAD_MUTEX_ERRORCHECK = 2,
1627         PTHREAD_MUTEX_DEFAULT = 0,
1628         PTHREAD_MUTEX_FAST_NP = 0,
1629     }
1630     enum PTHREAD_MUTEX_TIMED_NP = _Anonymous_39.PTHREAD_MUTEX_TIMED_NP;
1631     enum PTHREAD_MUTEX_RECURSIVE_NP = _Anonymous_39.PTHREAD_MUTEX_RECURSIVE_NP;
1632     enum PTHREAD_MUTEX_ERRORCHECK_NP = _Anonymous_39.PTHREAD_MUTEX_ERRORCHECK_NP;
1633     enum PTHREAD_MUTEX_ADAPTIVE_NP = _Anonymous_39.PTHREAD_MUTEX_ADAPTIVE_NP;
1634     enum PTHREAD_MUTEX_NORMAL = _Anonymous_39.PTHREAD_MUTEX_NORMAL;
1635     enum PTHREAD_MUTEX_RECURSIVE = _Anonymous_39.PTHREAD_MUTEX_RECURSIVE;
1636     enum PTHREAD_MUTEX_ERRORCHECK = _Anonymous_39.PTHREAD_MUTEX_ERRORCHECK;
1637     enum PTHREAD_MUTEX_DEFAULT = _Anonymous_39.PTHREAD_MUTEX_DEFAULT;
1638     enum PTHREAD_MUTEX_FAST_NP = _Anonymous_39.PTHREAD_MUTEX_FAST_NP;
1639     enum _Anonymous_40
1640     {
1641         PTHREAD_MUTEX_STALLED = 0,
1642         PTHREAD_MUTEX_STALLED_NP = 0,
1643         PTHREAD_MUTEX_ROBUST = 1,
1644         PTHREAD_MUTEX_ROBUST_NP = 1,
1645     }
1646     enum PTHREAD_MUTEX_STALLED = _Anonymous_40.PTHREAD_MUTEX_STALLED;
1647     enum PTHREAD_MUTEX_STALLED_NP = _Anonymous_40.PTHREAD_MUTEX_STALLED_NP;
1648     enum PTHREAD_MUTEX_ROBUST = _Anonymous_40.PTHREAD_MUTEX_ROBUST;
1649     enum PTHREAD_MUTEX_ROBUST_NP = _Anonymous_40.PTHREAD_MUTEX_ROBUST_NP;
1650     enum _Anonymous_41
1651     {
1652         PTHREAD_PRIO_NONE = 0,
1653         PTHREAD_PRIO_INHERIT = 1,
1654         PTHREAD_PRIO_PROTECT = 2,
1655     }
1656     enum PTHREAD_PRIO_NONE = _Anonymous_41.PTHREAD_PRIO_NONE;
1657     enum PTHREAD_PRIO_INHERIT = _Anonymous_41.PTHREAD_PRIO_INHERIT;
1658     enum PTHREAD_PRIO_PROTECT = _Anonymous_41.PTHREAD_PRIO_PROTECT;
1659     int pthread_cond_clockwait(pthread_cond_t*, pthread_mutex_t*, int, const(timespec)*) @nogc nothrow;
1660     int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, const(timespec)*) @nogc nothrow;
1661     enum _Anonymous_42
1662     {
1663         PTHREAD_RWLOCK_PREFER_READER_NP = 0,
1664         PTHREAD_RWLOCK_PREFER_WRITER_NP = 1,
1665         PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP = 2,
1666         PTHREAD_RWLOCK_DEFAULT_NP = 0,
1667     }
1668     enum PTHREAD_RWLOCK_PREFER_READER_NP = _Anonymous_42.PTHREAD_RWLOCK_PREFER_READER_NP;
1669     enum PTHREAD_RWLOCK_PREFER_WRITER_NP = _Anonymous_42.PTHREAD_RWLOCK_PREFER_WRITER_NP;
1670     enum PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP = _Anonymous_42.PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP;
1671     enum PTHREAD_RWLOCK_DEFAULT_NP = _Anonymous_42.PTHREAD_RWLOCK_DEFAULT_NP;
1672     int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*) @nogc nothrow;
1673     enum _Anonymous_43
1674     {
1675         PTHREAD_INHERIT_SCHED = 0,
1676         PTHREAD_EXPLICIT_SCHED = 1,
1677     }
1678     enum PTHREAD_INHERIT_SCHED = _Anonymous_43.PTHREAD_INHERIT_SCHED;
1679     enum PTHREAD_EXPLICIT_SCHED = _Anonymous_43.PTHREAD_EXPLICIT_SCHED;
1680     enum _Anonymous_44
1681     {
1682         PTHREAD_SCOPE_SYSTEM = 0,
1683         PTHREAD_SCOPE_PROCESS = 1,
1684     }
1685     enum PTHREAD_SCOPE_SYSTEM = _Anonymous_44.PTHREAD_SCOPE_SYSTEM;
1686     enum PTHREAD_SCOPE_PROCESS = _Anonymous_44.PTHREAD_SCOPE_PROCESS;
1687     int pthread_cond_broadcast(pthread_cond_t*) @nogc nothrow;
1688     enum _Anonymous_45
1689     {
1690         PTHREAD_PROCESS_PRIVATE = 0,
1691         PTHREAD_PROCESS_SHARED = 1,
1692     }
1693     enum PTHREAD_PROCESS_PRIVATE = _Anonymous_45.PTHREAD_PROCESS_PRIVATE;
1694     enum PTHREAD_PROCESS_SHARED = _Anonymous_45.PTHREAD_PROCESS_SHARED;
1695     int pthread_cond_signal(pthread_cond_t*) @nogc nothrow;
1696     struct _pthread_cleanup_buffer
1697     {
1698         void function(void*) __routine;
1699         void* __arg;
1700         int __canceltype;
1701         _pthread_cleanup_buffer* __prev;
1702     }
1703     enum _Anonymous_46
1704     {
1705         PTHREAD_CANCEL_ENABLE = 0,
1706         PTHREAD_CANCEL_DISABLE = 1,
1707     }
1708     enum PTHREAD_CANCEL_ENABLE = _Anonymous_46.PTHREAD_CANCEL_ENABLE;
1709     enum PTHREAD_CANCEL_DISABLE = _Anonymous_46.PTHREAD_CANCEL_DISABLE;
1710     int pthread_cond_destroy(pthread_cond_t*) @nogc nothrow;
1711     enum _Anonymous_47
1712     {
1713         PTHREAD_CANCEL_DEFERRED = 0,
1714         PTHREAD_CANCEL_ASYNCHRONOUS = 1,
1715     }
1716     enum PTHREAD_CANCEL_DEFERRED = _Anonymous_47.PTHREAD_CANCEL_DEFERRED;
1717     enum PTHREAD_CANCEL_ASYNCHRONOUS = _Anonymous_47.PTHREAD_CANCEL_ASYNCHRONOUS;
1718     int pthread_cond_init(pthread_cond_t*, const(pthread_condattr_t)*) @nogc nothrow;
1719     int pthread_create(c_ulong*, const(pthread_attr_t)*, void* function(void*), void*) @nogc nothrow;
1720     void pthread_exit(void*) @nogc nothrow;
1721     int pthread_join(c_ulong, void**) @nogc nothrow;
1722     int pthread_tryjoin_np(c_ulong, void**) @nogc nothrow;
1723     int pthread_timedjoin_np(c_ulong, void**, const(timespec)*) @nogc nothrow;
1724     int pthread_clockjoin_np(c_ulong, void**, int, const(timespec)*) @nogc nothrow;
1725     int pthread_detach(c_ulong) @nogc nothrow;
1726     c_ulong pthread_self() @nogc nothrow;
1727     int pthread_equal(c_ulong, c_ulong) @nogc nothrow;
1728     int pthread_attr_init(pthread_attr_t*) @nogc nothrow;
1729     int pthread_attr_destroy(pthread_attr_t*) @nogc nothrow;
1730     int pthread_attr_getdetachstate(const(pthread_attr_t)*, int*) @nogc nothrow;
1731     int pthread_attr_setdetachstate(pthread_attr_t*, int) @nogc nothrow;
1732     int pthread_attr_getguardsize(const(pthread_attr_t)*, c_ulong*) @nogc nothrow;
1733     int pthread_attr_setguardsize(pthread_attr_t*, c_ulong) @nogc nothrow;
1734     int pthread_attr_getschedparam(const(pthread_attr_t)*, sched_param*) @nogc nothrow;
1735     int pthread_attr_setschedparam(pthread_attr_t*, const(sched_param)*) @nogc nothrow;
1736     int pthread_attr_getschedpolicy(const(pthread_attr_t)*, int*) @nogc nothrow;
1737     int pthread_attr_setschedpolicy(pthread_attr_t*, int) @nogc nothrow;
1738     int pthread_attr_getinheritsched(const(pthread_attr_t)*, int*) @nogc nothrow;
1739     int pthread_attr_setinheritsched(pthread_attr_t*, int) @nogc nothrow;
1740     int pthread_attr_getscope(const(pthread_attr_t)*, int*) @nogc nothrow;
1741     int pthread_attr_setscope(pthread_attr_t*, int) @nogc nothrow;
1742     int pthread_attr_getstackaddr(const(pthread_attr_t)*, void**) @nogc nothrow;
1743     int pthread_attr_setstackaddr(pthread_attr_t*, void*) @nogc nothrow;
1744     int pthread_attr_getstacksize(const(pthread_attr_t)*, c_ulong*) @nogc nothrow;
1745     int pthread_attr_setstacksize(pthread_attr_t*, c_ulong) @nogc nothrow;
1746     int pthread_attr_getstack(const(pthread_attr_t)*, void**, c_ulong*) @nogc nothrow;
1747     int pthread_attr_setstack(pthread_attr_t*, void*, c_ulong) @nogc nothrow;
1748     int pthread_attr_setaffinity_np(pthread_attr_t*, c_ulong, const(cpu_set_t)*) @nogc nothrow;
1749     int pthread_attr_getaffinity_np(const(pthread_attr_t)*, c_ulong, cpu_set_t*) @nogc nothrow;
1750     int pthread_getattr_default_np(pthread_attr_t*) @nogc nothrow;
1751     int pthread_setattr_default_np(const(pthread_attr_t)*) @nogc nothrow;
1752     int pthread_getattr_np(c_ulong, pthread_attr_t*) @nogc nothrow;
1753     int pthread_setschedparam(c_ulong, int, const(sched_param)*) @nogc nothrow;
1754     int pthread_getschedparam(c_ulong, int*, sched_param*) @nogc nothrow;
1755     int pthread_setschedprio(c_ulong, int) @nogc nothrow;
1756     int pthread_getname_np(c_ulong, char*, c_ulong) @nogc nothrow;
1757     int pthread_setname_np(c_ulong, const(char)*) @nogc nothrow;
1758     int pthread_getconcurrency() @nogc nothrow;
1759     int pthread_setconcurrency(int) @nogc nothrow;
1760     int pthread_yield() @nogc nothrow;
1761     int pthread_setaffinity_np(c_ulong, c_ulong, const(cpu_set_t)*) @nogc nothrow;
1762     int pthread_getaffinity_np(c_ulong, c_ulong, cpu_set_t*) @nogc nothrow;
1763     int pthread_once(int*, void function()) @nogc nothrow;
1764     int pthread_setcancelstate(int, int*) @nogc nothrow;
1765     int pthread_setcanceltype(int, int*) @nogc nothrow;
1766     int pthread_cancel(c_ulong) @nogc nothrow;
1767     void pthread_testcancel() @nogc nothrow;
1768     struct __pthread_unwind_buf_t
1769     {
1770         static struct _Anonymous_48
1771         {
1772             c_long[8] __cancel_jmp_buf;
1773             int __mask_was_saved;
1774         }
1775         _Anonymous_48[1] __cancel_jmp_buf;
1776         void*[4] __pad;
1777     }
1778     int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t*, int) @nogc nothrow;
1779     struct __pthread_cleanup_frame
1780     {
1781         void function(void*) __cancel_routine;
1782         void* __cancel_arg;
1783         int __do_it;
1784         int __cancel_type;
1785     }
1786     void __pthread_register_cancel(__pthread_unwind_buf_t*) @nogc nothrow;
1787     void __pthread_unregister_cancel(__pthread_unwind_buf_t*) @nogc nothrow;
1788     int pthread_rwlockattr_getkind_np(const(pthread_rwlockattr_t)*, int*) @nogc nothrow;
1789     void __pthread_register_cancel_defer(__pthread_unwind_buf_t*) @nogc nothrow;
1790     void __pthread_unregister_cancel_restore(__pthread_unwind_buf_t*) @nogc nothrow;
1791     void __pthread_unwind_next(__pthread_unwind_buf_t*) @nogc nothrow;
1792     struct __jmp_buf_tag;
1793     int __sigsetjmp(__jmp_buf_tag*, int) @nogc nothrow;
1794     int pthread_mutex_init(pthread_mutex_t*, const(pthread_mutexattr_t)*) @nogc nothrow;
1795     int pthread_mutex_destroy(pthread_mutex_t*) @nogc nothrow;
1796     int pthread_mutex_trylock(pthread_mutex_t*) @nogc nothrow;
1797     int pthread_mutex_lock(pthread_mutex_t*) @nogc nothrow;
1798     int pthread_mutex_timedlock(pthread_mutex_t*, const(timespec)*) @nogc nothrow;
1799     int pthread_mutex_clocklock(pthread_mutex_t*, int, const(timespec)*) @nogc nothrow;
1800     int pthread_mutex_unlock(pthread_mutex_t*) @nogc nothrow;
1801     int pthread_mutex_getprioceiling(const(pthread_mutex_t)*, int*) @nogc nothrow;
1802     int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*) @nogc nothrow;
1803     int pthread_mutex_consistent(pthread_mutex_t*) @nogc nothrow;
1804     int pthread_mutex_consistent_np(pthread_mutex_t*) @nogc nothrow;
1805     int pthread_mutexattr_init(pthread_mutexattr_t*) @nogc nothrow;
1806     int pthread_mutexattr_destroy(pthread_mutexattr_t*) @nogc nothrow;
1807     int pthread_mutexattr_getpshared(const(pthread_mutexattr_t)*, int*) @nogc nothrow;
1808     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int) @nogc nothrow;
1809     int pthread_mutexattr_gettype(const(pthread_mutexattr_t)*, int*) @nogc nothrow;
1810     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @nogc nothrow;
1811     int pthread_mutexattr_getprotocol(const(pthread_mutexattr_t)*, int*) @nogc nothrow;
1812     int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int) @nogc nothrow;
1813     int pthread_mutexattr_getprioceiling(const(pthread_mutexattr_t)*, int*) @nogc nothrow;
1814     int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int) @nogc nothrow;
1815     int pthread_mutexattr_getrobust(const(pthread_mutexattr_t)*, int*) @nogc nothrow;
1816     int pthread_mutexattr_getrobust_np(const(pthread_mutexattr_t)*, int*) @nogc nothrow;
1817     int pthread_mutexattr_setrobust(pthread_mutexattr_t*, int) @nogc nothrow;
1818     int pthread_mutexattr_setrobust_np(pthread_mutexattr_t*, int) @nogc nothrow;
1819     int pthread_rwlock_init(pthread_rwlock_t*, const(pthread_rwlockattr_t)*) @nogc nothrow;
1820     int pthread_rwlock_destroy(pthread_rwlock_t*) @nogc nothrow;
1821     int pthread_rwlock_rdlock(pthread_rwlock_t*) @nogc nothrow;
1822     int pthread_rwlock_tryrdlock(pthread_rwlock_t*) @nogc nothrow;
1823     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const(timespec)*) @nogc nothrow;
1824     int pthread_rwlock_clockrdlock(pthread_rwlock_t*, int, const(timespec)*) @nogc nothrow;
1825     int pthread_rwlock_wrlock(pthread_rwlock_t*) @nogc nothrow;
1826     int pthread_rwlock_trywrlock(pthread_rwlock_t*) @nogc nothrow;
1827     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const(timespec)*) @nogc nothrow;
1828     int pthread_rwlock_clockwrlock(pthread_rwlock_t*, int, const(timespec)*) @nogc nothrow;
1829     int pthread_rwlock_unlock(pthread_rwlock_t*) @nogc nothrow;
1830     int pthread_rwlockattr_init(pthread_rwlockattr_t*) @nogc nothrow;
1831     int pthread_rwlockattr_destroy(pthread_rwlockattr_t*) @nogc nothrow;
1832     int pthread_rwlockattr_getpshared(const(pthread_rwlockattr_t)*, int*) @nogc nothrow;
1833     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int) @nogc nothrow;
1834     static if(!is(typeof(PTHREAD_ONCE_INIT))) {
1835         enum PTHREAD_ONCE_INIT = 0;
1836     }
1837     static if(!is(typeof(_PTHREAD_H))) {
1838         enum _PTHREAD_H = 1;
1839     }
1840 
1841 
1842 
1843 
1844 
1845 
1846     static if(!is(typeof(LINUX_VERSION_CODE))) {
1847         enum LINUX_VERSION_CODE = 328721;
1848     }
1849 
1850 
1851 
1852 
1853     static if(!is(typeof(GPR_US_PER_MS))) {
1854         enum GPR_US_PER_MS = 1000;
1855     }
1856 
1857 
1858 
1859 
1860     static if(!is(typeof(GPR_NS_PER_US))) {
1861         enum GPR_NS_PER_US = 1000;
1862     }
1863 
1864 
1865 
1866 
1867     static if(!is(typeof(GPR_NS_PER_MS))) {
1868         enum GPR_NS_PER_MS = 1000000;
1869     }
1870 
1871 
1872 
1873 
1874     static if(!is(typeof(GPR_NS_PER_SEC))) {
1875         enum GPR_NS_PER_SEC = 1000000000;
1876     }
1877 
1878 
1879 
1880 
1881     static if(!is(typeof(GPR_US_PER_SEC))) {
1882         enum GPR_US_PER_SEC = 1000000;
1883     }
1884 
1885 
1886 
1887 
1888     static if(!is(typeof(GPR_MS_PER_SEC))) {
1889         enum GPR_MS_PER_SEC = 1000;
1890     }
1891     static if(!is(typeof(GRPC_SLICE_BUFFER_INLINE_ELEMENTS))) {
1892         enum GRPC_SLICE_BUFFER_INLINE_ELEMENTS = 8;
1893     }
1894     static if(!is(typeof(GRPC_ALLOW_EXCEPTIONS))) {
1895         enum GRPC_ALLOW_EXCEPTIONS = 0;
1896     }
1897 
1898 
1899 
1900 
1901 
1902 
1903     static if(!is(typeof(GPR_HAS_ATTRIBUTE_WEAK))) {
1904         enum GPR_HAS_ATTRIBUTE_WEAK = 1;
1905     }
1906 
1907 
1908 
1909 
1910 
1911 
1912     static if(!is(typeof(GPR_HAS_ATTRIBUTE_NOINLINE))) {
1913         enum GPR_HAS_ATTRIBUTE_NOINLINE = 1;
1914     }
1915     static if(!is(typeof(GRPC_IF_NAMETOINDEX))) {
1916         enum GRPC_IF_NAMETOINDEX = 1;
1917     }
1918 
1919 
1920 
1921 
1922     static if(!is(typeof(GRPC_ARES))) {
1923         enum GRPC_ARES = 1;
1924     }
1925 
1926 
1927 
1928 
1929     static if(!is(typeof(GPR_MAX_ALIGNMENT))) {
1930         enum GPR_MAX_ALIGNMENT = 16;
1931     }
1932 
1933 
1934 
1935 
1936 
1937 
1938     static if(!is(typeof(GPR_CACHELINE_SIZE_LOG))) {
1939         enum GPR_CACHELINE_SIZE_LOG = 6;
1940     }
1941 
1942 
1943 
1944 
1945     static if(!is(typeof(_SCHED_H))) {
1946         enum _SCHED_H = 1;
1947     }
1948 
1949 
1950 
1951 
1952     static if(!is(typeof(GPR_CYCLE_COUNTER_FALLBACK))) {
1953         enum GPR_CYCLE_COUNTER_FALLBACK = 1;
1954     }
1955     static if(!is(typeof(GPR_LINUX_PTHREAD_NAME))) {
1956         enum GPR_LINUX_PTHREAD_NAME = 1;
1957     }
1958 
1959 
1960 
1961 
1962     static if(!is(typeof(GPR_POSIX_CRASH_HANDLER))) {
1963         enum GPR_POSIX_CRASH_HANDLER = 1;
1964     }
1965 
1966 
1967 
1968 
1969     static if(!is(typeof(GPR_ARCH_64))) {
1970         enum GPR_ARCH_64 = 1;
1971     }
1972 
1973 
1974 
1975 
1976     static if(!is(typeof(GPR_GETPID_IN_UNISTD_H))) {
1977         enum GPR_GETPID_IN_UNISTD_H = 1;
1978     }
1979 
1980 
1981 
1982 
1983     static if(!is(typeof(GPR_HAS_PTHREAD_H))) {
1984         enum GPR_HAS_PTHREAD_H = 1;
1985     }
1986 
1987 
1988 
1989 
1990 
1991 
1992     static if(!is(typeof(GPR_POSIX_TIME))) {
1993         enum GPR_POSIX_TIME = 1;
1994     }
1995 
1996 
1997 
1998 
1999     static if(!is(typeof(GPR_POSIX_SYNC))) {
2000         enum GPR_POSIX_SYNC = 1;
2001     }
2002     static if(!is(typeof(GPR_POSIX_SUBPROCESS))) {
2003         enum GPR_POSIX_SUBPROCESS = 1;
2004     }
2005 
2006 
2007 
2008 
2009     static if(!is(typeof(GPR_POSIX_STRING))) {
2010         enum GPR_POSIX_STRING = 1;
2011     }
2012 
2013 
2014 
2015 
2016     static if(!is(typeof(GPR_POSIX_TMPFILE))) {
2017         enum GPR_POSIX_TMPFILE = 1;
2018     }
2019 
2020 
2021 
2022 
2023     static if(!is(typeof(GPR_LINUX_ENV))) {
2024         enum GPR_LINUX_ENV = 1;
2025     }
2026 
2027 
2028 
2029 
2030     static if(!is(typeof(GPR_SUPPORT_CHANNELS_FROM_FD))) {
2031         enum GPR_SUPPORT_CHANNELS_FROM_FD = 1;
2032     }
2033 
2034 
2035 
2036 
2037 
2038 
2039     static if(!is(typeof(GPR_LINUX))) {
2040         enum GPR_LINUX = 1;
2041     }
2042 
2043 
2044 
2045 
2046     static if(!is(typeof(GPR_GCC_TLS))) {
2047         enum GPR_GCC_TLS = 1;
2048     }
2049 
2050 
2051 
2052 
2053     static if(!is(typeof(GPR_GCC_ATOMIC))) {
2054         enum GPR_GCC_ATOMIC = 1;
2055     }
2056 
2057 
2058 
2059 
2060     static if(!is(typeof(GPR_CPU_LINUX))) {
2061         enum GPR_CPU_LINUX = 1;
2062     }
2063     static if(!is(typeof(GPR_PLATFORM_STRING))) {
2064         enum GPR_PLATFORM_STRING = "linux";
2065     }
2066 
2067 
2068 
2069 
2070     static if(!is(typeof(GRPC_USE_ABSL))) {
2071         enum GRPC_USE_ABSL = 1;
2072     }
2073     static if(!is(typeof(_STDC_PREDEF_H))) {
2074         enum _STDC_PREDEF_H = 1;
2075     }
2076 
2077 
2078 
2079 
2080     static if(!is(typeof(_STDINT_H))) {
2081         enum _STDINT_H = 1;
2082     }
2083 
2084 
2085 
2086 
2087 
2088 
2089     static if(!is(typeof(GRPC_CQ_VERSION_MINIMUM_FOR_CALLBACKABLE))) {
2090         enum GRPC_CQ_VERSION_MINIMUM_FOR_CALLBACKABLE = 2;
2091     }
2092 
2093 
2094 
2095 
2096     static if(!is(typeof(GRPC_CQ_CURRENT_VERSION))) {
2097         enum GRPC_CQ_CURRENT_VERSION = 2;
2098     }
2099     static if(!is(typeof(GRPC_ARG_CHANNEL_ID))) {
2100         enum GRPC_ARG_CHANNEL_ID = "grpc.channel_id";
2101     }
2102 
2103 
2104 
2105 
2106     static if(!is(typeof(GRPC_ARG_CHANNEL_POOL_DOMAIN))) {
2107         enum GRPC_ARG_CHANNEL_POOL_DOMAIN = "grpc.channel_pooling_domain";
2108     }
2109 
2110 
2111 
2112 
2113     static if(!is(typeof(GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL))) {
2114         enum GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL = "grpc.use_local_subchannel_pool";
2115     }
2116 
2117 
2118 
2119 
2120     static if(!is(typeof(GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS))) {
2121         enum GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS = "grpc.dns_ares_query_timeout";
2122     }
2123 
2124 
2125 
2126 
2127     static if(!is(typeof(GRPC_ARG_DNS_ENABLE_SRV_QUERIES))) {
2128         enum GRPC_ARG_DNS_ENABLE_SRV_QUERIES = "grpc.dns_enable_srv_queries";
2129     }
2130 
2131 
2132 
2133 
2134     static if(!is(typeof(GRPC_ARG_INHIBIT_HEALTH_CHECKING))) {
2135         enum GRPC_ARG_INHIBIT_HEALTH_CHECKING = "grpc.inhibit_health_checking";
2136     }
2137 
2138 
2139 
2140 
2141     static if(!is(typeof(GRPC_ARG_SURFACE_USER_AGENT))) {
2142         enum GRPC_ARG_SURFACE_USER_AGENT = "grpc.surface_user_agent";
2143     }
2144 
2145 
2146 
2147 
2148     static if(!is(typeof(GRPC_ARG_ENABLE_HTTP_PROXY))) {
2149         enum GRPC_ARG_ENABLE_HTTP_PROXY = "grpc.enable_http_proxy";
2150     }
2151 
2152 
2153 
2154 
2155     static if(!is(typeof(GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER))) {
2156         enum GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER = "grpc.disable_client_authority_filter";
2157     }
2158 
2159 
2160 
2161 
2162     static if(!is(typeof(GRPC_ARG_MOBILE_LOG_CONTEXT))) {
2163         enum GRPC_ARG_MOBILE_LOG_CONTEXT = "grpc.mobile_log_context";
2164     }
2165 
2166 
2167 
2168 
2169     static if(!is(typeof(GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE))) {
2170         enum GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE = "grpc.per_rpc_retry_buffer_size";
2171     }
2172 
2173 
2174 
2175 
2176     static if(!is(typeof(GRPC_ARG_ENABLE_RETRIES))) {
2177         enum GRPC_ARG_ENABLE_RETRIES = "grpc.enable_retries";
2178     }
2179 
2180 
2181 
2182 
2183 
2184 
2185     static if(!is(typeof(GRPC_ARG_OPTIMIZATION_TARGET))) {
2186         enum GRPC_ARG_OPTIMIZATION_TARGET = "grpc.optimization_target";
2187     }
2188 
2189 
2190 
2191 
2192     static if(!is(typeof(GRPC_ARG_WORKAROUND_CRONET_COMPRESSION))) {
2193         enum GRPC_ARG_WORKAROUND_CRONET_COMPRESSION = "grpc.workaround.cronet_compression";
2194     }
2195 
2196 
2197 
2198 
2199     static if(!is(typeof(GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS))) {
2200         enum GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS = "grpc.xds_resource_does_not_exist_timeout_ms";
2201     }
2202 
2203 
2204 
2205 
2206     static if(!is(typeof(GRPC_ARG_XDS_FAILOVER_TIMEOUT_MS))) {
2207         enum GRPC_ARG_XDS_FAILOVER_TIMEOUT_MS = "grpc.xds_failover_timeout_ms";
2208     }
2209     static if(!is(typeof(GRPC_ARG_LOCALITY_RETENTION_INTERVAL_MS))) {
2210         enum GRPC_ARG_LOCALITY_RETENTION_INTERVAL_MS = "grpc.xds_locality_retention_interval_ms";
2211     }
2212     static if(!is(typeof(GRPC_ARG_XDS_FALLBACK_TIMEOUT_MS))) {
2213         enum GRPC_ARG_XDS_FALLBACK_TIMEOUT_MS = "grpc.xds_fallback_timeout_ms";
2214     }
2215     static if(!is(typeof(GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS))) {
2216         enum GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS = "grpc.grpclb_fallback_timeout_ms";
2217     }
2218     static if(!is(typeof(GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS))) {
2219         enum GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS = "grpc.grpclb_call_timeout_ms";
2220     }
2221     static if(!is(typeof(GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS))) {
2222         enum GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS = "grpc.experimental.tcp_tx_zerocopy_max_simultaneous_sends";
2223     }
2224     static if(!is(typeof(GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD))) {
2225         enum GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD = "grpc.experimental.tcp_tx_zerocopy_send_bytes_threshold";
2226     }
2227     static if(!is(typeof(GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED))) {
2228         enum GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED = "grpc.experimental.tcp_tx_zerocopy_enabled";
2229     }
2230     static if(!is(typeof(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE))) {
2231         enum GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE = "grpc.experimental.tcp_max_read_chunk_size";
2232     }
2233 
2234 
2235 
2236 
2237 
2238 
2239     static if(!is(typeof(GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE))) {
2240         enum GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE = "grpc.experimental.tcp_min_read_chunk_size";
2241     }
2242     static if(!is(typeof(GRPC_TCP_DEFAULT_READ_SLICE_SIZE))) {
2243         enum GRPC_TCP_DEFAULT_READ_SLICE_SIZE = 8192;
2244     }
2245 
2246 
2247 
2248 
2249     static if(!is(typeof(INT8_WIDTH))) {
2250         enum INT8_WIDTH = 8;
2251     }
2252 
2253 
2254 
2255 
2256     static if(!is(typeof(UINT8_WIDTH))) {
2257         enum UINT8_WIDTH = 8;
2258     }
2259 
2260 
2261 
2262 
2263     static if(!is(typeof(INT16_WIDTH))) {
2264         enum INT16_WIDTH = 16;
2265     }
2266 
2267 
2268 
2269 
2270     static if(!is(typeof(UINT16_WIDTH))) {
2271         enum UINT16_WIDTH = 16;
2272     }
2273 
2274 
2275 
2276 
2277     static if(!is(typeof(INT32_WIDTH))) {
2278         enum INT32_WIDTH = 32;
2279     }
2280 
2281 
2282 
2283 
2284     static if(!is(typeof(UINT32_WIDTH))) {
2285         enum UINT32_WIDTH = 32;
2286     }
2287 
2288 
2289 
2290 
2291     static if(!is(typeof(INT64_WIDTH))) {
2292         enum INT64_WIDTH = 64;
2293     }
2294 
2295 
2296 
2297 
2298     static if(!is(typeof(UINT64_WIDTH))) {
2299         enum UINT64_WIDTH = 64;
2300     }
2301 
2302 
2303 
2304 
2305     static if(!is(typeof(INT_LEAST8_WIDTH))) {
2306         enum INT_LEAST8_WIDTH = 8;
2307     }
2308 
2309 
2310 
2311 
2312     static if(!is(typeof(UINT_LEAST8_WIDTH))) {
2313         enum UINT_LEAST8_WIDTH = 8;
2314     }
2315 
2316 
2317 
2318 
2319     static if(!is(typeof(INT_LEAST16_WIDTH))) {
2320         enum INT_LEAST16_WIDTH = 16;
2321     }
2322 
2323 
2324 
2325 
2326     static if(!is(typeof(UINT_LEAST16_WIDTH))) {
2327         enum UINT_LEAST16_WIDTH = 16;
2328     }
2329 
2330 
2331 
2332 
2333     static if(!is(typeof(INT_LEAST32_WIDTH))) {
2334         enum INT_LEAST32_WIDTH = 32;
2335     }
2336 
2337 
2338 
2339 
2340     static if(!is(typeof(UINT_LEAST32_WIDTH))) {
2341         enum UINT_LEAST32_WIDTH = 32;
2342     }
2343 
2344 
2345 
2346 
2347     static if(!is(typeof(INT_LEAST64_WIDTH))) {
2348         enum INT_LEAST64_WIDTH = 64;
2349     }
2350 
2351 
2352 
2353 
2354     static if(!is(typeof(UINT_LEAST64_WIDTH))) {
2355         enum UINT_LEAST64_WIDTH = 64;
2356     }
2357 
2358 
2359 
2360 
2361     static if(!is(typeof(INT_FAST8_WIDTH))) {
2362         enum INT_FAST8_WIDTH = 8;
2363     }
2364 
2365 
2366 
2367 
2368     static if(!is(typeof(UINT_FAST8_WIDTH))) {
2369         enum UINT_FAST8_WIDTH = 8;
2370     }
2371     static if(!is(typeof(INT_FAST64_WIDTH))) {
2372         enum INT_FAST64_WIDTH = 64;
2373     }
2374 
2375 
2376 
2377 
2378     static if(!is(typeof(UINT_FAST64_WIDTH))) {
2379         enum UINT_FAST64_WIDTH = 64;
2380     }
2381     static if(!is(typeof(INTMAX_WIDTH))) {
2382         enum INTMAX_WIDTH = 64;
2383     }
2384 
2385 
2386 
2387 
2388     static if(!is(typeof(UINTMAX_WIDTH))) {
2389         enum UINTMAX_WIDTH = 64;
2390     }
2391 
2392 
2393 
2394 
2395 
2396 
2397     static if(!is(typeof(SIG_ATOMIC_WIDTH))) {
2398         enum SIG_ATOMIC_WIDTH = 32;
2399     }
2400 
2401 
2402 
2403 
2404 
2405 
2406     static if(!is(typeof(WCHAR_WIDTH))) {
2407         enum WCHAR_WIDTH = 32;
2408     }
2409 
2410 
2411 
2412 
2413     static if(!is(typeof(WINT_WIDTH))) {
2414         enum WINT_WIDTH = 32;
2415     }
2416 
2417 
2418 
2419 
2420     static if(!is(typeof(GRPC_ARG_TCP_READ_CHUNK_SIZE))) {
2421         enum GRPC_ARG_TCP_READ_CHUNK_SIZE = "grpc.experimental.tcp_read_chunk_size";
2422     }
2423 
2424 
2425 
2426 
2427 
2428 
2429     static if(!is(typeof(GRPC_ARG_USE_CRONET_PACKET_COALESCING))) {
2430         enum GRPC_ARG_USE_CRONET_PACKET_COALESCING = "grpc.use_cronet_packet_coalescing";
2431     }
2432 
2433 
2434 
2435 
2436     static if(!is(typeof(GRPC_ARG_ENABLE_CHANNELZ))) {
2437         enum GRPC_ARG_ENABLE_CHANNELZ = "grpc.enable_channelz";
2438     }
2439 
2440 
2441 
2442 
2443     static if(!is(typeof(_STDLIB_H))) {
2444         enum _STDLIB_H = 1;
2445     }
2446 
2447 
2448 
2449 
2450     static if(!is(typeof(GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE))) {
2451         enum GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE = "grpc.max_channel_trace_event_memory_per_node";
2452     }
2453 
2454 
2455 
2456 
2457     static if(!is(typeof(GRPC_ARG_SOCKET_FACTORY))) {
2458         enum GRPC_ARG_SOCKET_FACTORY = "grpc.socket_factory";
2459     }
2460 
2461 
2462 
2463 
2464     static if(!is(typeof(GRPC_ARG_SOCKET_MUTATOR))) {
2465         enum GRPC_ARG_SOCKET_MUTATOR = "grpc.socket_mutator";
2466     }
2467 
2468 
2469 
2470 
2471     static if(!is(typeof(GRPC_ARG_LB_POLICY_NAME))) {
2472         enum GRPC_ARG_LB_POLICY_NAME = "grpc.lb_policy_name";
2473     }
2474     static if(!is(typeof(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION))) {
2475         enum GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION = "grpc.service_config_disable_resolution";
2476     }
2477 
2478 
2479 
2480 
2481 
2482 
2483     static if(!is(typeof(GRPC_ARG_SERVICE_CONFIG))) {
2484         enum GRPC_ARG_SERVICE_CONFIG = "grpc.service_config";
2485     }
2486 
2487 
2488 
2489 
2490     static if(!is(typeof(GRPC_ARG_EXPAND_WILDCARD_ADDRS))) {
2491         enum GRPC_ARG_EXPAND_WILDCARD_ADDRS = "grpc.expand_wildcard_addrs";
2492     }
2493 
2494 
2495 
2496 
2497     static if(!is(typeof(GRPC_ARG_RESOURCE_QUOTA))) {
2498         enum GRPC_ARG_RESOURCE_QUOTA = "grpc.resource_quota";
2499     }
2500 
2501 
2502 
2503 
2504     static if(!is(typeof(GRPC_ARG_ALLOW_REUSEPORT))) {
2505         enum GRPC_ARG_ALLOW_REUSEPORT = "grpc.so_reuseport";
2506     }
2507 
2508 
2509 
2510 
2511     static if(!is(typeof(GRPC_ARG_MAX_METADATA_SIZE))) {
2512         enum GRPC_ARG_MAX_METADATA_SIZE = "grpc.max_metadata_size";
2513     }
2514 
2515 
2516 
2517 
2518     static if(!is(typeof(__ldiv_t_defined))) {
2519         enum __ldiv_t_defined = 1;
2520     }
2521 
2522 
2523 
2524 
2525     static if(!is(typeof(GRPC_ARG_TSI_MAX_FRAME_SIZE))) {
2526         enum GRPC_ARG_TSI_MAX_FRAME_SIZE = "grpc.tsi.max_frame_size";
2527     }
2528 
2529 
2530 
2531 
2532     static if(!is(typeof(GRPC_SSL_SESSION_CACHE_ARG))) {
2533         enum GRPC_SSL_SESSION_CACHE_ARG = "grpc.ssl_session_cache";
2534     }
2535 
2536 
2537 
2538 
2539     static if(!is(typeof(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG))) {
2540         enum GRPC_SSL_TARGET_NAME_OVERRIDE_ARG = "grpc.ssl_target_name_override";
2541     }
2542 
2543 
2544 
2545 
2546     static if(!is(typeof(__lldiv_t_defined))) {
2547         enum __lldiv_t_defined = 1;
2548     }
2549 
2550 
2551 
2552 
2553     static if(!is(typeof(RAND_MAX))) {
2554         enum RAND_MAX = 2147483647;
2555     }
2556 
2557 
2558 
2559 
2560     static if(!is(typeof(EXIT_FAILURE))) {
2561         enum EXIT_FAILURE = 1;
2562     }
2563 
2564 
2565 
2566 
2567     static if(!is(typeof(EXIT_SUCCESS))) {
2568         enum EXIT_SUCCESS = 0;
2569     }
2570 
2571 
2572 
2573 
2574 
2575 
2576     static if(!is(typeof(GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS))) {
2577         enum GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS = "grpc.server_handshake_timeout_ms";
2578     }
2579 
2580 
2581 
2582 
2583     static if(!is(typeof(GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS))) {
2584         enum GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS = "grpc.dns_min_time_between_resolutions_ms";
2585     }
2586 
2587 
2588 
2589 
2590     static if(!is(typeof(GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS))) {
2591         enum GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS = "grpc.initial_reconnect_backoff_ms";
2592     }
2593 
2594 
2595 
2596 
2597     static if(!is(typeof(GRPC_ARG_MAX_RECONNECT_BACKOFF_MS))) {
2598         enum GRPC_ARG_MAX_RECONNECT_BACKOFF_MS = "grpc.max_reconnect_backoff_ms";
2599     }
2600 
2601 
2602 
2603 
2604     static if(!is(typeof(GRPC_ARG_MIN_RECONNECT_BACKOFF_MS))) {
2605         enum GRPC_ARG_MIN_RECONNECT_BACKOFF_MS = "grpc.min_reconnect_backoff_ms";
2606     }
2607 
2608 
2609 
2610 
2611     static if(!is(typeof(GRPC_ARG_SECONDARY_USER_AGENT_STRING))) {
2612         enum GRPC_ARG_SECONDARY_USER_AGENT_STRING = "grpc.secondary_user_agent";
2613     }
2614 
2615 
2616 
2617 
2618     static if(!is(typeof(GRPC_ARG_PRIMARY_USER_AGENT_STRING))) {
2619         enum GRPC_ARG_PRIMARY_USER_AGENT_STRING = "grpc.primary_user_agent";
2620     }
2621 
2622 
2623 
2624 
2625     static if(!is(typeof(GRPC_ARG_DEFAULT_AUTHORITY))) {
2626         enum GRPC_ARG_DEFAULT_AUTHORITY = "grpc.default_authority";
2627     }
2628 
2629 
2630 
2631 
2632     static if(!is(typeof(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS))) {
2633         enum GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS = "grpc.keepalive_permit_without_calls";
2634     }
2635 
2636 
2637 
2638 
2639     static if(!is(typeof(GRPC_ARG_KEEPALIVE_TIMEOUT_MS))) {
2640         enum GRPC_ARG_KEEPALIVE_TIMEOUT_MS = "grpc.keepalive_timeout_ms";
2641     }
2642 
2643 
2644 
2645 
2646     static if(!is(typeof(GRPC_ARG_KEEPALIVE_TIME_MS))) {
2647         enum GRPC_ARG_KEEPALIVE_TIME_MS = "grpc.keepalive_time_ms";
2648     }
2649 
2650 
2651 
2652 
2653     static if(!is(typeof(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY))) {
2654         enum GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY = "grpc.http2.true_binary";
2655     }
2656 
2657 
2658 
2659 
2660     static if(!is(typeof(GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE))) {
2661         enum GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE = "grpc.http2.write_buffer_size";
2662     }
2663 
2664 
2665 
2666 
2667     static if(!is(typeof(GRPC_ARG_HTTP2_MAX_PING_STRIKES))) {
2668         enum GRPC_ARG_HTTP2_MAX_PING_STRIKES = "grpc.http2.max_ping_strikes";
2669     }
2670 
2671 
2672 
2673 
2674     static if(!is(typeof(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA))) {
2675         enum GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA = "grpc.http2.max_pings_without_data";
2676     }
2677 
2678 
2679 
2680 
2681     static if(!is(typeof(GRPC_ARG_HTTP2_SCHEME))) {
2682         enum GRPC_ARG_HTTP2_SCHEME = "grpc.http2_scheme";
2683     }
2684 
2685 
2686 
2687 
2688     static if(!is(typeof(GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS))) {
2689         enum GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS = "grpc.http2.min_ping_interval_without_data_ms";
2690     }
2691 
2692 
2693 
2694 
2695     static if(!is(typeof(GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS))) {
2696         enum GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS = "grpc.http2.min_time_between_pings_ms";
2697     }
2698 
2699 
2700 
2701 
2702     static if(!is(typeof(GRPC_ARG_HTTP2_BDP_PROBE))) {
2703         enum GRPC_ARG_HTTP2_BDP_PROBE = "grpc.http2.bdp_probe";
2704     }
2705 
2706 
2707 
2708 
2709     static if(!is(typeof(GRPC_ARG_HTTP2_MAX_FRAME_SIZE))) {
2710         enum GRPC_ARG_HTTP2_MAX_FRAME_SIZE = "grpc.http2.max_frame_size";
2711     }
2712 
2713 
2714 
2715 
2716     static if(!is(typeof(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER))) {
2717         enum GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER = "grpc.http2.hpack_table_size.encoder";
2718     }
2719 
2720 
2721 
2722 
2723     static if(!is(typeof(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER))) {
2724         enum GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER = "grpc.http2.hpack_table_size.decoder";
2725     }
2726 
2727 
2728 
2729 
2730     static if(!is(typeof(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES))) {
2731         enum GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES = "grpc.http2.lookahead_bytes";
2732     }
2733 
2734 
2735 
2736 
2737     static if(!is(typeof(GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER))) {
2738         enum GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER = "grpc.http2.initial_sequence_number";
2739     }
2740 
2741 
2742 
2743 
2744     static if(!is(typeof(GRPC_ARG_ENABLE_DEADLINE_CHECKS))) {
2745         enum GRPC_ARG_ENABLE_DEADLINE_CHECKS = "grpc.enable_deadline_checking";
2746     }
2747 
2748 
2749 
2750 
2751     static if(!is(typeof(GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION))) {
2752         enum GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION = "grpc.per_message_compression";
2753     }
2754 
2755 
2756 
2757 
2758     static if(!is(typeof(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS))) {
2759         enum GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS = "grpc.client_idle_timeout_ms";
2760     }
2761 
2762 
2763 
2764 
2765     static if(!is(typeof(GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS))) {
2766         enum GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS = "grpc.max_connection_age_grace_ms";
2767     }
2768 
2769 
2770 
2771 
2772     static if(!is(typeof(GRPC_ARG_MAX_CONNECTION_AGE_MS))) {
2773         enum GRPC_ARG_MAX_CONNECTION_AGE_MS = "grpc.max_connection_age_ms";
2774     }
2775 
2776 
2777 
2778 
2779     static if(!is(typeof(GRPC_ARG_MAX_CONNECTION_IDLE_MS))) {
2780         enum GRPC_ARG_MAX_CONNECTION_IDLE_MS = "grpc.max_connection_idle_ms";
2781     }
2782 
2783 
2784 
2785 
2786     static if(!is(typeof(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH))) {
2787         enum GRPC_ARG_MAX_SEND_MESSAGE_LENGTH = "grpc.max_send_message_length";
2788     }
2789 
2790 
2791 
2792 
2793 
2794 
2795     static if(!is(typeof(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH))) {
2796         enum GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH = "grpc.max_receive_message_length";
2797     }
2798 
2799 
2800 
2801 
2802     static if(!is(typeof(GRPC_ARG_MAX_CONCURRENT_STREAMS))) {
2803         enum GRPC_ARG_MAX_CONCURRENT_STREAMS = "grpc.max_concurrent_streams";
2804     }
2805 
2806 
2807 
2808 
2809     static if(!is(typeof(GRPC_ARG_MINIMAL_STACK))) {
2810         enum GRPC_ARG_MINIMAL_STACK = "grpc.minimal_stack";
2811     }
2812 
2813 
2814 
2815 
2816     static if(!is(typeof(GRPC_ARG_ENABLE_LOAD_REPORTING))) {
2817         enum GRPC_ARG_ENABLE_LOAD_REPORTING = "grpc.loadreporting";
2818     }
2819 
2820 
2821 
2822 
2823     static if(!is(typeof(GRPC_ARG_ENABLE_CENSUS))) {
2824         enum GRPC_ARG_ENABLE_CENSUS = "grpc.census";
2825     }
2826     static if(!is(typeof(GRPC_ALLOW_GPR_SLICE_FUNCTIONS))) {
2827         enum GRPC_ALLOW_GPR_SLICE_FUNCTIONS = 1;
2828     }
2829     static if(!is(typeof(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET))) {
2830         enum GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET = "grpc.compression_enabled_algorithms_bitset";
2831     }
2832 
2833 
2834 
2835 
2836     static if(!is(typeof(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL))) {
2837         enum GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL = "grpc.default_compression_level";
2838     }
2839 
2840 
2841 
2842 
2843     static if(!is(typeof(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM))) {
2844         enum GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM = "grpc.default_compression_algorithm";
2845     }
2846 
2847 
2848 
2849 
2850     static if(!is(typeof(GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY))) {
2851         enum GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY = "grpc-internal-encoding-request";
2852     }
2853     static if(!is(typeof(GRPC_GOOGLE_CREDENTIALS_ENV_VAR))) {
2854         enum GRPC_GOOGLE_CREDENTIALS_ENV_VAR = "GOOGLE_APPLICATION_CREDENTIALS";
2855     }
2856 
2857 
2858 
2859 
2860     static if(!is(typeof(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR))) {
2861         enum GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR = "GRPC_DEFAULT_SSL_ROOTS_FILE_PATH";
2862     }
2863 
2864 
2865 
2866 
2867     static if(!is(typeof(GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME))) {
2868         enum GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME = "security_level";
2869     }
2870 
2871 
2872 
2873 
2874     static if(!is(typeof(GRPC_SSL_SESSION_REUSED_PROPERTY))) {
2875         enum GRPC_SSL_SESSION_REUSED_PROPERTY = "ssl_session_reused";
2876     }
2877 
2878 
2879 
2880 
2881     static if(!is(typeof(GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME))) {
2882         enum GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME = "x509_pem_cert_chain";
2883     }
2884 
2885 
2886 
2887 
2888     static if(!is(typeof(GRPC_X509_PEM_CERT_PROPERTY_NAME))) {
2889         enum GRPC_X509_PEM_CERT_PROPERTY_NAME = "x509_pem_cert";
2890     }
2891 
2892 
2893 
2894 
2895     static if(!is(typeof(GRPC_X509_SAN_PROPERTY_NAME))) {
2896         enum GRPC_X509_SAN_PROPERTY_NAME = "x509_subject_alternative_name";
2897     }
2898 
2899 
2900 
2901 
2902     static if(!is(typeof(GRPC_X509_CN_PROPERTY_NAME))) {
2903         enum GRPC_X509_CN_PROPERTY_NAME = "x509_common_name";
2904     }
2905 
2906 
2907 
2908 
2909     static if(!is(typeof(GRPC_SSL_TRANSPORT_SECURITY_TYPE))) {
2910         enum GRPC_SSL_TRANSPORT_SECURITY_TYPE = "ssl";
2911     }
2912 
2913 
2914 
2915 
2916     static if(!is(typeof(GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME))) {
2917         enum GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME = "transport_security_type";
2918     }
2919 
2920 
2921 
2922 
2923 
2924 
2925     static if(!is(typeof(GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX))) {
2926         enum GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX = 4;
2927     }
2928 
2929 
2930 
2931 
2932 
2933 
2934     static if(!is(typeof(GRPC_MAX_COMPLETION_QUEUE_PLUCKERS))) {
2935         enum GRPC_MAX_COMPLETION_QUEUE_PLUCKERS = 6;
2936     }
2937     static if(!is(typeof(__GLIBC_MINOR__))) {
2938         enum __GLIBC_MINOR__ = 31;
2939     }
2940 
2941 
2942 
2943 
2944     static if(!is(typeof(__GLIBC__))) {
2945         enum __GLIBC__ = 2;
2946     }
2947 
2948 
2949 
2950 
2951     static if(!is(typeof(__GNU_LIBRARY__))) {
2952         enum __GNU_LIBRARY__ = 6;
2953     }
2954 
2955 
2956 
2957 
2958     static if(!is(typeof(__GLIBC_USE_DEPRECATED_SCANF))) {
2959         enum __GLIBC_USE_DEPRECATED_SCANF = 0;
2960     }
2961 
2962 
2963 
2964 
2965     static if(!is(typeof(__GLIBC_USE_DEPRECATED_GETS))) {
2966         enum __GLIBC_USE_DEPRECATED_GETS = 0;
2967     }
2968 
2969 
2970 
2971 
2972     static if(!is(typeof(__USE_FORTIFY_LEVEL))) {
2973         enum __USE_FORTIFY_LEVEL = 0;
2974     }
2975 
2976 
2977 
2978 
2979     static if(!is(typeof(__USE_GNU))) {
2980         enum __USE_GNU = 1;
2981     }
2982 
2983 
2984 
2985 
2986     static if(!is(typeof(__USE_ATFILE))) {
2987         enum __USE_ATFILE = 1;
2988     }
2989 
2990 
2991 
2992 
2993     static if(!is(typeof(__USE_MISC))) {
2994         enum __USE_MISC = 1;
2995     }
2996 
2997 
2998 
2999 
3000     static if(!is(typeof(__USE_LARGEFILE64))) {
3001         enum __USE_LARGEFILE64 = 1;
3002     }
3003 
3004 
3005 
3006 
3007     static if(!is(typeof(__USE_LARGEFILE))) {
3008         enum __USE_LARGEFILE = 1;
3009     }
3010 
3011 
3012 
3013 
3014     static if(!is(typeof(__USE_ISOC99))) {
3015         enum __USE_ISOC99 = 1;
3016     }
3017 
3018 
3019 
3020 
3021     static if(!is(typeof(__USE_ISOC95))) {
3022         enum __USE_ISOC95 = 1;
3023     }
3024 
3025 
3026 
3027 
3028     static if(!is(typeof(__USE_XOPEN2KXSI))) {
3029         enum __USE_XOPEN2KXSI = 1;
3030     }
3031 
3032 
3033 
3034 
3035     static if(!is(typeof(__USE_XOPEN2K))) {
3036         enum __USE_XOPEN2K = 1;
3037     }
3038 
3039 
3040 
3041 
3042     static if(!is(typeof(__USE_XOPEN2K8XSI))) {
3043         enum __USE_XOPEN2K8XSI = 1;
3044     }
3045 
3046 
3047 
3048 
3049     static if(!is(typeof(__USE_XOPEN2K8))) {
3050         enum __USE_XOPEN2K8 = 1;
3051     }
3052 
3053 
3054 
3055 
3056     static if(!is(typeof(_LARGEFILE_SOURCE))) {
3057         enum _LARGEFILE_SOURCE = 1;
3058     }
3059 
3060 
3061 
3062 
3063     static if(!is(typeof(__USE_UNIX98))) {
3064         enum __USE_UNIX98 = 1;
3065     }
3066 
3067 
3068 
3069 
3070     static if(!is(typeof(__USE_XOPEN_EXTENDED))) {
3071         enum __USE_XOPEN_EXTENDED = 1;
3072     }
3073 
3074 
3075 
3076 
3077     static if(!is(typeof(__USE_XOPEN))) {
3078         enum __USE_XOPEN = 1;
3079     }
3080 
3081 
3082 
3083 
3084     static if(!is(typeof(_ATFILE_SOURCE))) {
3085         enum _ATFILE_SOURCE = 1;
3086     }
3087 
3088 
3089 
3090 
3091     static if(!is(typeof(__USE_POSIX199506))) {
3092         enum __USE_POSIX199506 = 1;
3093     }
3094 
3095 
3096 
3097 
3098     static if(!is(typeof(__USE_POSIX199309))) {
3099         enum __USE_POSIX199309 = 1;
3100     }
3101 
3102 
3103 
3104 
3105     static if(!is(typeof(__USE_POSIX2))) {
3106         enum __USE_POSIX2 = 1;
3107     }
3108 
3109 
3110 
3111 
3112     static if(!is(typeof(__USE_POSIX))) {
3113         enum __USE_POSIX = 1;
3114     }
3115 
3116 
3117 
3118 
3119     static if(!is(typeof(_POSIX_C_SOURCE))) {
3120         enum _POSIX_C_SOURCE = 200809L;
3121     }
3122 
3123 
3124 
3125 
3126     static if(!is(typeof(_POSIX_SOURCE))) {
3127         enum _POSIX_SOURCE = 1;
3128     }
3129 
3130 
3131 
3132 
3133     static if(!is(typeof(__USE_ISOC11))) {
3134         enum __USE_ISOC11 = 1;
3135     }
3136 
3137 
3138 
3139 
3140     static if(!is(typeof(__GLIBC_USE_ISOC2X))) {
3141         enum __GLIBC_USE_ISOC2X = 1;
3142     }
3143 
3144 
3145 
3146 
3147     static if(!is(typeof(_LARGEFILE64_SOURCE))) {
3148         enum _LARGEFILE64_SOURCE = 1;
3149     }
3150 
3151 
3152 
3153 
3154     static if(!is(typeof(_XOPEN_SOURCE_EXTENDED))) {
3155         enum _XOPEN_SOURCE_EXTENDED = 1;
3156     }
3157 
3158 
3159 
3160 
3161     static if(!is(typeof(_XOPEN_SOURCE))) {
3162         enum _XOPEN_SOURCE = 700;
3163     }
3164 
3165 
3166 
3167 
3168     static if(!is(typeof(_ISOC2X_SOURCE))) {
3169         enum _ISOC2X_SOURCE = 1;
3170     }
3171 
3172 
3173 
3174 
3175     static if(!is(typeof(_ISOC11_SOURCE))) {
3176         enum _ISOC11_SOURCE = 1;
3177     }
3178 
3179 
3180 
3181 
3182     static if(!is(typeof(_ISOC99_SOURCE))) {
3183         enum _ISOC99_SOURCE = 1;
3184     }
3185 
3186 
3187 
3188 
3189     static if(!is(typeof(_ISOC95_SOURCE))) {
3190         enum _ISOC95_SOURCE = 1;
3191     }
3192     static if(!is(typeof(_FEATURES_H))) {
3193         enum _FEATURES_H = 1;
3194     }
3195     static if(!is(typeof(_ENDIAN_H))) {
3196         enum _ENDIAN_H = 1;
3197     }
3198 
3199 
3200 
3201 
3202     static if(!is(typeof(__SYSCALL_WORDSIZE))) {
3203         enum __SYSCALL_WORDSIZE = 64;
3204     }
3205 
3206 
3207 
3208 
3209     static if(!is(typeof(__WORDSIZE_TIME64_COMPAT32))) {
3210         enum __WORDSIZE_TIME64_COMPAT32 = 1;
3211     }
3212 
3213 
3214 
3215 
3216     static if(!is(typeof(__WORDSIZE))) {
3217         enum __WORDSIZE = 64;
3218     }
3219     static if(!is(typeof(_BITS_WCHAR_H))) {
3220         enum _BITS_WCHAR_H = 1;
3221     }
3222 
3223 
3224 
3225 
3226     static if(!is(typeof(__WCOREFLAG))) {
3227         enum __WCOREFLAG = 0x80;
3228     }
3229 
3230 
3231 
3232 
3233     static if(!is(typeof(__W_CONTINUED))) {
3234         enum __W_CONTINUED = 0xffff;
3235     }
3236     static if(!is(typeof(__WCLONE))) {
3237         enum __WCLONE = 0x80000000;
3238     }
3239 
3240 
3241 
3242 
3243     static if(!is(typeof(__WALL))) {
3244         enum __WALL = 0x40000000;
3245     }
3246 
3247 
3248 
3249 
3250     static if(!is(typeof(__WNOTHREAD))) {
3251         enum __WNOTHREAD = 0x20000000;
3252     }
3253 
3254 
3255 
3256 
3257     static if(!is(typeof(WNOWAIT))) {
3258         enum WNOWAIT = 0x01000000;
3259     }
3260 
3261 
3262 
3263 
3264     static if(!is(typeof(WCONTINUED))) {
3265         enum WCONTINUED = 8;
3266     }
3267 
3268 
3269 
3270 
3271     static if(!is(typeof(WEXITED))) {
3272         enum WEXITED = 4;
3273     }
3274 
3275 
3276 
3277 
3278     static if(!is(typeof(WSTOPPED))) {
3279         enum WSTOPPED = 2;
3280     }
3281 
3282 
3283 
3284 
3285     static if(!is(typeof(WUNTRACED))) {
3286         enum WUNTRACED = 2;
3287     }
3288 
3289 
3290 
3291 
3292     static if(!is(typeof(WNOHANG))) {
3293         enum WNOHANG = 1;
3294     }
3295 
3296 
3297 
3298 
3299     static if(!is(typeof(_BITS_UINTN_IDENTITY_H))) {
3300         enum _BITS_UINTN_IDENTITY_H = 1;
3301     }
3302 
3303 
3304 
3305 
3306     static if(!is(typeof(__FD_SETSIZE))) {
3307         enum __FD_SETSIZE = 1024;
3308     }
3309 
3310 
3311 
3312 
3313     static if(!is(typeof(__STATFS_MATCHES_STATFS64))) {
3314         enum __STATFS_MATCHES_STATFS64 = 1;
3315     }
3316 
3317 
3318 
3319 
3320     static if(!is(typeof(__RLIM_T_MATCHES_RLIM64_T))) {
3321         enum __RLIM_T_MATCHES_RLIM64_T = 1;
3322     }
3323 
3324 
3325 
3326 
3327     static if(!is(typeof(__INO_T_MATCHES_INO64_T))) {
3328         enum __INO_T_MATCHES_INO64_T = 1;
3329     }
3330 
3331 
3332 
3333 
3334     static if(!is(typeof(__OFF_T_MATCHES_OFF64_T))) {
3335         enum __OFF_T_MATCHES_OFF64_T = 1;
3336     }
3337     static if(!is(typeof(_BITS_TYPESIZES_H))) {
3338         enum _BITS_TYPESIZES_H = 1;
3339     }
3340 
3341 
3342 
3343 
3344     static if(!is(typeof(__timer_t_defined))) {
3345         enum __timer_t_defined = 1;
3346     }
3347 
3348 
3349 
3350 
3351     static if(!is(typeof(__time_t_defined))) {
3352         enum __time_t_defined = 1;
3353     }
3354 
3355 
3356 
3357 
3358     static if(!is(typeof(__struct_tm_defined))) {
3359         enum __struct_tm_defined = 1;
3360     }
3361 
3362 
3363 
3364 
3365     static if(!is(typeof(__timeval_defined))) {
3366         enum __timeval_defined = 1;
3367     }
3368 
3369 
3370 
3371 
3372     static if(!is(typeof(_STRUCT_TIMESPEC))) {
3373         enum _STRUCT_TIMESPEC = 1;
3374     }
3375 
3376 
3377 
3378 
3379     static if(!is(typeof(_BITS_TYPES_STRUCT_SCHED_PARAM))) {
3380         enum _BITS_TYPES_STRUCT_SCHED_PARAM = 1;
3381     }
3382 
3383 
3384 
3385 
3386     static if(!is(typeof(__itimerspec_defined))) {
3387         enum __itimerspec_defined = 1;
3388     }
3389 
3390 
3391 
3392 
3393     static if(!is(typeof(__sigset_t_defined))) {
3394         enum __sigset_t_defined = 1;
3395     }
3396 
3397 
3398 
3399 
3400     static if(!is(typeof(_BITS_TYPES_LOCALE_T_H))) {
3401         enum _BITS_TYPES_LOCALE_T_H = 1;
3402     }
3403 
3404 
3405 
3406 
3407     static if(!is(typeof(__clockid_t_defined))) {
3408         enum __clockid_t_defined = 1;
3409     }
3410 
3411 
3412 
3413 
3414     static if(!is(typeof(__clock_t_defined))) {
3415         enum __clock_t_defined = 1;
3416     }
3417     static if(!is(typeof(_BITS_TYPES___LOCALE_T_H))) {
3418         enum _BITS_TYPES___LOCALE_T_H = 1;
3419     }
3420     static if(!is(typeof(_BITS_TYPES_H))) {
3421         enum _BITS_TYPES_H = 1;
3422     }
3423 
3424 
3425 
3426 
3427 
3428 
3429     static if(!is(typeof(STA_CLK))) {
3430         enum STA_CLK = 0x8000;
3431     }
3432 
3433 
3434 
3435 
3436     static if(!is(typeof(STA_MODE))) {
3437         enum STA_MODE = 0x4000;
3438     }
3439 
3440 
3441 
3442 
3443     static if(!is(typeof(STA_NANO))) {
3444         enum STA_NANO = 0x2000;
3445     }
3446 
3447 
3448 
3449 
3450     static if(!is(typeof(STA_CLOCKERR))) {
3451         enum STA_CLOCKERR = 0x1000;
3452     }
3453 
3454 
3455 
3456 
3457     static if(!is(typeof(STA_PPSERROR))) {
3458         enum STA_PPSERROR = 0x0800;
3459     }
3460 
3461 
3462 
3463 
3464     static if(!is(typeof(STA_PPSWANDER))) {
3465         enum STA_PPSWANDER = 0x0400;
3466     }
3467 
3468 
3469 
3470 
3471     static if(!is(typeof(STA_PPSJITTER))) {
3472         enum STA_PPSJITTER = 0x0200;
3473     }
3474 
3475 
3476 
3477 
3478     static if(!is(typeof(STA_PPSSIGNAL))) {
3479         enum STA_PPSSIGNAL = 0x0100;
3480     }
3481 
3482 
3483 
3484 
3485     static if(!is(typeof(STA_FREQHOLD))) {
3486         enum STA_FREQHOLD = 0x0080;
3487     }
3488 
3489 
3490 
3491 
3492     static if(!is(typeof(STA_UNSYNC))) {
3493         enum STA_UNSYNC = 0x0040;
3494     }
3495 
3496 
3497 
3498 
3499     static if(!is(typeof(STA_DEL))) {
3500         enum STA_DEL = 0x0020;
3501     }
3502 
3503 
3504 
3505 
3506     static if(!is(typeof(STA_INS))) {
3507         enum STA_INS = 0x0010;
3508     }
3509 
3510 
3511 
3512 
3513     static if(!is(typeof(STA_FLL))) {
3514         enum STA_FLL = 0x0008;
3515     }
3516 
3517 
3518 
3519 
3520     static if(!is(typeof(STA_PPSTIME))) {
3521         enum STA_PPSTIME = 0x0004;
3522     }
3523 
3524 
3525 
3526 
3527     static if(!is(typeof(STA_PPSFREQ))) {
3528         enum STA_PPSFREQ = 0x0002;
3529     }
3530 
3531 
3532 
3533 
3534     static if(!is(typeof(STA_PLL))) {
3535         enum STA_PLL = 0x0001;
3536     }
3537     static if(!is(typeof(ADJ_OFFSET_SS_READ))) {
3538         enum ADJ_OFFSET_SS_READ = 0xa001;
3539     }
3540 
3541 
3542 
3543 
3544     static if(!is(typeof(ADJ_OFFSET_SINGLESHOT))) {
3545         enum ADJ_OFFSET_SINGLESHOT = 0x8001;
3546     }
3547 
3548 
3549 
3550 
3551     static if(!is(typeof(ADJ_TICK))) {
3552         enum ADJ_TICK = 0x4000;
3553     }
3554 
3555 
3556 
3557 
3558     static if(!is(typeof(ADJ_NANO))) {
3559         enum ADJ_NANO = 0x2000;
3560     }
3561 
3562 
3563 
3564 
3565     static if(!is(typeof(ADJ_MICRO))) {
3566         enum ADJ_MICRO = 0x1000;
3567     }
3568 
3569 
3570 
3571 
3572     static if(!is(typeof(ADJ_SETOFFSET))) {
3573         enum ADJ_SETOFFSET = 0x0100;
3574     }
3575 
3576 
3577 
3578 
3579     static if(!is(typeof(ADJ_TAI))) {
3580         enum ADJ_TAI = 0x0080;
3581     }
3582 
3583 
3584 
3585 
3586     static if(!is(typeof(ADJ_TIMECONST))) {
3587         enum ADJ_TIMECONST = 0x0020;
3588     }
3589 
3590 
3591 
3592 
3593     static if(!is(typeof(ADJ_STATUS))) {
3594         enum ADJ_STATUS = 0x0010;
3595     }
3596 
3597 
3598 
3599 
3600     static if(!is(typeof(ADJ_ESTERROR))) {
3601         enum ADJ_ESTERROR = 0x0008;
3602     }
3603 
3604 
3605 
3606 
3607     static if(!is(typeof(ADJ_MAXERROR))) {
3608         enum ADJ_MAXERROR = 0x0004;
3609     }
3610 
3611 
3612 
3613 
3614     static if(!is(typeof(ADJ_FREQUENCY))) {
3615         enum ADJ_FREQUENCY = 0x0002;
3616     }
3617 
3618 
3619 
3620 
3621     static if(!is(typeof(ADJ_OFFSET))) {
3622         enum ADJ_OFFSET = 0x0001;
3623     }
3624 
3625 
3626 
3627 
3628     static if(!is(typeof(_BITS_TIMEX_H))) {
3629         enum _BITS_TIMEX_H = 1;
3630     }
3631     static if(!is(typeof(_BITS_TIME64_H))) {
3632         enum _BITS_TIME64_H = 1;
3633     }
3634 
3635 
3636 
3637 
3638     static if(!is(typeof(TIMER_ABSTIME))) {
3639         enum TIMER_ABSTIME = 1;
3640     }
3641 
3642 
3643 
3644 
3645     static if(!is(typeof(CLOCK_TAI))) {
3646         enum CLOCK_TAI = 11;
3647     }
3648 
3649 
3650 
3651 
3652     static if(!is(typeof(CLOCK_BOOTTIME_ALARM))) {
3653         enum CLOCK_BOOTTIME_ALARM = 9;
3654     }
3655 
3656 
3657 
3658 
3659     static if(!is(typeof(CLOCK_REALTIME_ALARM))) {
3660         enum CLOCK_REALTIME_ALARM = 8;
3661     }
3662 
3663 
3664 
3665 
3666     static if(!is(typeof(CLOCK_BOOTTIME))) {
3667         enum CLOCK_BOOTTIME = 7;
3668     }
3669 
3670 
3671 
3672 
3673     static if(!is(typeof(CLOCK_MONOTONIC_COARSE))) {
3674         enum CLOCK_MONOTONIC_COARSE = 6;
3675     }
3676 
3677 
3678 
3679 
3680     static if(!is(typeof(CLOCK_REALTIME_COARSE))) {
3681         enum CLOCK_REALTIME_COARSE = 5;
3682     }
3683 
3684 
3685 
3686 
3687     static if(!is(typeof(CLOCK_MONOTONIC_RAW))) {
3688         enum CLOCK_MONOTONIC_RAW = 4;
3689     }
3690 
3691 
3692 
3693 
3694     static if(!is(typeof(CLOCK_THREAD_CPUTIME_ID))) {
3695         enum CLOCK_THREAD_CPUTIME_ID = 3;
3696     }
3697 
3698 
3699 
3700 
3701     static if(!is(typeof(CLOCK_PROCESS_CPUTIME_ID))) {
3702         enum CLOCK_PROCESS_CPUTIME_ID = 2;
3703     }
3704 
3705 
3706 
3707 
3708     static if(!is(typeof(CLOCK_MONOTONIC))) {
3709         enum CLOCK_MONOTONIC = 1;
3710     }
3711 
3712 
3713 
3714 
3715     static if(!is(typeof(CLOCK_REALTIME))) {
3716         enum CLOCK_REALTIME = 0;
3717     }
3718 
3719 
3720 
3721 
3722 
3723 
3724     static if(!is(typeof(_BITS_TIME_H))) {
3725         enum _BITS_TIME_H = 1;
3726     }
3727 
3728 
3729 
3730 
3731     static if(!is(typeof(_THREAD_SHARED_TYPES_H))) {
3732         enum _THREAD_SHARED_TYPES_H = 1;
3733     }
3734     static if(!is(typeof(__PTHREAD_MUTEX_HAVE_PREV))) {
3735         enum __PTHREAD_MUTEX_HAVE_PREV = 1;
3736     }
3737 
3738 
3739 
3740 
3741     static if(!is(typeof(_THREAD_MUTEX_INTERNAL_H))) {
3742         enum _THREAD_MUTEX_INTERNAL_H = 1;
3743     }
3744 
3745 
3746 
3747 
3748     static if(!is(typeof(_BITS_STDINT_UINTN_H))) {
3749         enum _BITS_STDINT_UINTN_H = 1;
3750     }
3751 
3752 
3753 
3754 
3755     static if(!is(typeof(_BITS_STDINT_INTN_H))) {
3756         enum _BITS_STDINT_INTN_H = 1;
3757     }
3758 
3759 
3760 
3761 
3762     static if(!is(typeof(_BITS_SETJMP_H))) {
3763         enum _BITS_SETJMP_H = 1;
3764     }
3765     static if(!is(typeof(__FD_ZERO_STOS))) {
3766         enum __FD_ZERO_STOS = "stosq";
3767     }
3768 
3769 
3770 
3771 
3772     static if(!is(typeof(CLONE_IO))) {
3773         enum CLONE_IO = 0x80000000;
3774     }
3775 
3776 
3777 
3778 
3779     static if(!is(typeof(CLONE_NEWNET))) {
3780         enum CLONE_NEWNET = 0x40000000;
3781     }
3782 
3783 
3784 
3785 
3786     static if(!is(typeof(CLONE_NEWPID))) {
3787         enum CLONE_NEWPID = 0x20000000;
3788     }
3789 
3790 
3791 
3792 
3793     static if(!is(typeof(CLONE_NEWUSER))) {
3794         enum CLONE_NEWUSER = 0x10000000;
3795     }
3796 
3797 
3798 
3799 
3800     static if(!is(typeof(CLONE_NEWIPC))) {
3801         enum CLONE_NEWIPC = 0x08000000;
3802     }
3803 
3804 
3805 
3806 
3807     static if(!is(typeof(CLONE_NEWUTS))) {
3808         enum CLONE_NEWUTS = 0x04000000;
3809     }
3810 
3811 
3812 
3813 
3814     static if(!is(typeof(CLONE_NEWCGROUP))) {
3815         enum CLONE_NEWCGROUP = 0x02000000;
3816     }
3817 
3818 
3819 
3820 
3821     static if(!is(typeof(CLONE_CHILD_SETTID))) {
3822         enum CLONE_CHILD_SETTID = 0x01000000;
3823     }
3824 
3825 
3826 
3827 
3828     static if(!is(typeof(CLONE_UNTRACED))) {
3829         enum CLONE_UNTRACED = 0x00800000;
3830     }
3831 
3832 
3833 
3834 
3835     static if(!is(typeof(CLONE_DETACHED))) {
3836         enum CLONE_DETACHED = 0x00400000;
3837     }
3838 
3839 
3840 
3841 
3842     static if(!is(typeof(CLONE_CHILD_CLEARTID))) {
3843         enum CLONE_CHILD_CLEARTID = 0x00200000;
3844     }
3845 
3846 
3847 
3848 
3849     static if(!is(typeof(CLONE_PARENT_SETTID))) {
3850         enum CLONE_PARENT_SETTID = 0x00100000;
3851     }
3852 
3853 
3854 
3855 
3856     static if(!is(typeof(CLONE_SETTLS))) {
3857         enum CLONE_SETTLS = 0x00080000;
3858     }
3859 
3860 
3861 
3862 
3863     static if(!is(typeof(CLONE_SYSVSEM))) {
3864         enum CLONE_SYSVSEM = 0x00040000;
3865     }
3866 
3867 
3868 
3869 
3870     static if(!is(typeof(CLONE_NEWNS))) {
3871         enum CLONE_NEWNS = 0x00020000;
3872     }
3873 
3874 
3875 
3876 
3877 
3878 
3879     static if(!is(typeof(CLONE_THREAD))) {
3880         enum CLONE_THREAD = 0x00010000;
3881     }
3882 
3883 
3884 
3885 
3886     static if(!is(typeof(CLONE_PARENT))) {
3887         enum CLONE_PARENT = 0x00008000;
3888     }
3889 
3890 
3891 
3892 
3893     static if(!is(typeof(CLONE_VFORK))) {
3894         enum CLONE_VFORK = 0x00004000;
3895     }
3896 
3897 
3898 
3899 
3900     static if(!is(typeof(CLONE_PTRACE))) {
3901         enum CLONE_PTRACE = 0x00002000;
3902     }
3903 
3904 
3905 
3906 
3907     static if(!is(typeof(CLONE_PIDFD))) {
3908         enum CLONE_PIDFD = 0x00001000;
3909     }
3910 
3911 
3912 
3913 
3914     static if(!is(typeof(CLONE_SIGHAND))) {
3915         enum CLONE_SIGHAND = 0x00000800;
3916     }
3917 
3918 
3919 
3920 
3921     static if(!is(typeof(CLONE_FILES))) {
3922         enum CLONE_FILES = 0x00000400;
3923     }
3924 
3925 
3926 
3927 
3928     static if(!is(typeof(CLONE_FS))) {
3929         enum CLONE_FS = 0x00000200;
3930     }
3931 
3932 
3933 
3934 
3935     static if(!is(typeof(CLONE_VM))) {
3936         enum CLONE_VM = 0x00000100;
3937     }
3938 
3939 
3940 
3941 
3942     static if(!is(typeof(CSIGNAL))) {
3943         enum CSIGNAL = 0x000000ff;
3944     }
3945 
3946 
3947 
3948 
3949     static if(!is(typeof(SCHED_RESET_ON_FORK))) {
3950         enum SCHED_RESET_ON_FORK = 0x40000000;
3951     }
3952 
3953 
3954 
3955 
3956     static if(!is(typeof(SCHED_DEADLINE))) {
3957         enum SCHED_DEADLINE = 6;
3958     }
3959 
3960 
3961 
3962 
3963     static if(!is(typeof(SCHED_IDLE))) {
3964         enum SCHED_IDLE = 5;
3965     }
3966 
3967 
3968 
3969 
3970     static if(!is(typeof(SCHED_ISO))) {
3971         enum SCHED_ISO = 4;
3972     }
3973 
3974 
3975 
3976 
3977     static if(!is(typeof(SCHED_BATCH))) {
3978         enum SCHED_BATCH = 3;
3979     }
3980 
3981 
3982 
3983 
3984     static if(!is(typeof(SCHED_RR))) {
3985         enum SCHED_RR = 2;
3986     }
3987 
3988 
3989 
3990 
3991     static if(!is(typeof(SCHED_FIFO))) {
3992         enum SCHED_FIFO = 1;
3993     }
3994 
3995 
3996 
3997 
3998     static if(!is(typeof(SCHED_OTHER))) {
3999         enum SCHED_OTHER = 0;
4000     }
4001 
4002 
4003 
4004 
4005     static if(!is(typeof(_BITS_SCHED_H))) {
4006         enum _BITS_SCHED_H = 1;
4007     }
4008 
4009 
4010 
4011 
4012     static if(!is(typeof(__have_pthread_attr_t))) {
4013         enum __have_pthread_attr_t = 1;
4014     }
4015 
4016 
4017 
4018 
4019     static if(!is(typeof(_BITS_PTHREADTYPES_COMMON_H))) {
4020         enum _BITS_PTHREADTYPES_COMMON_H = 1;
4021     }
4022     static if(!is(typeof(__SIZEOF_PTHREAD_BARRIERATTR_T))) {
4023         enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4;
4024     }
4025 
4026 
4027 
4028 
4029     static if(!is(typeof(__SIZEOF_PTHREAD_RWLOCKATTR_T))) {
4030         enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8;
4031     }
4032 
4033 
4034 
4035 
4036     static if(!is(typeof(__SIZEOF_PTHREAD_CONDATTR_T))) {
4037         enum __SIZEOF_PTHREAD_CONDATTR_T = 4;
4038     }
4039 
4040 
4041 
4042 
4043     static if(!is(typeof(__SIZEOF_PTHREAD_COND_T))) {
4044         enum __SIZEOF_PTHREAD_COND_T = 48;
4045     }
4046 
4047 
4048 
4049 
4050     static if(!is(typeof(__SIZEOF_PTHREAD_MUTEXATTR_T))) {
4051         enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4;
4052     }
4053 
4054 
4055 
4056 
4057     static if(!is(typeof(__SIZEOF_PTHREAD_BARRIER_T))) {
4058         enum __SIZEOF_PTHREAD_BARRIER_T = 32;
4059     }
4060 
4061 
4062 
4063 
4064     static if(!is(typeof(__SIZEOF_PTHREAD_RWLOCK_T))) {
4065         enum __SIZEOF_PTHREAD_RWLOCK_T = 56;
4066     }
4067 
4068 
4069 
4070 
4071     static if(!is(typeof(__SIZEOF_PTHREAD_ATTR_T))) {
4072         enum __SIZEOF_PTHREAD_ATTR_T = 56;
4073     }
4074 
4075 
4076 
4077 
4078     static if(!is(typeof(__SIZEOF_PTHREAD_MUTEX_T))) {
4079         enum __SIZEOF_PTHREAD_MUTEX_T = 40;
4080     }
4081 
4082 
4083 
4084 
4085     static if(!is(typeof(_BITS_PTHREADTYPES_ARCH_H))) {
4086         enum _BITS_PTHREADTYPES_ARCH_H = 1;
4087     }
4088 
4089 
4090 
4091 
4092     static if(!is(typeof(__LONG_DOUBLE_USES_FLOAT128))) {
4093         enum __LONG_DOUBLE_USES_FLOAT128 = 0;
4094     }
4095 
4096 
4097 
4098 
4099     static if(!is(typeof(__GLIBC_USE_IEC_60559_TYPES_EXT))) {
4100         enum __GLIBC_USE_IEC_60559_TYPES_EXT = 1;
4101     }
4102 
4103 
4104 
4105 
4106     static if(!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT_C2X))) {
4107         enum __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = 1;
4108     }
4109 
4110 
4111 
4112 
4113     static if(!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT))) {
4114         enum __GLIBC_USE_IEC_60559_FUNCS_EXT = 1;
4115     }
4116 
4117 
4118 
4119 
4120     static if(!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT_C2X))) {
4121         enum __GLIBC_USE_IEC_60559_BFP_EXT_C2X = 1;
4122     }
4123 
4124 
4125 
4126 
4127     static if(!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT))) {
4128         enum __GLIBC_USE_IEC_60559_BFP_EXT = 1;
4129     }
4130 
4131 
4132 
4133 
4134     static if(!is(typeof(__GLIBC_USE_LIB_EXT2))) {
4135         enum __GLIBC_USE_LIB_EXT2 = 1;
4136     }
4137 
4138 
4139 
4140 
4141     static if(!is(typeof(__HAVE_FLOAT64X_LONG_DOUBLE))) {
4142         enum __HAVE_FLOAT64X_LONG_DOUBLE = 1;
4143     }
4144 
4145 
4146 
4147 
4148     static if(!is(typeof(__HAVE_FLOAT64X))) {
4149         enum __HAVE_FLOAT64X = 1;
4150     }
4151 
4152 
4153 
4154 
4155     static if(!is(typeof(__HAVE_DISTINCT_FLOAT128))) {
4156         enum __HAVE_DISTINCT_FLOAT128 = 0;
4157     }
4158 
4159 
4160 
4161 
4162     static if(!is(typeof(__HAVE_FLOAT128))) {
4163         enum __HAVE_FLOAT128 = 0;
4164     }
4165     static if(!is(typeof(__HAVE_FLOATN_NOT_TYPEDEF))) {
4166         enum __HAVE_FLOATN_NOT_TYPEDEF = 0;
4167     }
4168     static if(!is(typeof(__HAVE_DISTINCT_FLOAT64X))) {
4169         enum __HAVE_DISTINCT_FLOAT64X = 0;
4170     }
4171 
4172 
4173 
4174 
4175     static if(!is(typeof(__HAVE_DISTINCT_FLOAT32X))) {
4176         enum __HAVE_DISTINCT_FLOAT32X = 0;
4177     }
4178 
4179 
4180 
4181 
4182     static if(!is(typeof(__HAVE_DISTINCT_FLOAT64))) {
4183         enum __HAVE_DISTINCT_FLOAT64 = 0;
4184     }
4185 
4186 
4187 
4188 
4189     static if(!is(typeof(__HAVE_DISTINCT_FLOAT32))) {
4190         enum __HAVE_DISTINCT_FLOAT32 = 0;
4191     }
4192 
4193 
4194 
4195 
4196 
4197 
4198     static if(!is(typeof(__HAVE_FLOAT128X))) {
4199         enum __HAVE_FLOAT128X = 0;
4200     }
4201 
4202 
4203 
4204 
4205     static if(!is(typeof(__HAVE_FLOAT32X))) {
4206         enum __HAVE_FLOAT32X = 1;
4207     }
4208 
4209 
4210 
4211 
4212     static if(!is(typeof(__HAVE_FLOAT64))) {
4213         enum __HAVE_FLOAT64 = 1;
4214     }
4215 
4216 
4217 
4218 
4219     static if(!is(typeof(__HAVE_FLOAT32))) {
4220         enum __HAVE_FLOAT32 = 1;
4221     }
4222 
4223 
4224 
4225 
4226     static if(!is(typeof(__HAVE_FLOAT16))) {
4227         enum __HAVE_FLOAT16 = 0;
4228     }
4229     static if(!is(typeof(_BITS_ENDIANNESS_H))) {
4230         enum _BITS_ENDIANNESS_H = 1;
4231     }
4232     static if(!is(typeof(__PDP_ENDIAN))) {
4233         enum __PDP_ENDIAN = 3412;
4234     }
4235 
4236 
4237 
4238 
4239     static if(!is(typeof(__BIG_ENDIAN))) {
4240         enum __BIG_ENDIAN = 4321;
4241     }
4242 
4243 
4244 
4245 
4246     static if(!is(typeof(__LITTLE_ENDIAN))) {
4247         enum __LITTLE_ENDIAN = 1234;
4248     }
4249 
4250 
4251 
4252 
4253     static if(!is(typeof(_BITS_ENDIAN_H))) {
4254         enum _BITS_ENDIAN_H = 1;
4255     }
4256     static if(!is(typeof(__CPU_SETSIZE))) {
4257         enum __CPU_SETSIZE = 1024;
4258     }
4259 
4260 
4261 
4262 
4263     static if(!is(typeof(_BITS_CPU_SET_H))) {
4264         enum _BITS_CPU_SET_H = 1;
4265     }
4266     static if(!is(typeof(_BITS_BYTESWAP_H))) {
4267         enum _BITS_BYTESWAP_H = 1;
4268     }
4269 
4270 
4271 
4272 
4273 
4274 
4275     static if(!is(typeof(_ALLOCA_H))) {
4276         enum _ALLOCA_H = 1;
4277     }
4278 
4279 
4280 
4281 
4282     static if(!is(typeof(_SYS_CDEFS_H))) {
4283         enum _SYS_CDEFS_H = 1;
4284     }
4285     static if(!is(typeof(__glibc_c99_flexarr_available))) {
4286         enum __glibc_c99_flexarr_available = 1;
4287     }
4288     static if(!is(typeof(__HAVE_GENERIC_SELECTION))) {
4289         enum __HAVE_GENERIC_SELECTION = 1;
4290     }
4291 
4292 
4293 
4294 
4295     static if(!is(typeof(_SYS_SELECT_H))) {
4296         enum _SYS_SELECT_H = 1;
4297     }
4298     static if(!is(typeof(_SYS_TYPES_H))) {
4299         enum _SYS_TYPES_H = 1;
4300     }
4301     static if(!is(typeof(__BIT_TYPES_DEFINED__))) {
4302         enum __BIT_TYPES_DEFINED__ = 1;
4303     }
4304     static if(!is(typeof(_TIME_H))) {
4305         enum _TIME_H = 1;
4306     }
4307 
4308 
4309 
4310 
4311     static if(!is(typeof(TIME_UTC))) {
4312         enum TIME_UTC = 1;
4313     }
4314     static if(!is(typeof(__GNUC_VA_LIST))) {
4315         enum __GNUC_VA_LIST = 1;
4316     }
4317 }