1 module ldapd; 2 3 4 5 import core.stdc.config; 6 import core.stdc.stdarg: va_list; 7 static import core.simd; 8 static import std.conv; 9 10 struct Int128 { long lower; long upper; } 11 struct UInt128 { ulong lower; ulong upper; } 12 13 struct __locale_data { int dummy; } 14 15 16 17 alias _Bool = bool; 18 struct dpp { 19 static struct Opaque(int N) { 20 void[N] bytes; 21 } 22 23 static bool isEmpty(T)() { 24 return T.tupleof.length == 0; 25 } 26 static struct Move(T) { 27 T* ptr; 28 } 29 30 31 static auto move(T)(ref T value) { 32 return Move!T(&value); 33 } 34 mixin template EnumD(string name, T, string prefix) if(is(T == enum)) { 35 private static string _memberMixinStr(string member) { 36 import std.conv: text; 37 import std.array: replace; 38 return text(` `, member.replace(prefix, ""), ` = `, T.stringof, `.`, member, `,`); 39 } 40 private static string _enumMixinStr() { 41 import std.array: join; 42 string[] ret; 43 ret ~= "enum " ~ name ~ "{"; 44 static foreach(member; __traits(allMembers, T)) { 45 ret ~= _memberMixinStr(member); 46 } 47 ret ~= "}"; 48 return ret.join("\n"); 49 } 50 mixin(_enumMixinStr()); 51 } 52 } 53 54 extern(C) 55 { 56 alias size_t = c_ulong; 57 int strncasecmp_l(const(char)*, const(char)*, c_ulong, __locale_struct*) @nogc nothrow; 58 int strcasecmp_l(const(char)*, const(char)*, __locale_struct*) @nogc nothrow; 59 int strncasecmp(const(char)*, const(char)*, c_ulong) @nogc nothrow; 60 int strcasecmp(const(char)*, const(char)*) @nogc nothrow; 61 int ffsll(long) @nogc nothrow; 62 int ffsl(c_long) @nogc nothrow; 63 int ffs(int) @nogc nothrow; 64 char* rindex(const(char)*, int) @nogc nothrow; 65 char* index(const(char)*, int) @nogc nothrow; 66 void bzero(void*, c_ulong) @nogc nothrow; 67 void bcopy(const(void)*, void*, c_ulong) @nogc nothrow; 68 int bcmp(const(void)*, const(void)*, c_ulong) @nogc nothrow; 69 char* stpncpy(char*, const(char)*, c_ulong) @nogc nothrow; 70 char* __stpncpy(char*, const(char)*, c_ulong) @nogc nothrow; 71 char* stpcpy(char*, const(char)*) @nogc nothrow; 72 char* __stpcpy(char*, const(char)*) @nogc nothrow; 73 char* strsignal(int) @nogc nothrow; 74 char* strsep(char**, const(char)*) @nogc nothrow; 75 void explicit_bzero(void*, c_ulong) @nogc nothrow; 76 char* strerror_l(int, __locale_struct*) @nogc nothrow; 77 int strerror_r(int, char*, c_ulong) @nogc nothrow; 78 char* strerror(int) @nogc nothrow; 79 c_ulong strnlen(const(char)*, c_ulong) @nogc nothrow; 80 c_ulong strlen(const(char)*) @nogc nothrow; 81 char* strtok_r(char*, const(char)*, char**) @nogc nothrow; 82 char* __strtok_r(char*, const(char)*, char**) @nogc nothrow; 83 char* strtok(char*, const(char)*) @nogc nothrow; 84 char* strstr(const(char)*, const(char)*) @nogc nothrow; 85 char* strpbrk(const(char)*, const(char)*) @nogc nothrow; 86 c_ulong strspn(const(char)*, const(char)*) @nogc nothrow; 87 c_ulong strcspn(const(char)*, const(char)*) @nogc nothrow; 88 char* strrchr(const(char)*, int) @nogc nothrow; 89 char* strchr(const(char)*, int) @nogc nothrow; 90 char* strndup(const(char)*, c_ulong) @nogc nothrow; 91 char* strdup(const(char)*) @nogc nothrow; 92 c_ulong strxfrm_l(char*, const(char)*, c_ulong, __locale_struct*) @nogc nothrow; 93 int strcoll_l(const(char)*, const(char)*, __locale_struct*) @nogc nothrow; 94 c_ulong strxfrm(char*, const(char)*, c_ulong) @nogc nothrow; 95 int strcoll(const(char)*, const(char)*) @nogc nothrow; 96 int strncmp(const(char)*, const(char)*, c_ulong) @nogc nothrow; 97 int strcmp(const(char)*, const(char)*) @nogc nothrow; 98 char* strncat(char*, const(char)*, c_ulong) @nogc nothrow; 99 char* strcat(char*, const(char)*) @nogc nothrow; 100 char* strncpy(char*, const(char)*, c_ulong) @nogc nothrow; 101 char* strcpy(char*, const(char)*) @nogc nothrow; 102 void* memchr(const(void)*, int, c_ulong) @nogc nothrow; 103 int memcmp(const(void)*, const(void)*, c_ulong) @nogc nothrow; 104 void* memset(void*, int, c_ulong) @nogc nothrow; 105 void* memccpy(void*, const(void)*, int, c_ulong) @nogc nothrow; 106 void* memmove(void*, const(void)*, c_ulong) @nogc nothrow; 107 void* memcpy(void*, const(void)*, c_ulong) @nogc nothrow; 108 int ldap_parse_ntlm_bind_result(ldap*, ldapmsg*, berval*) @nogc nothrow; 109 int ldap_ntlm_bind(ldap*, const(char)*, c_ulong, berval*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 110 int ldap_parse_deref_control(ldap*, ldapcontrol**, LDAPDerefRes**) @nogc nothrow; 111 int ldap_parse_derefresponse_control(ldap*, ldapcontrol*, LDAPDerefRes**) @nogc nothrow; 112 void ldap_derefresponse_free(LDAPDerefRes*) @nogc nothrow; 113 int ldap_create_deref_control(ldap*, LDAPDerefSpec*, int, ldapcontrol**) @nogc nothrow; 114 int ldap_create_deref_control_value(ldap*, LDAPDerefSpec*, berval*) @nogc nothrow; 115 struct LDAPDerefRes 116 { 117 char* derefAttr; 118 berval derefVal; 119 LDAPDerefVal* attrVals; 120 LDAPDerefRes* next; 121 } 122 struct LDAPDerefVal 123 { 124 char* type; 125 berval* vals; 126 LDAPDerefVal* next; 127 } 128 struct LDAPDerefSpec 129 { 130 char* derefAttr; 131 char** attributes; 132 } 133 int ldap_create_assertion_control(ldap*, char*, int, ldapcontrol**) @nogc nothrow; 134 int ldap_create_assertion_control_value(ldap*, char*, berval*) @nogc nothrow; 135 int ldap_parse_session_tracking_control(ldap*, ldapcontrol*, berval*, berval*, berval*, berval*) @nogc nothrow; 136 int ldap_create_session_tracking_control(ldap*, char*, char*, char*, berval*, ldapcontrol**) @nogc nothrow; 137 int ldap_create_session_tracking_value(ldap*, char*, char*, char*, berval*, berval*) @nogc nothrow; 138 int ldap_sync_poll(ldap_sync_t*) @nogc nothrow; 139 int ldap_sync_init_refresh_and_persist(ldap_sync_t*) @nogc nothrow; 140 int ldap_sync_init_refresh_only(ldap_sync_t*) @nogc nothrow; 141 int ldap_sync_init(ldap_sync_t*, int) @nogc nothrow; 142 struct __locale_struct 143 { 144 __locale_data*[13] __locales; 145 const(ushort)* __ctype_b; 146 const(int)* __ctype_tolower; 147 const(int)* __ctype_toupper; 148 const(char)*[13] __names; 149 } 150 alias __locale_t = __locale_struct*; 151 alias locale_t = __locale_struct*; 152 void ldap_sync_destroy(ldap_sync_t*, int) @nogc nothrow; 153 ldap_sync_t* ldap_sync_initialize(ldap_sync_t*) @nogc nothrow; 154 int ldap_refresh_s(ldap*, berval*, int, int*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 155 int ldap_refresh(ldap*, berval*, int, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 156 int ldap_parse_refresh(ldap*, ldapmsg*, int*) @nogc nothrow; 157 const(char)* ldap_passwordpolicy_err2txt(passpolicyerror_enum) @nogc nothrow; 158 int ldap_parse_passwordpolicy_control(ldap*, ldapcontrol*, int*, int*, passpolicyerror_enum*) @nogc nothrow; 159 int ldap_create_passwordpolicy_control(ldap*, ldapcontrol**) @nogc nothrow; 160 enum passpolicyerror_enum 161 { 162 PP_passwordExpired = 0, 163 PP_accountLocked = 1, 164 PP_changeAfterReset = 2, 165 PP_passwordModNotAllowed = 3, 166 PP_mustSupplyOldPassword = 4, 167 PP_insufficientPasswordQuality = 5, 168 PP_passwordTooShort = 6, 169 PP_passwordTooYoung = 7, 170 PP_passwordInHistory = 8, 171 PP_noError = 65535, 172 } 173 enum PP_passwordExpired = passpolicyerror_enum.PP_passwordExpired; 174 enum PP_accountLocked = passpolicyerror_enum.PP_accountLocked; 175 enum PP_changeAfterReset = passpolicyerror_enum.PP_changeAfterReset; 176 enum PP_passwordModNotAllowed = passpolicyerror_enum.PP_passwordModNotAllowed; 177 enum PP_mustSupplyOldPassword = passpolicyerror_enum.PP_mustSupplyOldPassword; 178 enum PP_insufficientPasswordQuality = passpolicyerror_enum.PP_insufficientPasswordQuality; 179 enum PP_passwordTooShort = passpolicyerror_enum.PP_passwordTooShort; 180 enum PP_passwordTooYoung = passpolicyerror_enum.PP_passwordTooYoung; 181 enum PP_passwordInHistory = passpolicyerror_enum.PP_passwordInHistory; 182 enum PP_noError = passpolicyerror_enum.PP_noError; 183 alias LDAPPasswordPolicyError = passpolicyerror_enum; 184 int ldap_passwd_s(ldap*, berval*, berval*, berval*, berval*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 185 int ldap_passwd(ldap*, berval*, berval*, berval*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 186 int ldap_parse_passwd(ldap*, ldapmsg*, berval*) @nogc nothrow; 187 int ldap_whoami_s(ldap*, berval**, ldapcontrol**, ldapcontrol**) @nogc nothrow; 188 int ldap_whoami(ldap*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 189 int ldap_parse_whoami(ldap*, ldapmsg*, berval**) @nogc nothrow; 190 int ldap_parse_vlvresponse_control(ldap*, ldapcontrol*, int*, int*, berval**, int*) @nogc nothrow; 191 int ldap_create_vlv_control(ldap*, ldapvlvinfo*, ldapcontrol**) @nogc nothrow; 192 int ldap_create_vlv_control_value(ldap*, ldapvlvinfo*, berval*) @nogc nothrow; 193 struct ldapvlvinfo 194 { 195 int ldvlv_version; 196 int ldvlv_before_count; 197 int ldvlv_after_count; 198 int ldvlv_offset; 199 int ldvlv_count; 200 berval* ldvlv_attrvalue; 201 berval* ldvlv_context; 202 void* ldvlv_extradata; 203 } 204 alias LDAPVLVInfo = ldapvlvinfo; 205 int ldap_parse_sortresponse_control(ldap*, ldapcontrol*, int*, char**) @nogc nothrow; 206 int ldap_create_sort_control(ldap*, ldapsortkey**, int, ldapcontrol**) @nogc nothrow; 207 int ldap_create_sort_control_value(ldap*, ldapsortkey**, berval*) @nogc nothrow; 208 void ldap_free_sort_keylist(ldapsortkey**) @nogc nothrow; 209 int ldap_create_sort_keylist(ldapsortkey***, char*) @nogc nothrow; 210 struct ldapsortkey 211 { 212 char* attributeType; 213 char* orderingRule; 214 int reverseOrder; 215 } 216 alias LDAPSortKey = ldapsortkey; 217 int ldap_parse_pageresponse_control(ldap*, ldapcontrol*, int*, berval*) @nogc nothrow; 218 int ldap_create_page_control(ldap*, int, berval*, int, ldapcontrol**) @nogc nothrow; 219 int ldap_create_page_control_value(ldap*, int, berval*, berval*) @nogc nothrow; 220 alias BER_ERRNO_FN = int* function(); 221 alias BER_LOG_PRINT_FN = void function(const(char)*); 222 alias BER_MEMALLOC_FN = void* function(c_ulong, void*); 223 alias BER_MEMCALLOC_FN = void* function(c_ulong, c_ulong, void*); 224 alias BER_MEMREALLOC_FN = void* function(void*, c_ulong, void*); 225 alias BER_MEMFREE_FN = void function(void*, void*); 226 alias BerMemoryFunctions = lber_memory_fns; 227 struct lber_memory_fns 228 { 229 void* function(c_ulong, void*) bmf_malloc; 230 void* function(c_ulong, c_ulong, void*) bmf_calloc; 231 void* function(void*, c_ulong, void*) bmf_realloc; 232 void function(void*, void*) bmf_free; 233 } 234 int ldap_turn_s(ldap*, int, const(char)*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 235 int ldap_turn(ldap*, int, const(char)*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 236 int ldap_cancel_s(ldap*, int, ldapcontrol**, ldapcontrol**) @nogc nothrow; 237 int ldap_cancel(ldap*, int, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 238 void ldap_free_urldesc(ldap_url_desc*) @nogc nothrow; 239 char* ldap_url_desc2str(ldap_url_desc*) @nogc nothrow; 240 extern __gshared char ber_pvt_opt_on; 241 int ldap_url_parse(const(char)*, ldap_url_desc**) @nogc nothrow; 242 alias BerElement = berelement; 243 struct berelement; 244 alias Sockbuf = sockbuf; 245 struct sockbuf; 246 alias Sockbuf_IO = sockbuf_io; 247 struct sockbuf_io 248 { 249 int function(sockbuf_io_desc*, void*) sbi_setup; 250 int function(sockbuf_io_desc*) sbi_remove; 251 int function(sockbuf_io_desc*, int, void*) sbi_ctrl; 252 c_long function(sockbuf_io_desc*, void*, c_ulong) sbi_read; 253 c_long function(sockbuf_io_desc*, void*, c_ulong) sbi_write; 254 int function(sockbuf_io_desc*) sbi_close; 255 } 256 alias Sockbuf_IO_Desc = sockbuf_io_desc; 257 struct sockbuf_io_desc 258 { 259 int sbiod_level; 260 sockbuf* sbiod_sb; 261 sockbuf_io* sbiod_io; 262 void* sbiod_pvt; 263 sockbuf_io_desc* sbiod_next; 264 } 265 int ldap_is_ldapi_url(const(char)*) @nogc nothrow; 266 alias BerValue = berval; 267 struct berval 268 { 269 c_ulong bv_len; 270 char* bv_val; 271 } 272 alias BerVarray = berval*; 273 void ber_error_print(const(char)*) @nogc nothrow; 274 void ber_bprint(const(char)*, c_ulong) @nogc nothrow; 275 void ber_dump(berelement*, int) @nogc nothrow; 276 alias BERDecodeCallback = int function(berelement*, void*, int); 277 c_ulong ber_get_tag(berelement*) @nogc nothrow; 278 c_ulong ber_skip_tag(berelement*, c_ulong*) @nogc nothrow; 279 c_ulong ber_peek_tag(berelement*, c_ulong*) @nogc nothrow; 280 c_ulong ber_skip_element(berelement*, berval*) @nogc nothrow; 281 c_ulong ber_peek_element(const(berelement)*, berval*) @nogc nothrow; 282 c_ulong ber_get_int(berelement*, int*) @nogc nothrow; 283 c_ulong ber_get_enum(berelement*, int*) @nogc nothrow; 284 c_ulong ber_get_stringb(berelement*, char*, c_ulong*) @nogc nothrow; 285 c_ulong ber_get_stringbv(berelement*, berval*, int) @nogc nothrow; 286 c_ulong ber_get_stringa(berelement*, char**) @nogc nothrow; 287 c_ulong ber_get_stringal(berelement*, berval**) @nogc nothrow; 288 c_ulong ber_get_bitstringa(berelement*, char**, c_ulong*) @nogc nothrow; 289 c_ulong ber_get_null(berelement*) @nogc nothrow; 290 c_ulong ber_get_boolean(berelement*, int*) @nogc nothrow; 291 c_ulong ber_first_element(berelement*, c_ulong*, char**) @nogc nothrow; 292 c_ulong ber_next_element(berelement*, c_ulong*, const(char)*) @nogc nothrow; 293 c_ulong ber_scanf(berelement*, const(char)*, ...) @nogc nothrow; 294 int ber_decode_oid(berval*, berval*) @nogc nothrow; 295 int ber_encode_oid(berval*, berval*) @nogc nothrow; 296 alias BEREncodeCallback = int function(berelement*, void*); 297 int ber_put_enum(berelement*, int, c_ulong) @nogc nothrow; 298 int ber_put_int(berelement*, int, c_ulong) @nogc nothrow; 299 int ber_put_ostring(berelement*, const(char)*, c_ulong, c_ulong) @nogc nothrow; 300 int ber_put_berval(berelement*, berval*, c_ulong) @nogc nothrow; 301 int ber_put_string(berelement*, const(char)*, c_ulong) @nogc nothrow; 302 int ber_put_bitstring(berelement*, const(char)*, c_ulong, c_ulong) @nogc nothrow; 303 int ber_put_null(berelement*, c_ulong) @nogc nothrow; 304 int ber_put_boolean(berelement*, int, c_ulong) @nogc nothrow; 305 int ber_start_seq(berelement*, c_ulong) @nogc nothrow; 306 int ber_start_set(berelement*, c_ulong) @nogc nothrow; 307 int ber_put_seq(berelement*) @nogc nothrow; 308 int ber_put_set(berelement*) @nogc nothrow; 309 int ber_printf(berelement*, const(char)*, ...) @nogc nothrow; 310 c_long ber_skip_data(berelement*, c_ulong) @nogc nothrow; 311 c_long ber_read(berelement*, char*, c_ulong) @nogc nothrow; 312 c_long ber_write(berelement*, const(char)*, c_ulong, int) @nogc nothrow; 313 void ber_free(berelement*, int) @nogc nothrow; 314 void ber_free_buf(berelement*) @nogc nothrow; 315 int ber_flush2(sockbuf*, berelement*, int) @nogc nothrow; 316 int ldap_is_ldaps_url(const(char)*) @nogc nothrow; 317 int ber_flush(sockbuf*, berelement*, int) @nogc nothrow; 318 berelement* ber_alloc() @nogc nothrow; 319 berelement* der_alloc() @nogc nothrow; 320 berelement* ber_alloc_t(int) @nogc nothrow; 321 berelement* ber_dup(berelement*) @nogc nothrow; 322 c_ulong ber_get_next(sockbuf*, c_ulong*, berelement*) @nogc nothrow; 323 void ber_init2(berelement*, berval*, int) @nogc nothrow; 324 void ber_init_w_nullc(berelement*, int) @nogc nothrow; 325 void ber_reset(berelement*, int) @nogc nothrow; 326 berelement* ber_init(berval*) @nogc nothrow; 327 int ber_flatten(berelement*, berval**) @nogc nothrow; 328 int ber_flatten2(berelement*, berval*, int) @nogc nothrow; 329 int ber_remaining(berelement*) @nogc nothrow; 330 int ber_get_option(void*, int, void*) @nogc nothrow; 331 int ber_set_option(void*, int, const(void)*) @nogc nothrow; 332 sockbuf* ber_sockbuf_alloc() @nogc nothrow; 333 void ber_sockbuf_free(sockbuf*) @nogc nothrow; 334 int ber_sockbuf_add_io(sockbuf*, sockbuf_io*, int, void*) @nogc nothrow; 335 int ber_sockbuf_remove_io(sockbuf*, sockbuf_io*, int) @nogc nothrow; 336 int ber_sockbuf_ctrl(sockbuf*, int, void*) @nogc nothrow; 337 extern __gshared sockbuf_io ber_sockbuf_io_tcp; 338 extern __gshared sockbuf_io ber_sockbuf_io_readahead; 339 extern __gshared sockbuf_io ber_sockbuf_io_fd; 340 extern __gshared sockbuf_io ber_sockbuf_io_debug; 341 extern __gshared sockbuf_io ber_sockbuf_io_udp; 342 void* ber_memalloc(c_ulong) @nogc nothrow; 343 void* ber_memrealloc(void*, c_ulong) @nogc nothrow; 344 void* ber_memcalloc(c_ulong, c_ulong) @nogc nothrow; 345 void ber_memfree(void*) @nogc nothrow; 346 void ber_memvfree(void**) @nogc nothrow; 347 void ber_bvfree(berval*) @nogc nothrow; 348 void ber_bvecfree(berval**) @nogc nothrow; 349 int ber_bvecadd(berval***, berval*) @nogc nothrow; 350 berval* ber_dupbv(berval*, berval*) @nogc nothrow; 351 berval* ber_bvdup(berval*) @nogc nothrow; 352 berval* ber_mem2bv(const(char)*, c_ulong, int, berval*) @nogc nothrow; 353 berval* ber_str2bv(const(char)*, c_ulong, int, berval*) @nogc nothrow; 354 int ldap_is_ldap_url(const(char)*) @nogc nothrow; 355 char* ber_strdup(const(char)*) @nogc nothrow; 356 c_ulong ber_strnlen(const(char)*, c_ulong) @nogc nothrow; 357 char* ber_strndup(const(char)*, c_ulong) @nogc nothrow; 358 berval* ber_bvreplace(berval*, const(berval)*) @nogc nothrow; 359 void ber_bvarray_free(berval*) @nogc nothrow; 360 int ber_bvarray_add(berval**, berval*) @nogc nothrow; 361 int* ber_errno_addr() @nogc nothrow; 362 void ldap_mods_free(ldapmod**, int) @nogc nothrow; 363 char* ldap_strdup(const(char)*) @nogc nothrow; 364 void ldap_memvfree(void**) @nogc nothrow; 365 alias ber_int_t = int; 366 alias ber_sint_t = int; 367 alias ber_uint_t = uint; 368 alias ber_tag_t = c_ulong; 369 alias ber_socket_t = int; 370 alias ber_len_t = c_ulong; 371 alias ber_slen_t = c_long; 372 void ldap_memfree(void*) @nogc nothrow; 373 void* ldap_memcalloc(c_ulong, c_ulong) @nogc nothrow; 374 void* ldap_memrealloc(void*, c_ulong) @nogc nothrow; 375 void* ldap_memalloc(c_ulong) @nogc nothrow; 376 int ldap_put_vrFilter(berelement*, const(char)*) @nogc nothrow; 377 int ldap_destroy(ldap*) @nogc nothrow; 378 int ldap_unbind_ext_s(ldap*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 379 int ldap_unbind_ext(ldap*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 380 int ldap_search_ext_s(ldap*, const(char)*, int, const(char)*, char**, int, ldapcontrol**, ldapcontrol**, timeval*, int, ldapmsg**) @nogc nothrow; 381 int ldap_search_ext(ldap*, const(char)*, int, const(char)*, char**, int, ldapcontrol**, ldapcontrol**, timeval*, int, int*) @nogc nothrow; 382 int ldap_bv2escaped_filter_value(berval*, berval*) @nogc nothrow; 383 int ldap_msgdelete(ldap*, int) @nogc nothrow; 384 int ldap_msgfree(ldapmsg*) @nogc nothrow; 385 int ldap_msgid(ldapmsg*) @nogc nothrow; 386 int ldap_msgtype(ldapmsg*) @nogc nothrow; 387 int ldap_result(ldap*, int, int, timeval*, ldapmsg**) @nogc nothrow; 388 void ldap_value_free_len(berval**) @nogc nothrow; 389 int ldap_count_values_len(berval**) @nogc nothrow; 390 berval** ldap_get_values_len(ldap*, ldapmsg*, const(char)*) @nogc nothrow; 391 char* ldap_next_attribute(ldap*, ldapmsg*, berelement*) @nogc nothrow; 392 char* ldap_first_attribute(ldap*, ldapmsg*, berelement**) @nogc nothrow; 393 int ldap_get_attribute_ber(ldap*, ldapmsg*, berelement*, berval*, berval**) @nogc nothrow; 394 int ldap_get_dn_ber(ldap*, ldapmsg*, berelement**, berval*) @nogc nothrow; 395 char* ldap_dn2ad_canonical(const(char)*) @nogc nothrow; 396 char* ldap_dcedn2dn(const(char)*) @nogc nothrow; 397 char* ldap_dn2dcedn(const(char)*) @nogc nothrow; 398 int ldap_X509dn2bv(void*, berval*, int function(ldap_ava***, uint, void*), uint) @nogc nothrow; 399 alias LDAPDN_rewrite_func = int function(ldap_ava***, uint, void*); 400 char** ldap_explode_rdn(const(char)*, int) @nogc nothrow; 401 char** ldap_explode_dn(const(char)*, int) @nogc nothrow; 402 char* ldap_dn2ufn(const(char)*) @nogc nothrow; 403 int ldap_dn_normalize(const(char)*, uint, char**, uint) @nogc nothrow; 404 int ldap_rdn2str(ldap_ava**, char**, uint) @nogc nothrow; 405 alias LDAPAPIInfo = ldapapiinfo; 406 struct ldapapiinfo 407 { 408 int ldapai_info_version; 409 int ldapai_api_version; 410 int ldapai_protocol_version; 411 char** ldapai_extensions; 412 char* ldapai_vendor_name; 413 int ldapai_vendor_version; 414 } 415 alias LDAPAPIFeatureInfo = ldap_apifeature_info; 416 struct ldap_apifeature_info 417 { 418 int ldapaif_info_version; 419 char* ldapaif_name; 420 int ldapaif_version; 421 } 422 alias LDAPControl = ldapcontrol; 423 struct ldapcontrol 424 { 425 char* ldctl_oid; 426 berval ldctl_value; 427 char ldctl_iscritical; 428 } 429 int ldap_rdn2bv(ldap_ava**, berval*, uint) @nogc nothrow; 430 int ldap_str2rdn(const(char)*, ldap_ava***, char**, uint) @nogc nothrow; 431 int ldap_bv2rdn(berval*, ldap_ava***, char**, uint) @nogc nothrow; 432 int ldap_dn2str(ldap_ava***, char**, uint) @nogc nothrow; 433 int ldap_dn2bv(ldap_ava***, berval*, uint) @nogc nothrow; 434 int ldap_str2dn(const(char)*, ldap_ava****, uint) @nogc nothrow; 435 int ldap_bv2dn(berval*, ldap_ava****, uint) @nogc nothrow; 436 void ldap_dnfree(ldap_ava***) @nogc nothrow; 437 void ldap_rdnfree(ldap_ava**) @nogc nothrow; 438 alias LDAPDN = ldap_ava***; 439 alias LDAPRDN = ldap_ava**; 440 struct ldap_ava 441 { 442 berval la_attr; 443 berval la_value; 444 uint la_flags; 445 void* la_private; 446 } 447 alias LDAPAVA = ldap_ava; 448 char* ldap_get_dn(ldap*, ldapmsg*) @nogc nothrow; 449 void ldap_add_result_entry(ldapmsg**, ldapmsg*) @nogc nothrow; 450 ldapmsg* ldap_delete_result_entry(ldapmsg**, ldapmsg*) @nogc nothrow; 451 int ldap_get_entry_controls(ldap*, ldapmsg*, ldapcontrol***) @nogc nothrow; 452 int ldap_count_entries(ldap*, ldapmsg*) @nogc nothrow; 453 ldapmsg* ldap_next_entry(ldap*, ldapmsg*) @nogc nothrow; 454 ldapmsg* ldap_first_entry(ldap*, ldapmsg*) @nogc nothrow; 455 int ldap_parse_reference(ldap*, ldapmsg*, char***, ldapcontrol***, int) @nogc nothrow; 456 int ldap_count_references(ldap*, ldapmsg*) @nogc nothrow; 457 ldapmsg* ldap_next_reference(ldap*, ldapmsg*) @nogc nothrow; 458 ldapmsg* ldap_first_reference(ldap*, ldapmsg*) @nogc nothrow; 459 int ldap_count_messages(ldap*, ldapmsg*) @nogc nothrow; 460 ldapmsg* ldap_next_message(ldap*, ldapmsg*) @nogc nothrow; 461 ldapmsg* ldap_first_message(ldap*, ldapmsg*) @nogc nothrow; 462 int ldap_start_tls_s(ldap*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 463 int ldap_install_tls(ldap*) @nogc nothrow; 464 int ldap_start_tls(ldap*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 465 int ldap_tls_inplace(ldap*) @nogc nothrow; 466 ldap* ldap_dup(ldap*) @nogc nothrow; 467 int ldap_initialize(ldap**, const(char)*) @nogc nothrow; 468 int ldap_create(ldap**) @nogc nothrow; 469 int ldap_rename_s(ldap*, const(char)*, const(char)*, const(char)*, int, ldapcontrol**, ldapcontrol**) @nogc nothrow; 470 int ldap_rename(ldap*, const(char)*, const(char)*, const(char)*, int, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 471 int ldap_modify_ext_s(ldap*, const(char)*, ldapmod**, ldapcontrol**, ldapcontrol**) @nogc nothrow; 472 int ldap_modify_ext(ldap*, const(char)*, ldapmod**, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 473 int ldap_gssapi_bind_s(ldap*, const(char)*, const(char)*) @nogc nothrow; 474 int ldap_gssapi_bind(ldap*, const(char)*, const(char)*) @nogc nothrow; 475 char* ldap_err2string(int) @nogc nothrow; 476 int ldap_parse_result(ldap*, ldapmsg*, int*, char**, char**, char***, ldapcontrol***, int) @nogc nothrow; 477 int ldap_delete_ext_s(ldap*, const(char)*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 478 int ldap_delete_ext(ldap*, const(char)*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 479 int ldap_compare_ext_s(ldap*, const(char)*, const(char)*, berval*, ldapcontrol**, ldapcontrol**) @nogc nothrow; 480 int ldap_compare_ext(ldap*, const(char)*, const(char)*, berval*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 481 int ldap_parse_sasl_bind_result(ldap*, ldapmsg*, berval**, int) @nogc nothrow; 482 int ldap_sasl_bind_s(ldap*, const(char)*, const(char)*, berval*, ldapcontrol**, ldapcontrol**, berval**) @nogc nothrow; 483 int ldap_sasl_interactive_bind_s(ldap*, const(char)*, const(char)*, ldapcontrol**, ldapcontrol**, uint, int function(ldap*, uint, void*, void*), void*) @nogc nothrow; 484 int ldap_sasl_interactive_bind(ldap*, const(char)*, const(char)*, ldapcontrol**, ldapcontrol**, uint, int function(ldap*, uint, void*, void*), void*, ldapmsg*, const(char)**, int*) @nogc nothrow; 485 alias LDAP_SASL_INTERACT_PROC = int function(ldap*, uint, void*, void*); 486 int ldap_sasl_bind(ldap*, const(char)*, const(char)*, berval*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 487 int ldap_add_ext_s(ldap*, const(char)*, ldapmod**, ldapcontrol**, ldapcontrol**) @nogc nothrow; 488 int ldap_add_ext(ldap*, const(char)*, ldapmod**, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 489 int ldap_abandon_ext(ldap*, int, ldapcontrol**, ldapcontrol**) @nogc nothrow; 490 int ldap_parse_intermediate(ldap*, ldapmsg*, char**, berval**, ldapcontrol***, int) @nogc nothrow; 491 int ldap_parse_extended_result(ldap*, ldapmsg*, char**, berval**, int) @nogc nothrow; 492 int ldap_extended_operation_s(ldap*, const(char)*, berval*, ldapcontrol**, ldapcontrol**, char**, berval**) @nogc nothrow; 493 int ldap_extended_operation(ldap*, const(char)*, berval*, ldapcontrol**, ldapcontrol**, int*) @nogc nothrow; 494 int ldap_domain2hostlist(const(char)*, char**) @nogc nothrow; 495 int ldap_dn2domain(const(char)*, char**) @nogc nothrow; 496 int ldap_domain2dn(const(char)*, char**) @nogc nothrow; 497 ldapcontrol* ldap_control_dup(const(ldapcontrol)*) @nogc nothrow; 498 ldapcontrol** ldap_controls_dup(ldapcontrol**) @nogc nothrow; 499 void ldap_controls_free(ldapcontrol**) @nogc nothrow; 500 void ldap_control_free(ldapcontrol*) @nogc nothrow; 501 ldapcontrol* ldap_control_find(const(char)*, ldapcontrol**, ldapcontrol***) @nogc nothrow; 502 int ldap_control_create(const(char)*, int, berval*, int, ldapcontrol**) @nogc nothrow; 503 int ldap_set_urllist_proc(ldap*, int function(ldap*, ldap_url_desc**, ldap_url_desc**, void*), void*) @nogc nothrow; 504 alias LDAP_URLLIST_PROC = int function(ldap*, ldap_url_desc**, ldap_url_desc**, void*); 505 int ldap_set_nextref_proc(ldap*, int function(ldap*, char***, int*, void*), void*) @nogc nothrow; 506 alias LDAP_NEXTREF_PROC = int function(ldap*, char***, int*, void*); 507 int ldap_set_rebind_proc(ldap*, int function(ldap*, const(char)*, c_ulong, int, void*), void*) @nogc nothrow; 508 alias LDAP_REBIND_PROC = int function(ldap*, const(char)*, c_ulong, int, void*); 509 int ldap_set_option(ldap*, int, const(void)*) @nogc nothrow; 510 int ldap_get_option(ldap*, int, void*) @nogc nothrow; 511 512 struct timeval { 513 import core.stdc.time; 514 time_t tv_sec; 515 long tv_usec; 516 } 517 518 alias ldap_conn_del_f = void function(ldap*, sockbuf*, ldap_conncb*); 519 alias ldap_conn_add_f = int function(ldap*, sockbuf*, ldap_url_desc*, sockaddr*, ldap_conncb*); 520 struct sockaddr; 521 struct ldap_conncb 522 { 523 int function(ldap*, sockbuf*, ldap_url_desc*, sockaddr*, ldap_conncb*) lc_add; 524 void function(ldap*, sockbuf*, ldap_conncb*) lc_del; 525 void* lc_arg; 526 } 527 alias ldap_sync_search_result_f = int function(ldap_sync_t*, ldapmsg*, int); 528 alias ldap_sync_intermediate_f = int function(ldap_sync_t*, ldapmsg*, berval*, ldap_sync_refresh_t); 529 alias ldap_sync_search_reference_f = int function(ldap_sync_t*, ldapmsg*); 530 alias ldap_sync_search_entry_f = int function(ldap_sync_t*, ldapmsg*, berval*, ldap_sync_refresh_t); 531 enum _Anonymous_0 532 { 533 LDAP_SYNC_CAPI_NONE = -1, 534 LDAP_SYNC_CAPI_PHASE_FLAG = 16, 535 LDAP_SYNC_CAPI_IDSET_FLAG = 32, 536 LDAP_SYNC_CAPI_DONE_FLAG = 64, 537 LDAP_SYNC_CAPI_PRESENT = 0, 538 LDAP_SYNC_CAPI_ADD = 1, 539 LDAP_SYNC_CAPI_MODIFY = 2, 540 LDAP_SYNC_CAPI_DELETE = 3, 541 LDAP_SYNC_CAPI_PRESENTS = 16, 542 LDAP_SYNC_CAPI_DELETES = 19, 543 LDAP_SYNC_CAPI_PRESENTS_IDSET = 48, 544 LDAP_SYNC_CAPI_DELETES_IDSET = 51, 545 LDAP_SYNC_CAPI_DONE = 80, 546 } 547 enum LDAP_SYNC_CAPI_NONE = _Anonymous_0.LDAP_SYNC_CAPI_NONE; 548 enum LDAP_SYNC_CAPI_PHASE_FLAG = _Anonymous_0.LDAP_SYNC_CAPI_PHASE_FLAG; 549 enum LDAP_SYNC_CAPI_IDSET_FLAG = _Anonymous_0.LDAP_SYNC_CAPI_IDSET_FLAG; 550 enum LDAP_SYNC_CAPI_DONE_FLAG = _Anonymous_0.LDAP_SYNC_CAPI_DONE_FLAG; 551 enum LDAP_SYNC_CAPI_PRESENT = _Anonymous_0.LDAP_SYNC_CAPI_PRESENT; 552 enum LDAP_SYNC_CAPI_ADD = _Anonymous_0.LDAP_SYNC_CAPI_ADD; 553 enum LDAP_SYNC_CAPI_MODIFY = _Anonymous_0.LDAP_SYNC_CAPI_MODIFY; 554 enum LDAP_SYNC_CAPI_DELETE = _Anonymous_0.LDAP_SYNC_CAPI_DELETE; 555 enum LDAP_SYNC_CAPI_PRESENTS = _Anonymous_0.LDAP_SYNC_CAPI_PRESENTS; 556 enum LDAP_SYNC_CAPI_DELETES = _Anonymous_0.LDAP_SYNC_CAPI_DELETES; 557 enum LDAP_SYNC_CAPI_PRESENTS_IDSET = _Anonymous_0.LDAP_SYNC_CAPI_PRESENTS_IDSET; 558 enum LDAP_SYNC_CAPI_DELETES_IDSET = _Anonymous_0.LDAP_SYNC_CAPI_DELETES_IDSET; 559 enum LDAP_SYNC_CAPI_DONE = _Anonymous_0.LDAP_SYNC_CAPI_DONE; 560 alias ldap_sync_refresh_t = _Anonymous_0; 561 struct ldap_sync_t 562 { 563 char* ls_base; 564 int ls_scope; 565 char* ls_filter; 566 char** ls_attrs; 567 int ls_timelimit; 568 int ls_sizelimit; 569 int ls_timeout; 570 int function(ldap_sync_t*, ldapmsg*, berval*, ldap_sync_refresh_t) ls_search_entry; 571 int function(ldap_sync_t*, ldapmsg*) ls_search_reference; 572 int function(ldap_sync_t*, ldapmsg*, berval*, ldap_sync_refresh_t) ls_intermediate; 573 int function(ldap_sync_t*, ldapmsg*, int) ls_search_result; 574 void* ls_private; 575 ldap* ls_ld; 576 int ls_msgid; 577 int ls_reloadHint; 578 berval ls_cookie; 579 ldap_sync_refresh_t ls_refreshPhase; 580 } 581 struct ldap_url_desc 582 { 583 ldap_url_desc* lud_next; 584 char* lud_scheme; 585 char* lud_host; 586 int lud_port; 587 char* lud_dn; 588 char** lud_attrs; 589 int lud_scope; 590 char* lud_filter; 591 char** lud_exts; 592 int lud_crit_exts; 593 } 594 alias LDAPURLDesc = ldap_url_desc; 595 alias LDAPMessage = ldapmsg; 596 struct ldapmsg; 597 alias LDAPMod = ldapmod; 598 struct ldapmod 599 { 600 int mod_op; 601 char* mod_type; 602 union mod_vals_u 603 { 604 char** modv_strvals; 605 berval** modv_bvals; 606 } 607 ldapmod.mod_vals_u mod_vals; 608 } 609 struct ldap; 610 alias LDAP = ldap; 611 612 613 614 static if(!is(typeof(LDAP_MOD_DELETE))) { 615 private enum enumMixinStr_LDAP_MOD_DELETE = `enum LDAP_MOD_DELETE = ( 0x0001 );`; 616 static if(is(typeof({ mixin(enumMixinStr_LDAP_MOD_DELETE); }))) { 617 mixin(enumMixinStr_LDAP_MOD_DELETE); 618 } 619 } 620 621 622 623 624 static if(!is(typeof(LDAP_MOD_REPLACE))) { 625 private enum enumMixinStr_LDAP_MOD_REPLACE = `enum LDAP_MOD_REPLACE = ( 0x0002 );`; 626 static if(is(typeof({ mixin(enumMixinStr_LDAP_MOD_REPLACE); }))) { 627 mixin(enumMixinStr_LDAP_MOD_REPLACE); 628 } 629 } 630 631 632 633 634 static if(!is(typeof(LDAP_MOD_INCREMENT))) { 635 private enum enumMixinStr_LDAP_MOD_INCREMENT = `enum LDAP_MOD_INCREMENT = ( 0x0003 );`; 636 static if(is(typeof({ mixin(enumMixinStr_LDAP_MOD_INCREMENT); }))) { 637 mixin(enumMixinStr_LDAP_MOD_INCREMENT); 638 } 639 } 640 641 642 643 644 static if(!is(typeof(LDAP_MOD_BVALUES))) { 645 private enum enumMixinStr_LDAP_MOD_BVALUES = `enum LDAP_MOD_BVALUES = ( 0x0080 );`; 646 static if(is(typeof({ mixin(enumMixinStr_LDAP_MOD_BVALUES); }))) { 647 mixin(enumMixinStr_LDAP_MOD_BVALUES); 648 } 649 } 650 651 652 653 654 static if(!is(typeof(mod_values))) { 655 private enum enumMixinStr_mod_values = `enum mod_values = mod_vals . modv_strvals;`; 656 static if(is(typeof({ mixin(enumMixinStr_mod_values); }))) { 657 mixin(enumMixinStr_mod_values); 658 } 659 } 660 661 662 663 664 static if(!is(typeof(mod_bvalues))) { 665 private enum enumMixinStr_mod_bvalues = `enum mod_bvalues = mod_vals . modv_bvals;`; 666 static if(is(typeof({ mixin(enumMixinStr_mod_bvalues); }))) { 667 mixin(enumMixinStr_mod_bvalues); 668 } 669 } 670 671 672 673 674 static if(!is(typeof(LDAP_MOD_ADD))) { 675 private enum enumMixinStr_LDAP_MOD_ADD = `enum LDAP_MOD_ADD = ( 0x0000 );`; 676 static if(is(typeof({ mixin(enumMixinStr_LDAP_MOD_ADD); }))) { 677 mixin(enumMixinStr_LDAP_MOD_ADD); 678 } 679 } 680 681 682 683 684 static if(!is(typeof(LDAP_MOD_OP))) { 685 private enum enumMixinStr_LDAP_MOD_OP = `enum LDAP_MOD_OP = ( 0x0007 );`; 686 static if(is(typeof({ mixin(enumMixinStr_LDAP_MOD_OP); }))) { 687 mixin(enumMixinStr_LDAP_MOD_OP); 688 } 689 } 690 691 692 693 694 static if(!is(typeof(LDAP_DEREF_NEVER))) { 695 private enum enumMixinStr_LDAP_DEREF_NEVER = `enum LDAP_DEREF_NEVER = 0x00;`; 696 static if(is(typeof({ mixin(enumMixinStr_LDAP_DEREF_NEVER); }))) { 697 mixin(enumMixinStr_LDAP_DEREF_NEVER); 698 } 699 } 700 701 702 703 704 static if(!is(typeof(LDAP_DEREF_SEARCHING))) { 705 private enum enumMixinStr_LDAP_DEREF_SEARCHING = `enum LDAP_DEREF_SEARCHING = 0x01;`; 706 static if(is(typeof({ mixin(enumMixinStr_LDAP_DEREF_SEARCHING); }))) { 707 mixin(enumMixinStr_LDAP_DEREF_SEARCHING); 708 } 709 } 710 711 712 713 714 static if(!is(typeof(LDAP_DEREF_FINDING))) { 715 private enum enumMixinStr_LDAP_DEREF_FINDING = `enum LDAP_DEREF_FINDING = 0x02;`; 716 static if(is(typeof({ mixin(enumMixinStr_LDAP_DEREF_FINDING); }))) { 717 mixin(enumMixinStr_LDAP_DEREF_FINDING); 718 } 719 } 720 721 722 723 724 static if(!is(typeof(LDAP_DEREF_ALWAYS))) { 725 private enum enumMixinStr_LDAP_DEREF_ALWAYS = `enum LDAP_DEREF_ALWAYS = 0x03;`; 726 static if(is(typeof({ mixin(enumMixinStr_LDAP_DEREF_ALWAYS); }))) { 727 mixin(enumMixinStr_LDAP_DEREF_ALWAYS); 728 } 729 } 730 731 732 733 734 static if(!is(typeof(LDAP_NO_LIMIT))) { 735 private enum enumMixinStr_LDAP_NO_LIMIT = `enum LDAP_NO_LIMIT = 0;`; 736 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_LIMIT); }))) { 737 mixin(enumMixinStr_LDAP_NO_LIMIT); 738 } 739 } 740 741 742 743 744 static if(!is(typeof(LDAP_MSG_ONE))) { 745 private enum enumMixinStr_LDAP_MSG_ONE = `enum LDAP_MSG_ONE = 0x00;`; 746 static if(is(typeof({ mixin(enumMixinStr_LDAP_MSG_ONE); }))) { 747 mixin(enumMixinStr_LDAP_MSG_ONE); 748 } 749 } 750 751 752 753 754 static if(!is(typeof(LDAP_MSG_ALL))) { 755 private enum enumMixinStr_LDAP_MSG_ALL = `enum LDAP_MSG_ALL = 0x01;`; 756 static if(is(typeof({ mixin(enumMixinStr_LDAP_MSG_ALL); }))) { 757 mixin(enumMixinStr_LDAP_MSG_ALL); 758 } 759 } 760 761 762 763 764 static if(!is(typeof(LDAP_MSG_RECEIVED))) { 765 private enum enumMixinStr_LDAP_MSG_RECEIVED = `enum LDAP_MSG_RECEIVED = 0x02;`; 766 static if(is(typeof({ mixin(enumMixinStr_LDAP_MSG_RECEIVED); }))) { 767 mixin(enumMixinStr_LDAP_MSG_RECEIVED); 768 } 769 } 770 771 772 773 774 static if(!is(typeof(LDAP_X_CONNECTING))) { 775 private enum enumMixinStr_LDAP_X_CONNECTING = `enum LDAP_X_CONNECTING = ( - 18 );`; 776 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_CONNECTING); }))) { 777 mixin(enumMixinStr_LDAP_X_CONNECTING); 778 } 779 } 780 781 782 783 784 static if(!is(typeof(LDAP_REFERRAL_LIMIT_EXCEEDED))) { 785 private enum enumMixinStr_LDAP_REFERRAL_LIMIT_EXCEEDED = `enum LDAP_REFERRAL_LIMIT_EXCEEDED = ( - 17 );`; 786 static if(is(typeof({ mixin(enumMixinStr_LDAP_REFERRAL_LIMIT_EXCEEDED); }))) { 787 mixin(enumMixinStr_LDAP_REFERRAL_LIMIT_EXCEEDED); 788 } 789 } 790 791 792 793 794 static if(!is(typeof(LDAP_URL_SUCCESS))) { 795 private enum enumMixinStr_LDAP_URL_SUCCESS = `enum LDAP_URL_SUCCESS = 0x00;`; 796 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_SUCCESS); }))) { 797 mixin(enumMixinStr_LDAP_URL_SUCCESS); 798 } 799 } 800 801 802 803 804 static if(!is(typeof(LDAP_URL_ERR_MEM))) { 805 private enum enumMixinStr_LDAP_URL_ERR_MEM = `enum LDAP_URL_ERR_MEM = 0x01;`; 806 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_MEM); }))) { 807 mixin(enumMixinStr_LDAP_URL_ERR_MEM); 808 } 809 } 810 811 812 813 814 static if(!is(typeof(LDAP_URL_ERR_PARAM))) { 815 private enum enumMixinStr_LDAP_URL_ERR_PARAM = `enum LDAP_URL_ERR_PARAM = 0x02;`; 816 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_PARAM); }))) { 817 mixin(enumMixinStr_LDAP_URL_ERR_PARAM); 818 } 819 } 820 821 822 823 824 static if(!is(typeof(LDAP_URL_ERR_BADSCHEME))) { 825 private enum enumMixinStr_LDAP_URL_ERR_BADSCHEME = `enum LDAP_URL_ERR_BADSCHEME = 0x03;`; 826 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADSCHEME); }))) { 827 mixin(enumMixinStr_LDAP_URL_ERR_BADSCHEME); 828 } 829 } 830 831 832 833 834 static if(!is(typeof(LDAP_URL_ERR_BADENCLOSURE))) { 835 private enum enumMixinStr_LDAP_URL_ERR_BADENCLOSURE = `enum LDAP_URL_ERR_BADENCLOSURE = 0x04;`; 836 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADENCLOSURE); }))) { 837 mixin(enumMixinStr_LDAP_URL_ERR_BADENCLOSURE); 838 } 839 } 840 841 842 843 844 static if(!is(typeof(LDAP_URL_ERR_BADURL))) { 845 private enum enumMixinStr_LDAP_URL_ERR_BADURL = `enum LDAP_URL_ERR_BADURL = 0x05;`; 846 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADURL); }))) { 847 mixin(enumMixinStr_LDAP_URL_ERR_BADURL); 848 } 849 } 850 851 852 853 854 static if(!is(typeof(LDAP_URL_ERR_BADHOST))) { 855 private enum enumMixinStr_LDAP_URL_ERR_BADHOST = `enum LDAP_URL_ERR_BADHOST = 0x06;`; 856 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADHOST); }))) { 857 mixin(enumMixinStr_LDAP_URL_ERR_BADHOST); 858 } 859 } 860 861 862 863 864 static if(!is(typeof(LDAP_URL_ERR_BADATTRS))) { 865 private enum enumMixinStr_LDAP_URL_ERR_BADATTRS = `enum LDAP_URL_ERR_BADATTRS = 0x07;`; 866 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADATTRS); }))) { 867 mixin(enumMixinStr_LDAP_URL_ERR_BADATTRS); 868 } 869 } 870 871 872 873 874 static if(!is(typeof(LDAP_URL_ERR_BADSCOPE))) { 875 private enum enumMixinStr_LDAP_URL_ERR_BADSCOPE = `enum LDAP_URL_ERR_BADSCOPE = 0x08;`; 876 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADSCOPE); }))) { 877 mixin(enumMixinStr_LDAP_URL_ERR_BADSCOPE); 878 } 879 } 880 881 882 883 884 static if(!is(typeof(LDAP_URL_ERR_BADFILTER))) { 885 private enum enumMixinStr_LDAP_URL_ERR_BADFILTER = `enum LDAP_URL_ERR_BADFILTER = 0x09;`; 886 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADFILTER); }))) { 887 mixin(enumMixinStr_LDAP_URL_ERR_BADFILTER); 888 } 889 } 890 891 892 893 894 static if(!is(typeof(LDAP_URL_ERR_BADEXTS))) { 895 private enum enumMixinStr_LDAP_URL_ERR_BADEXTS = `enum LDAP_URL_ERR_BADEXTS = 0x0a;`; 896 static if(is(typeof({ mixin(enumMixinStr_LDAP_URL_ERR_BADEXTS); }))) { 897 mixin(enumMixinStr_LDAP_URL_ERR_BADEXTS); 898 } 899 } 900 901 902 903 904 static if(!is(typeof(LDAP_CLIENT_LOOP))) { 905 private enum enumMixinStr_LDAP_CLIENT_LOOP = `enum LDAP_CLIENT_LOOP = ( - 16 );`; 906 static if(is(typeof({ mixin(enumMixinStr_LDAP_CLIENT_LOOP); }))) { 907 mixin(enumMixinStr_LDAP_CLIENT_LOOP); 908 } 909 } 910 911 912 913 914 static if(!is(typeof(LDAP_MORE_RESULTS_TO_RETURN))) { 915 private enum enumMixinStr_LDAP_MORE_RESULTS_TO_RETURN = `enum LDAP_MORE_RESULTS_TO_RETURN = ( - 15 );`; 916 static if(is(typeof({ mixin(enumMixinStr_LDAP_MORE_RESULTS_TO_RETURN); }))) { 917 mixin(enumMixinStr_LDAP_MORE_RESULTS_TO_RETURN); 918 } 919 } 920 921 922 923 924 static if(!is(typeof(LDAP_NO_RESULTS_RETURNED))) { 925 private enum enumMixinStr_LDAP_NO_RESULTS_RETURNED = `enum LDAP_NO_RESULTS_RETURNED = ( - 14 );`; 926 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_RESULTS_RETURNED); }))) { 927 mixin(enumMixinStr_LDAP_NO_RESULTS_RETURNED); 928 } 929 } 930 931 932 933 934 static if(!is(typeof(LDAP_CONTROL_NOT_FOUND))) { 935 private enum enumMixinStr_LDAP_CONTROL_NOT_FOUND = `enum LDAP_CONTROL_NOT_FOUND = ( - 13 );`; 936 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_NOT_FOUND); }))) { 937 mixin(enumMixinStr_LDAP_CONTROL_NOT_FOUND); 938 } 939 } 940 941 942 943 944 static if(!is(typeof(LDAP_NOT_SUPPORTED))) { 945 private enum enumMixinStr_LDAP_NOT_SUPPORTED = `enum LDAP_NOT_SUPPORTED = ( - 12 );`; 946 static if(is(typeof({ mixin(enumMixinStr_LDAP_NOT_SUPPORTED); }))) { 947 mixin(enumMixinStr_LDAP_NOT_SUPPORTED); 948 } 949 } 950 951 952 953 954 static if(!is(typeof(LDAP_CONNECT_ERROR))) { 955 private enum enumMixinStr_LDAP_CONNECT_ERROR = `enum LDAP_CONNECT_ERROR = ( - 11 );`; 956 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONNECT_ERROR); }))) { 957 mixin(enumMixinStr_LDAP_CONNECT_ERROR); 958 } 959 } 960 961 962 963 964 static if(!is(typeof(LDAP_NO_MEMORY))) { 965 private enum enumMixinStr_LDAP_NO_MEMORY = `enum LDAP_NO_MEMORY = ( - 10 );`; 966 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_MEMORY); }))) { 967 mixin(enumMixinStr_LDAP_NO_MEMORY); 968 } 969 } 970 971 972 973 974 static if(!is(typeof(LDAP_PARAM_ERROR))) { 975 private enum enumMixinStr_LDAP_PARAM_ERROR = `enum LDAP_PARAM_ERROR = ( - 9 );`; 976 static if(is(typeof({ mixin(enumMixinStr_LDAP_PARAM_ERROR); }))) { 977 mixin(enumMixinStr_LDAP_PARAM_ERROR); 978 } 979 } 980 981 982 983 984 static if(!is(typeof(LDAP_USER_CANCELLED))) { 985 private enum enumMixinStr_LDAP_USER_CANCELLED = `enum LDAP_USER_CANCELLED = ( - 8 );`; 986 static if(is(typeof({ mixin(enumMixinStr_LDAP_USER_CANCELLED); }))) { 987 mixin(enumMixinStr_LDAP_USER_CANCELLED); 988 } 989 } 990 991 992 993 994 static if(!is(typeof(LDAP_FILTER_ERROR))) { 995 private enum enumMixinStr_LDAP_FILTER_ERROR = `enum LDAP_FILTER_ERROR = ( - 7 );`; 996 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_ERROR); }))) { 997 mixin(enumMixinStr_LDAP_FILTER_ERROR); 998 } 999 } 1000 1001 1002 1003 1004 static if(!is(typeof(LDAP_AUTH_UNKNOWN))) { 1005 private enum enumMixinStr_LDAP_AUTH_UNKNOWN = `enum LDAP_AUTH_UNKNOWN = ( - 6 );`; 1006 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_UNKNOWN); }))) { 1007 mixin(enumMixinStr_LDAP_AUTH_UNKNOWN); 1008 } 1009 } 1010 1011 1012 1013 1014 static if(!is(typeof(LDAP_TIMEOUT))) { 1015 private enum enumMixinStr_LDAP_TIMEOUT = `enum LDAP_TIMEOUT = ( - 5 );`; 1016 static if(is(typeof({ mixin(enumMixinStr_LDAP_TIMEOUT); }))) { 1017 mixin(enumMixinStr_LDAP_TIMEOUT); 1018 } 1019 } 1020 1021 1022 1023 1024 static if(!is(typeof(LDAP_DECODING_ERROR))) { 1025 private enum enumMixinStr_LDAP_DECODING_ERROR = `enum LDAP_DECODING_ERROR = ( - 4 );`; 1026 static if(is(typeof({ mixin(enumMixinStr_LDAP_DECODING_ERROR); }))) { 1027 mixin(enumMixinStr_LDAP_DECODING_ERROR); 1028 } 1029 } 1030 1031 1032 1033 1034 static if(!is(typeof(LDAP_ENCODING_ERROR))) { 1035 private enum enumMixinStr_LDAP_ENCODING_ERROR = `enum LDAP_ENCODING_ERROR = ( - 3 );`; 1036 static if(is(typeof({ mixin(enumMixinStr_LDAP_ENCODING_ERROR); }))) { 1037 mixin(enumMixinStr_LDAP_ENCODING_ERROR); 1038 } 1039 } 1040 1041 1042 1043 1044 static if(!is(typeof(LDAP_LOCAL_ERROR))) { 1045 private enum enumMixinStr_LDAP_LOCAL_ERROR = `enum LDAP_LOCAL_ERROR = ( - 2 );`; 1046 static if(is(typeof({ mixin(enumMixinStr_LDAP_LOCAL_ERROR); }))) { 1047 mixin(enumMixinStr_LDAP_LOCAL_ERROR); 1048 } 1049 } 1050 1051 1052 1053 1054 static if(!is(typeof(LDAP_SERVER_DOWN))) { 1055 private enum enumMixinStr_LDAP_SERVER_DOWN = `enum LDAP_SERVER_DOWN = ( - 1 );`; 1056 static if(is(typeof({ mixin(enumMixinStr_LDAP_SERVER_DOWN); }))) { 1057 mixin(enumMixinStr_LDAP_SERVER_DOWN); 1058 } 1059 } 1060 static if(!is(typeof(LDAP_X_INVALIDREFERENCE))) { 1061 private enum enumMixinStr_LDAP_X_INVALIDREFERENCE = `enum LDAP_X_INVALIDREFERENCE = 0x4112;`; 1062 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_INVALIDREFERENCE); }))) { 1063 mixin(enumMixinStr_LDAP_X_INVALIDREFERENCE); 1064 } 1065 } 1066 1067 1068 1069 1070 static if(!is(typeof(LDAP_X_CANNOT_CHAIN))) { 1071 private enum enumMixinStr_LDAP_X_CANNOT_CHAIN = `enum LDAP_X_CANNOT_CHAIN = 0x4111;`; 1072 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_CANNOT_CHAIN); }))) { 1073 mixin(enumMixinStr_LDAP_X_CANNOT_CHAIN); 1074 } 1075 } 1076 1077 1078 1079 1080 static if(!is(typeof(LDAP_X_NO_REFERRALS_FOUND))) { 1081 private enum enumMixinStr_LDAP_X_NO_REFERRALS_FOUND = `enum LDAP_X_NO_REFERRALS_FOUND = 0x4110;`; 1082 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_NO_REFERRALS_FOUND); }))) { 1083 mixin(enumMixinStr_LDAP_X_NO_REFERRALS_FOUND); 1084 } 1085 } 1086 1087 1088 1089 1090 static if(!is(typeof(LDAP_X_NO_OPERATION))) { 1091 private enum enumMixinStr_LDAP_X_NO_OPERATION = `enum LDAP_X_NO_OPERATION = 0x410e;`; 1092 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_NO_OPERATION); }))) { 1093 mixin(enumMixinStr_LDAP_X_NO_OPERATION); 1094 } 1095 } 1096 1097 1098 1099 1100 static if(!is(typeof(LDAP_X_ASSERTION_FAILED))) { 1101 private enum enumMixinStr_LDAP_X_ASSERTION_FAILED = `enum LDAP_X_ASSERTION_FAILED = 0x410f;`; 1102 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_ASSERTION_FAILED); }))) { 1103 mixin(enumMixinStr_LDAP_X_ASSERTION_FAILED); 1104 } 1105 } 1106 1107 1108 1109 1110 static if(!is(typeof(LDAP_X_SYNC_REFRESH_REQUIRED))) { 1111 private enum enumMixinStr_LDAP_X_SYNC_REFRESH_REQUIRED = `enum LDAP_X_SYNC_REFRESH_REQUIRED = 0x4100;`; 1112 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_SYNC_REFRESH_REQUIRED); }))) { 1113 mixin(enumMixinStr_LDAP_X_SYNC_REFRESH_REQUIRED); 1114 } 1115 } 1116 1117 1118 1119 1120 1121 1122 static if(!is(typeof(LDAP_SYNC_REFRESH_REQUIRED))) { 1123 private enum enumMixinStr_LDAP_SYNC_REFRESH_REQUIRED = `enum LDAP_SYNC_REFRESH_REQUIRED = 0x1000;`; 1124 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_REFRESH_REQUIRED); }))) { 1125 mixin(enumMixinStr_LDAP_SYNC_REFRESH_REQUIRED); 1126 } 1127 } 1128 1129 1130 1131 1132 1133 1134 static if(!is(typeof(LDAP_PROXIED_AUTHORIZATION_DENIED))) { 1135 private enum enumMixinStr_LDAP_PROXIED_AUTHORIZATION_DENIED = `enum LDAP_PROXIED_AUTHORIZATION_DENIED = 0x7B;`; 1136 static if(is(typeof({ mixin(enumMixinStr_LDAP_PROXIED_AUTHORIZATION_DENIED); }))) { 1137 mixin(enumMixinStr_LDAP_PROXIED_AUTHORIZATION_DENIED); 1138 } 1139 } 1140 1141 1142 1143 1144 static if(!is(typeof(LDAP_ASSERTION_FAILED))) { 1145 private enum enumMixinStr_LDAP_ASSERTION_FAILED = `enum LDAP_ASSERTION_FAILED = 0x7A;`; 1146 static if(is(typeof({ mixin(enumMixinStr_LDAP_ASSERTION_FAILED); }))) { 1147 mixin(enumMixinStr_LDAP_ASSERTION_FAILED); 1148 } 1149 } 1150 1151 1152 1153 1154 static if(!is(typeof(LDAP_CANNOT_CANCEL))) { 1155 private enum enumMixinStr_LDAP_CANNOT_CANCEL = `enum LDAP_CANNOT_CANCEL = 0x79;`; 1156 static if(is(typeof({ mixin(enumMixinStr_LDAP_CANNOT_CANCEL); }))) { 1157 mixin(enumMixinStr_LDAP_CANNOT_CANCEL); 1158 } 1159 } 1160 1161 1162 1163 1164 static if(!is(typeof(LDAP_TOO_LATE))) { 1165 private enum enumMixinStr_LDAP_TOO_LATE = `enum LDAP_TOO_LATE = 0x78;`; 1166 static if(is(typeof({ mixin(enumMixinStr_LDAP_TOO_LATE); }))) { 1167 mixin(enumMixinStr_LDAP_TOO_LATE); 1168 } 1169 } 1170 1171 1172 1173 1174 static if(!is(typeof(LDAP_NO_SUCH_OPERATION))) { 1175 private enum enumMixinStr_LDAP_NO_SUCH_OPERATION = `enum LDAP_NO_SUCH_OPERATION = 0x77;`; 1176 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_SUCH_OPERATION); }))) { 1177 mixin(enumMixinStr_LDAP_NO_SUCH_OPERATION); 1178 } 1179 } 1180 1181 1182 1183 1184 static if(!is(typeof(LDAP_CANCELLED))) { 1185 private enum enumMixinStr_LDAP_CANCELLED = `enum LDAP_CANCELLED = 0x76;`; 1186 static if(is(typeof({ mixin(enumMixinStr_LDAP_CANCELLED); }))) { 1187 mixin(enumMixinStr_LDAP_CANCELLED); 1188 } 1189 } 1190 1191 1192 1193 1194 static if(!is(typeof(LDAP_CUP_RELOAD_REQUIRED))) { 1195 private enum enumMixinStr_LDAP_CUP_RELOAD_REQUIRED = `enum LDAP_CUP_RELOAD_REQUIRED = 0x75;`; 1196 static if(is(typeof({ mixin(enumMixinStr_LDAP_CUP_RELOAD_REQUIRED); }))) { 1197 mixin(enumMixinStr_LDAP_CUP_RELOAD_REQUIRED); 1198 } 1199 } 1200 1201 1202 1203 1204 static if(!is(typeof(LDAP_CUP_UNSUPPORTED_SCHEME))) { 1205 private enum enumMixinStr_LDAP_CUP_UNSUPPORTED_SCHEME = `enum LDAP_CUP_UNSUPPORTED_SCHEME = 0x74;`; 1206 static if(is(typeof({ mixin(enumMixinStr_LDAP_CUP_UNSUPPORTED_SCHEME); }))) { 1207 mixin(enumMixinStr_LDAP_CUP_UNSUPPORTED_SCHEME); 1208 } 1209 } 1210 1211 1212 1213 1214 static if(!is(typeof(LDAP_CUP_INVALID_DATA))) { 1215 private enum enumMixinStr_LDAP_CUP_INVALID_DATA = `enum LDAP_CUP_INVALID_DATA = 0x73;`; 1216 static if(is(typeof({ mixin(enumMixinStr_LDAP_CUP_INVALID_DATA); }))) { 1217 mixin(enumMixinStr_LDAP_CUP_INVALID_DATA); 1218 } 1219 } 1220 1221 1222 1223 1224 static if(!is(typeof(LDAP_CUP_SECURITY_VIOLATION))) { 1225 private enum enumMixinStr_LDAP_CUP_SECURITY_VIOLATION = `enum LDAP_CUP_SECURITY_VIOLATION = 0x72;`; 1226 static if(is(typeof({ mixin(enumMixinStr_LDAP_CUP_SECURITY_VIOLATION); }))) { 1227 mixin(enumMixinStr_LDAP_CUP_SECURITY_VIOLATION); 1228 } 1229 } 1230 1231 1232 1233 1234 static if(!is(typeof(LDAP_CUP_RESOURCES_EXHAUSTED))) { 1235 private enum enumMixinStr_LDAP_CUP_RESOURCES_EXHAUSTED = `enum LDAP_CUP_RESOURCES_EXHAUSTED = 0x71;`; 1236 static if(is(typeof({ mixin(enumMixinStr_LDAP_CUP_RESOURCES_EXHAUSTED); }))) { 1237 mixin(enumMixinStr_LDAP_CUP_RESOURCES_EXHAUSTED); 1238 } 1239 } 1240 1241 1242 1243 1244 static if(!is(typeof(LDAP_OTHER))) { 1245 private enum enumMixinStr_LDAP_OTHER = `enum LDAP_OTHER = 0x50;`; 1246 static if(is(typeof({ mixin(enumMixinStr_LDAP_OTHER); }))) { 1247 mixin(enumMixinStr_LDAP_OTHER); 1248 } 1249 } 1250 1251 1252 1253 1254 static if(!is(typeof(LDAP_VLV_ERROR))) { 1255 private enum enumMixinStr_LDAP_VLV_ERROR = `enum LDAP_VLV_ERROR = 0x4C;`; 1256 static if(is(typeof({ mixin(enumMixinStr_LDAP_VLV_ERROR); }))) { 1257 mixin(enumMixinStr_LDAP_VLV_ERROR); 1258 } 1259 } 1260 1261 1262 1263 1264 static if(!is(typeof(LDAP_AFFECTS_MULTIPLE_DSAS))) { 1265 private enum enumMixinStr_LDAP_AFFECTS_MULTIPLE_DSAS = `enum LDAP_AFFECTS_MULTIPLE_DSAS = 0x47;`; 1266 static if(is(typeof({ mixin(enumMixinStr_LDAP_AFFECTS_MULTIPLE_DSAS); }))) { 1267 mixin(enumMixinStr_LDAP_AFFECTS_MULTIPLE_DSAS); 1268 } 1269 } 1270 1271 1272 1273 1274 static if(!is(typeof(LDAP_RESULTS_TOO_LARGE))) { 1275 private enum enumMixinStr_LDAP_RESULTS_TOO_LARGE = `enum LDAP_RESULTS_TOO_LARGE = 0x46;`; 1276 static if(is(typeof({ mixin(enumMixinStr_LDAP_RESULTS_TOO_LARGE); }))) { 1277 mixin(enumMixinStr_LDAP_RESULTS_TOO_LARGE); 1278 } 1279 } 1280 1281 1282 1283 1284 static if(!is(typeof(LDAP_NO_OBJECT_CLASS_MODS))) { 1285 private enum enumMixinStr_LDAP_NO_OBJECT_CLASS_MODS = `enum LDAP_NO_OBJECT_CLASS_MODS = 0x45;`; 1286 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_OBJECT_CLASS_MODS); }))) { 1287 mixin(enumMixinStr_LDAP_NO_OBJECT_CLASS_MODS); 1288 } 1289 } 1290 1291 1292 1293 1294 static if(!is(typeof(LDAP_ALREADY_EXISTS))) { 1295 private enum enumMixinStr_LDAP_ALREADY_EXISTS = `enum LDAP_ALREADY_EXISTS = 0x44;`; 1296 static if(is(typeof({ mixin(enumMixinStr_LDAP_ALREADY_EXISTS); }))) { 1297 mixin(enumMixinStr_LDAP_ALREADY_EXISTS); 1298 } 1299 } 1300 1301 1302 1303 1304 static if(!is(typeof(LDAP_NOT_ALLOWED_ON_RDN))) { 1305 private enum enumMixinStr_LDAP_NOT_ALLOWED_ON_RDN = `enum LDAP_NOT_ALLOWED_ON_RDN = 0x43;`; 1306 static if(is(typeof({ mixin(enumMixinStr_LDAP_NOT_ALLOWED_ON_RDN); }))) { 1307 mixin(enumMixinStr_LDAP_NOT_ALLOWED_ON_RDN); 1308 } 1309 } 1310 1311 1312 1313 1314 static if(!is(typeof(LDAP_NOT_ALLOWED_ON_NONLEAF))) { 1315 private enum enumMixinStr_LDAP_NOT_ALLOWED_ON_NONLEAF = `enum LDAP_NOT_ALLOWED_ON_NONLEAF = 0x42;`; 1316 static if(is(typeof({ mixin(enumMixinStr_LDAP_NOT_ALLOWED_ON_NONLEAF); }))) { 1317 mixin(enumMixinStr_LDAP_NOT_ALLOWED_ON_NONLEAF); 1318 } 1319 } 1320 1321 1322 1323 1324 static if(!is(typeof(LDAP_OBJECT_CLASS_VIOLATION))) { 1325 private enum enumMixinStr_LDAP_OBJECT_CLASS_VIOLATION = `enum LDAP_OBJECT_CLASS_VIOLATION = 0x41;`; 1326 static if(is(typeof({ mixin(enumMixinStr_LDAP_OBJECT_CLASS_VIOLATION); }))) { 1327 mixin(enumMixinStr_LDAP_OBJECT_CLASS_VIOLATION); 1328 } 1329 } 1330 1331 1332 1333 1334 static if(!is(typeof(LDAP_NAMING_VIOLATION))) { 1335 private enum enumMixinStr_LDAP_NAMING_VIOLATION = `enum LDAP_NAMING_VIOLATION = 0x40;`; 1336 static if(is(typeof({ mixin(enumMixinStr_LDAP_NAMING_VIOLATION); }))) { 1337 mixin(enumMixinStr_LDAP_NAMING_VIOLATION); 1338 } 1339 } 1340 1341 1342 1343 1344 1345 1346 static if(!is(typeof(LDAP_LOOP_DETECT))) { 1347 private enum enumMixinStr_LDAP_LOOP_DETECT = `enum LDAP_LOOP_DETECT = 0x36;`; 1348 static if(is(typeof({ mixin(enumMixinStr_LDAP_LOOP_DETECT); }))) { 1349 mixin(enumMixinStr_LDAP_LOOP_DETECT); 1350 } 1351 } 1352 1353 1354 1355 1356 static if(!is(typeof(LDAP_UNWILLING_TO_PERFORM))) { 1357 private enum enumMixinStr_LDAP_UNWILLING_TO_PERFORM = `enum LDAP_UNWILLING_TO_PERFORM = 0x35;`; 1358 static if(is(typeof({ mixin(enumMixinStr_LDAP_UNWILLING_TO_PERFORM); }))) { 1359 mixin(enumMixinStr_LDAP_UNWILLING_TO_PERFORM); 1360 } 1361 } 1362 1363 1364 1365 1366 static if(!is(typeof(LDAP_UNAVAILABLE))) { 1367 private enum enumMixinStr_LDAP_UNAVAILABLE = `enum LDAP_UNAVAILABLE = 0x34;`; 1368 static if(is(typeof({ mixin(enumMixinStr_LDAP_UNAVAILABLE); }))) { 1369 mixin(enumMixinStr_LDAP_UNAVAILABLE); 1370 } 1371 } 1372 1373 1374 1375 1376 static if(!is(typeof(LDAP_BUSY))) { 1377 private enum enumMixinStr_LDAP_BUSY = `enum LDAP_BUSY = 0x33;`; 1378 static if(is(typeof({ mixin(enumMixinStr_LDAP_BUSY); }))) { 1379 mixin(enumMixinStr_LDAP_BUSY); 1380 } 1381 } 1382 1383 1384 1385 1386 1387 1388 static if(!is(typeof(LDAP_INSUFFICIENT_ACCESS))) { 1389 private enum enumMixinStr_LDAP_INSUFFICIENT_ACCESS = `enum LDAP_INSUFFICIENT_ACCESS = 0x32;`; 1390 static if(is(typeof({ mixin(enumMixinStr_LDAP_INSUFFICIENT_ACCESS); }))) { 1391 mixin(enumMixinStr_LDAP_INSUFFICIENT_ACCESS); 1392 } 1393 } 1394 1395 1396 1397 1398 static if(!is(typeof(LDAP_INVALID_CREDENTIALS))) { 1399 private enum enumMixinStr_LDAP_INVALID_CREDENTIALS = `enum LDAP_INVALID_CREDENTIALS = 0x31;`; 1400 static if(is(typeof({ mixin(enumMixinStr_LDAP_INVALID_CREDENTIALS); }))) { 1401 mixin(enumMixinStr_LDAP_INVALID_CREDENTIALS); 1402 } 1403 } 1404 1405 1406 1407 1408 static if(!is(typeof(LDAP_INAPPROPRIATE_AUTH))) { 1409 private enum enumMixinStr_LDAP_INAPPROPRIATE_AUTH = `enum LDAP_INAPPROPRIATE_AUTH = 0x30;`; 1410 static if(is(typeof({ mixin(enumMixinStr_LDAP_INAPPROPRIATE_AUTH); }))) { 1411 mixin(enumMixinStr_LDAP_INAPPROPRIATE_AUTH); 1412 } 1413 } 1414 1415 1416 1417 1418 static if(!is(typeof(LDAP_X_PROXY_AUTHZ_FAILURE))) { 1419 private enum enumMixinStr_LDAP_X_PROXY_AUTHZ_FAILURE = `enum LDAP_X_PROXY_AUTHZ_FAILURE = 0x2F;`; 1420 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_PROXY_AUTHZ_FAILURE); }))) { 1421 mixin(enumMixinStr_LDAP_X_PROXY_AUTHZ_FAILURE); 1422 } 1423 } 1424 1425 1426 1427 1428 1429 1430 static if(!is(typeof(LDAP_ALIAS_DEREF_PROBLEM))) { 1431 private enum enumMixinStr_LDAP_ALIAS_DEREF_PROBLEM = `enum LDAP_ALIAS_DEREF_PROBLEM = 0x24;`; 1432 static if(is(typeof({ mixin(enumMixinStr_LDAP_ALIAS_DEREF_PROBLEM); }))) { 1433 mixin(enumMixinStr_LDAP_ALIAS_DEREF_PROBLEM); 1434 } 1435 } 1436 1437 1438 1439 1440 static if(!is(typeof(LDAP_IS_LEAF))) { 1441 private enum enumMixinStr_LDAP_IS_LEAF = `enum LDAP_IS_LEAF = 0x23;`; 1442 static if(is(typeof({ mixin(enumMixinStr_LDAP_IS_LEAF); }))) { 1443 mixin(enumMixinStr_LDAP_IS_LEAF); 1444 } 1445 } 1446 1447 1448 1449 1450 static if(!is(typeof(LDAP_INVALID_DN_SYNTAX))) { 1451 private enum enumMixinStr_LDAP_INVALID_DN_SYNTAX = `enum LDAP_INVALID_DN_SYNTAX = 0x22;`; 1452 static if(is(typeof({ mixin(enumMixinStr_LDAP_INVALID_DN_SYNTAX); }))) { 1453 mixin(enumMixinStr_LDAP_INVALID_DN_SYNTAX); 1454 } 1455 } 1456 1457 1458 1459 1460 static if(!is(typeof(LDAP_ALIAS_PROBLEM))) { 1461 private enum enumMixinStr_LDAP_ALIAS_PROBLEM = `enum LDAP_ALIAS_PROBLEM = 0x21;`; 1462 static if(is(typeof({ mixin(enumMixinStr_LDAP_ALIAS_PROBLEM); }))) { 1463 mixin(enumMixinStr_LDAP_ALIAS_PROBLEM); 1464 } 1465 } 1466 1467 1468 1469 1470 static if(!is(typeof(LDAP_NO_SUCH_OBJECT))) { 1471 private enum enumMixinStr_LDAP_NO_SUCH_OBJECT = `enum LDAP_NO_SUCH_OBJECT = 0x20;`; 1472 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_SUCH_OBJECT); }))) { 1473 mixin(enumMixinStr_LDAP_NO_SUCH_OBJECT); 1474 } 1475 } 1476 1477 1478 1479 1480 1481 1482 static if(!is(typeof(LDAP_INVALID_SYNTAX))) { 1483 private enum enumMixinStr_LDAP_INVALID_SYNTAX = `enum LDAP_INVALID_SYNTAX = 0x15;`; 1484 static if(is(typeof({ mixin(enumMixinStr_LDAP_INVALID_SYNTAX); }))) { 1485 mixin(enumMixinStr_LDAP_INVALID_SYNTAX); 1486 } 1487 } 1488 1489 1490 1491 1492 static if(!is(typeof(LDAP_TYPE_OR_VALUE_EXISTS))) { 1493 private enum enumMixinStr_LDAP_TYPE_OR_VALUE_EXISTS = `enum LDAP_TYPE_OR_VALUE_EXISTS = 0x14;`; 1494 static if(is(typeof({ mixin(enumMixinStr_LDAP_TYPE_OR_VALUE_EXISTS); }))) { 1495 mixin(enumMixinStr_LDAP_TYPE_OR_VALUE_EXISTS); 1496 } 1497 } 1498 1499 1500 1501 1502 static if(!is(typeof(LDAP_CONSTRAINT_VIOLATION))) { 1503 private enum enumMixinStr_LDAP_CONSTRAINT_VIOLATION = `enum LDAP_CONSTRAINT_VIOLATION = 0x13;`; 1504 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONSTRAINT_VIOLATION); }))) { 1505 mixin(enumMixinStr_LDAP_CONSTRAINT_VIOLATION); 1506 } 1507 } 1508 1509 1510 1511 1512 static if(!is(typeof(LDAP_INAPPROPRIATE_MATCHING))) { 1513 private enum enumMixinStr_LDAP_INAPPROPRIATE_MATCHING = `enum LDAP_INAPPROPRIATE_MATCHING = 0x12;`; 1514 static if(is(typeof({ mixin(enumMixinStr_LDAP_INAPPROPRIATE_MATCHING); }))) { 1515 mixin(enumMixinStr_LDAP_INAPPROPRIATE_MATCHING); 1516 } 1517 } 1518 1519 1520 1521 1522 static if(!is(typeof(LDAP_UNDEFINED_TYPE))) { 1523 private enum enumMixinStr_LDAP_UNDEFINED_TYPE = `enum LDAP_UNDEFINED_TYPE = 0x11;`; 1524 static if(is(typeof({ mixin(enumMixinStr_LDAP_UNDEFINED_TYPE); }))) { 1525 mixin(enumMixinStr_LDAP_UNDEFINED_TYPE); 1526 } 1527 } 1528 1529 1530 1531 1532 static if(!is(typeof(LDAP_NO_SUCH_ATTRIBUTE))) { 1533 private enum enumMixinStr_LDAP_NO_SUCH_ATTRIBUTE = `enum LDAP_NO_SUCH_ATTRIBUTE = 0x10;`; 1534 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_SUCH_ATTRIBUTE); }))) { 1535 mixin(enumMixinStr_LDAP_NO_SUCH_ATTRIBUTE); 1536 } 1537 } 1538 1539 1540 1541 1542 1543 1544 static if(!is(typeof(LDAP_SASL_BIND_IN_PROGRESS))) { 1545 private enum enumMixinStr_LDAP_SASL_BIND_IN_PROGRESS = `enum LDAP_SASL_BIND_IN_PROGRESS = 0x0e;`; 1546 static if(is(typeof({ mixin(enumMixinStr_LDAP_SASL_BIND_IN_PROGRESS); }))) { 1547 mixin(enumMixinStr_LDAP_SASL_BIND_IN_PROGRESS); 1548 } 1549 } 1550 1551 1552 1553 1554 static if(!is(typeof(LDAP_CONFIDENTIALITY_REQUIRED))) { 1555 private enum enumMixinStr_LDAP_CONFIDENTIALITY_REQUIRED = `enum LDAP_CONFIDENTIALITY_REQUIRED = 0x0d;`; 1556 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONFIDENTIALITY_REQUIRED); }))) { 1557 mixin(enumMixinStr_LDAP_CONFIDENTIALITY_REQUIRED); 1558 } 1559 } 1560 1561 1562 1563 1564 static if(!is(typeof(LDAP_UNAVAILABLE_CRITICAL_EXTENSION))) { 1565 private enum enumMixinStr_LDAP_UNAVAILABLE_CRITICAL_EXTENSION = `enum LDAP_UNAVAILABLE_CRITICAL_EXTENSION = 0x0c;`; 1566 static if(is(typeof({ mixin(enumMixinStr_LDAP_UNAVAILABLE_CRITICAL_EXTENSION); }))) { 1567 mixin(enumMixinStr_LDAP_UNAVAILABLE_CRITICAL_EXTENSION); 1568 } 1569 } 1570 1571 1572 1573 1574 static if(!is(typeof(LDAP_ADMINLIMIT_EXCEEDED))) { 1575 private enum enumMixinStr_LDAP_ADMINLIMIT_EXCEEDED = `enum LDAP_ADMINLIMIT_EXCEEDED = 0x0b;`; 1576 static if(is(typeof({ mixin(enumMixinStr_LDAP_ADMINLIMIT_EXCEEDED); }))) { 1577 mixin(enumMixinStr_LDAP_ADMINLIMIT_EXCEEDED); 1578 } 1579 } 1580 1581 1582 1583 1584 static if(!is(typeof(LDAP_REFERRAL))) { 1585 private enum enumMixinStr_LDAP_REFERRAL = `enum LDAP_REFERRAL = 0x0a;`; 1586 static if(is(typeof({ mixin(enumMixinStr_LDAP_REFERRAL); }))) { 1587 mixin(enumMixinStr_LDAP_REFERRAL); 1588 } 1589 } 1590 1591 1592 1593 1594 static if(!is(typeof(LDAP_PARTIAL_RESULTS))) { 1595 private enum enumMixinStr_LDAP_PARTIAL_RESULTS = `enum LDAP_PARTIAL_RESULTS = 0x09;`; 1596 static if(is(typeof({ mixin(enumMixinStr_LDAP_PARTIAL_RESULTS); }))) { 1597 mixin(enumMixinStr_LDAP_PARTIAL_RESULTS); 1598 } 1599 } 1600 1601 1602 1603 1604 static if(!is(typeof(LDAP_STRONGER_AUTH_REQUIRED))) { 1605 private enum enumMixinStr_LDAP_STRONGER_AUTH_REQUIRED = `enum LDAP_STRONGER_AUTH_REQUIRED = LDAP_STRONG_AUTH_REQUIRED;`; 1606 static if(is(typeof({ mixin(enumMixinStr_LDAP_STRONGER_AUTH_REQUIRED); }))) { 1607 mixin(enumMixinStr_LDAP_STRONGER_AUTH_REQUIRED); 1608 } 1609 } 1610 1611 1612 1613 1614 static if(!is(typeof(LDAP_STRONG_AUTH_REQUIRED))) { 1615 private enum enumMixinStr_LDAP_STRONG_AUTH_REQUIRED = `enum LDAP_STRONG_AUTH_REQUIRED = 0x08;`; 1616 static if(is(typeof({ mixin(enumMixinStr_LDAP_STRONG_AUTH_REQUIRED); }))) { 1617 mixin(enumMixinStr_LDAP_STRONG_AUTH_REQUIRED); 1618 } 1619 } 1620 1621 1622 1623 1624 static if(!is(typeof(LDAP_STRONG_AUTH_NOT_SUPPORTED))) { 1625 private enum enumMixinStr_LDAP_STRONG_AUTH_NOT_SUPPORTED = `enum LDAP_STRONG_AUTH_NOT_SUPPORTED = LDAP_AUTH_METHOD_NOT_SUPPORTED;`; 1626 static if(is(typeof({ mixin(enumMixinStr_LDAP_STRONG_AUTH_NOT_SUPPORTED); }))) { 1627 mixin(enumMixinStr_LDAP_STRONG_AUTH_NOT_SUPPORTED); 1628 } 1629 } 1630 1631 1632 1633 1634 static if(!is(typeof(LDAP_AUTH_METHOD_NOT_SUPPORTED))) { 1635 private enum enumMixinStr_LDAP_AUTH_METHOD_NOT_SUPPORTED = `enum LDAP_AUTH_METHOD_NOT_SUPPORTED = 0x07;`; 1636 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_METHOD_NOT_SUPPORTED); }))) { 1637 mixin(enumMixinStr_LDAP_AUTH_METHOD_NOT_SUPPORTED); 1638 } 1639 } 1640 1641 1642 1643 1644 static if(!is(typeof(LDAP_COMPARE_TRUE))) { 1645 private enum enumMixinStr_LDAP_COMPARE_TRUE = `enum LDAP_COMPARE_TRUE = 0x06;`; 1646 static if(is(typeof({ mixin(enumMixinStr_LDAP_COMPARE_TRUE); }))) { 1647 mixin(enumMixinStr_LDAP_COMPARE_TRUE); 1648 } 1649 } 1650 1651 1652 1653 1654 static if(!is(typeof(LDAP_COMPARE_FALSE))) { 1655 private enum enumMixinStr_LDAP_COMPARE_FALSE = `enum LDAP_COMPARE_FALSE = 0x05;`; 1656 static if(is(typeof({ mixin(enumMixinStr_LDAP_COMPARE_FALSE); }))) { 1657 mixin(enumMixinStr_LDAP_COMPARE_FALSE); 1658 } 1659 } 1660 1661 1662 1663 1664 static if(!is(typeof(LDAP_SIZELIMIT_EXCEEDED))) { 1665 private enum enumMixinStr_LDAP_SIZELIMIT_EXCEEDED = `enum LDAP_SIZELIMIT_EXCEEDED = 0x04;`; 1666 static if(is(typeof({ mixin(enumMixinStr_LDAP_SIZELIMIT_EXCEEDED); }))) { 1667 mixin(enumMixinStr_LDAP_SIZELIMIT_EXCEEDED); 1668 } 1669 } 1670 1671 1672 1673 1674 static if(!is(typeof(LDAP_TIMELIMIT_EXCEEDED))) { 1675 private enum enumMixinStr_LDAP_TIMELIMIT_EXCEEDED = `enum LDAP_TIMELIMIT_EXCEEDED = 0x03;`; 1676 static if(is(typeof({ mixin(enumMixinStr_LDAP_TIMELIMIT_EXCEEDED); }))) { 1677 mixin(enumMixinStr_LDAP_TIMELIMIT_EXCEEDED); 1678 } 1679 } 1680 1681 1682 1683 1684 static if(!is(typeof(LDAP_PROTOCOL_ERROR))) { 1685 private enum enumMixinStr_LDAP_PROTOCOL_ERROR = `enum LDAP_PROTOCOL_ERROR = 0x02;`; 1686 static if(is(typeof({ mixin(enumMixinStr_LDAP_PROTOCOL_ERROR); }))) { 1687 mixin(enumMixinStr_LDAP_PROTOCOL_ERROR); 1688 } 1689 } 1690 1691 1692 1693 1694 static if(!is(typeof(LDAP_OPERATIONS_ERROR))) { 1695 private enum enumMixinStr_LDAP_OPERATIONS_ERROR = `enum LDAP_OPERATIONS_ERROR = 0x01;`; 1696 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPERATIONS_ERROR); }))) { 1697 mixin(enumMixinStr_LDAP_OPERATIONS_ERROR); 1698 } 1699 } 1700 1701 1702 1703 1704 1705 1706 static if(!is(typeof(LDAP_SUCCESS))) { 1707 private enum enumMixinStr_LDAP_SUCCESS = `enum LDAP_SUCCESS = 0x00;`; 1708 static if(is(typeof({ mixin(enumMixinStr_LDAP_SUCCESS); }))) { 1709 mixin(enumMixinStr_LDAP_SUCCESS); 1710 } 1711 } 1712 1713 1714 1715 1716 static if(!is(typeof(LDAP_SUBSTRING_FINAL))) { 1717 private enum enumMixinStr_LDAP_SUBSTRING_FINAL = `enum LDAP_SUBSTRING_FINAL = ( cast( ber_tag_t ) 0x82U );`; 1718 static if(is(typeof({ mixin(enumMixinStr_LDAP_SUBSTRING_FINAL); }))) { 1719 mixin(enumMixinStr_LDAP_SUBSTRING_FINAL); 1720 } 1721 } 1722 1723 1724 1725 1726 static if(!is(typeof(LDAP_SUBSTRING_ANY))) { 1727 private enum enumMixinStr_LDAP_SUBSTRING_ANY = `enum LDAP_SUBSTRING_ANY = ( cast( ber_tag_t ) 0x81U );`; 1728 static if(is(typeof({ mixin(enumMixinStr_LDAP_SUBSTRING_ANY); }))) { 1729 mixin(enumMixinStr_LDAP_SUBSTRING_ANY); 1730 } 1731 } 1732 1733 1734 1735 1736 static if(!is(typeof(LDAP_SUBSTRING_INITIAL))) { 1737 private enum enumMixinStr_LDAP_SUBSTRING_INITIAL = `enum LDAP_SUBSTRING_INITIAL = ( cast( ber_tag_t ) 0x80U );`; 1738 static if(is(typeof({ mixin(enumMixinStr_LDAP_SUBSTRING_INITIAL); }))) { 1739 mixin(enumMixinStr_LDAP_SUBSTRING_INITIAL); 1740 } 1741 } 1742 1743 1744 1745 1746 static if(!is(typeof(LDAP_SCOPE_DEFAULT))) { 1747 private enum enumMixinStr_LDAP_SCOPE_DEFAULT = `enum LDAP_SCOPE_DEFAULT = ( cast( ber_int_t ) - 1 );`; 1748 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_DEFAULT); }))) { 1749 mixin(enumMixinStr_LDAP_SCOPE_DEFAULT); 1750 } 1751 } 1752 1753 1754 1755 1756 static if(!is(typeof(LDAP_SCOPE_CHILDREN))) { 1757 private enum enumMixinStr_LDAP_SCOPE_CHILDREN = `enum LDAP_SCOPE_CHILDREN = LDAP_SCOPE_SUBORDINATE;`; 1758 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_CHILDREN); }))) { 1759 mixin(enumMixinStr_LDAP_SCOPE_CHILDREN); 1760 } 1761 } 1762 1763 1764 1765 1766 static if(!is(typeof(LDAP_SCOPE_SUBORDINATE))) { 1767 private enum enumMixinStr_LDAP_SCOPE_SUBORDINATE = `enum LDAP_SCOPE_SUBORDINATE = ( cast( ber_int_t ) 0x0003 );`; 1768 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_SUBORDINATE); }))) { 1769 mixin(enumMixinStr_LDAP_SCOPE_SUBORDINATE); 1770 } 1771 } 1772 1773 1774 1775 1776 static if(!is(typeof(LDAP_SCOPE_SUB))) { 1777 private enum enumMixinStr_LDAP_SCOPE_SUB = `enum LDAP_SCOPE_SUB = LDAP_SCOPE_SUBTREE;`; 1778 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_SUB); }))) { 1779 mixin(enumMixinStr_LDAP_SCOPE_SUB); 1780 } 1781 } 1782 1783 1784 1785 1786 static if(!is(typeof(LDAP_SCOPE_SUBTREE))) { 1787 private enum enumMixinStr_LDAP_SCOPE_SUBTREE = `enum LDAP_SCOPE_SUBTREE = ( cast( ber_int_t ) 0x0002 );`; 1788 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_SUBTREE); }))) { 1789 mixin(enumMixinStr_LDAP_SCOPE_SUBTREE); 1790 } 1791 } 1792 1793 1794 1795 1796 static if(!is(typeof(LDAP_SCOPE_ONE))) { 1797 private enum enumMixinStr_LDAP_SCOPE_ONE = `enum LDAP_SCOPE_ONE = LDAP_SCOPE_ONELEVEL;`; 1798 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_ONE); }))) { 1799 mixin(enumMixinStr_LDAP_SCOPE_ONE); 1800 } 1801 } 1802 1803 1804 1805 1806 static if(!is(typeof(LDAP_SCOPE_ONELEVEL))) { 1807 private enum enumMixinStr_LDAP_SCOPE_ONELEVEL = `enum LDAP_SCOPE_ONELEVEL = ( cast( ber_int_t ) 0x0001 );`; 1808 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_ONELEVEL); }))) { 1809 mixin(enumMixinStr_LDAP_SCOPE_ONELEVEL); 1810 } 1811 } 1812 1813 1814 1815 1816 static if(!is(typeof(LDAP_SCOPE_BASEOBJECT))) { 1817 private enum enumMixinStr_LDAP_SCOPE_BASEOBJECT = `enum LDAP_SCOPE_BASEOBJECT = LDAP_SCOPE_BASE;`; 1818 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_BASEOBJECT); }))) { 1819 mixin(enumMixinStr_LDAP_SCOPE_BASEOBJECT); 1820 } 1821 } 1822 1823 1824 1825 1826 static if(!is(typeof(LDAP_SCOPE_BASE))) { 1827 private enum enumMixinStr_LDAP_SCOPE_BASE = `enum LDAP_SCOPE_BASE = ( cast( ber_int_t ) 0x0000 );`; 1828 static if(is(typeof({ mixin(enumMixinStr_LDAP_SCOPE_BASE); }))) { 1829 mixin(enumMixinStr_LDAP_SCOPE_BASE); 1830 } 1831 } 1832 1833 1834 1835 1836 static if(!is(typeof(LDAP_FILTER_EXT_DNATTRS))) { 1837 private enum enumMixinStr_LDAP_FILTER_EXT_DNATTRS = `enum LDAP_FILTER_EXT_DNATTRS = ( cast( ber_tag_t ) 0x84U );`; 1838 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_EXT_DNATTRS); }))) { 1839 mixin(enumMixinStr_LDAP_FILTER_EXT_DNATTRS); 1840 } 1841 } 1842 1843 1844 1845 1846 static if(!is(typeof(LDAP_FILTER_EXT_VALUE))) { 1847 private enum enumMixinStr_LDAP_FILTER_EXT_VALUE = `enum LDAP_FILTER_EXT_VALUE = ( cast( ber_tag_t ) 0x83U );`; 1848 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_EXT_VALUE); }))) { 1849 mixin(enumMixinStr_LDAP_FILTER_EXT_VALUE); 1850 } 1851 } 1852 1853 1854 1855 1856 static if(!is(typeof(LDAP_FILTER_EXT_TYPE))) { 1857 private enum enumMixinStr_LDAP_FILTER_EXT_TYPE = `enum LDAP_FILTER_EXT_TYPE = ( cast( ber_tag_t ) 0x82U );`; 1858 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_EXT_TYPE); }))) { 1859 mixin(enumMixinStr_LDAP_FILTER_EXT_TYPE); 1860 } 1861 } 1862 1863 1864 1865 1866 static if(!is(typeof(LDAP_FILTER_EXT_OID))) { 1867 private enum enumMixinStr_LDAP_FILTER_EXT_OID = `enum LDAP_FILTER_EXT_OID = ( cast( ber_tag_t ) 0x81U );`; 1868 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_EXT_OID); }))) { 1869 mixin(enumMixinStr_LDAP_FILTER_EXT_OID); 1870 } 1871 } 1872 1873 1874 1875 1876 static if(!is(typeof(LDAP_FILTER_EXT))) { 1877 private enum enumMixinStr_LDAP_FILTER_EXT = `enum LDAP_FILTER_EXT = ( cast( ber_tag_t ) 0xa9U );`; 1878 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_EXT); }))) { 1879 mixin(enumMixinStr_LDAP_FILTER_EXT); 1880 } 1881 } 1882 1883 1884 1885 1886 static if(!is(typeof(LDAP_FILTER_APPROX))) { 1887 private enum enumMixinStr_LDAP_FILTER_APPROX = `enum LDAP_FILTER_APPROX = ( cast( ber_tag_t ) 0xa8U );`; 1888 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_APPROX); }))) { 1889 mixin(enumMixinStr_LDAP_FILTER_APPROX); 1890 } 1891 } 1892 1893 1894 1895 1896 static if(!is(typeof(LDAP_SASL_AUTOMATIC))) { 1897 private enum enumMixinStr_LDAP_SASL_AUTOMATIC = `enum LDAP_SASL_AUTOMATIC = 0U;`; 1898 static if(is(typeof({ mixin(enumMixinStr_LDAP_SASL_AUTOMATIC); }))) { 1899 mixin(enumMixinStr_LDAP_SASL_AUTOMATIC); 1900 } 1901 } 1902 1903 1904 1905 1906 static if(!is(typeof(LDAP_SASL_INTERACTIVE))) { 1907 private enum enumMixinStr_LDAP_SASL_INTERACTIVE = `enum LDAP_SASL_INTERACTIVE = 1U;`; 1908 static if(is(typeof({ mixin(enumMixinStr_LDAP_SASL_INTERACTIVE); }))) { 1909 mixin(enumMixinStr_LDAP_SASL_INTERACTIVE); 1910 } 1911 } 1912 1913 1914 1915 1916 static if(!is(typeof(LDAP_SASL_QUIET))) { 1917 private enum enumMixinStr_LDAP_SASL_QUIET = `enum LDAP_SASL_QUIET = 2U;`; 1918 static if(is(typeof({ mixin(enumMixinStr_LDAP_SASL_QUIET); }))) { 1919 mixin(enumMixinStr_LDAP_SASL_QUIET); 1920 } 1921 } 1922 1923 1924 1925 1926 static if(!is(typeof(LDAP_FILTER_PRESENT))) { 1927 private enum enumMixinStr_LDAP_FILTER_PRESENT = `enum LDAP_FILTER_PRESENT = ( cast( ber_tag_t ) 0x87U );`; 1928 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_PRESENT); }))) { 1929 mixin(enumMixinStr_LDAP_FILTER_PRESENT); 1930 } 1931 } 1932 1933 1934 1935 1936 static if(!is(typeof(LDAP_FILTER_LE))) { 1937 private enum enumMixinStr_LDAP_FILTER_LE = `enum LDAP_FILTER_LE = ( cast( ber_tag_t ) 0xa6U );`; 1938 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_LE); }))) { 1939 mixin(enumMixinStr_LDAP_FILTER_LE); 1940 } 1941 } 1942 1943 1944 1945 1946 static if(!is(typeof(LDAP_FILTER_GE))) { 1947 private enum enumMixinStr_LDAP_FILTER_GE = `enum LDAP_FILTER_GE = ( cast( ber_tag_t ) 0xa5U );`; 1948 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_GE); }))) { 1949 mixin(enumMixinStr_LDAP_FILTER_GE); 1950 } 1951 } 1952 1953 1954 1955 1956 static if(!is(typeof(LDAP_FILTER_SUBSTRINGS))) { 1957 private enum enumMixinStr_LDAP_FILTER_SUBSTRINGS = `enum LDAP_FILTER_SUBSTRINGS = ( cast( ber_tag_t ) 0xa4U );`; 1958 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_SUBSTRINGS); }))) { 1959 mixin(enumMixinStr_LDAP_FILTER_SUBSTRINGS); 1960 } 1961 } 1962 1963 1964 1965 1966 static if(!is(typeof(LDAP_FILTER_EQUALITY))) { 1967 private enum enumMixinStr_LDAP_FILTER_EQUALITY = `enum LDAP_FILTER_EQUALITY = ( cast( ber_tag_t ) 0xa3U );`; 1968 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_EQUALITY); }))) { 1969 mixin(enumMixinStr_LDAP_FILTER_EQUALITY); 1970 } 1971 } 1972 1973 1974 1975 1976 static if(!is(typeof(LDAP_FILTER_NOT))) { 1977 private enum enumMixinStr_LDAP_FILTER_NOT = `enum LDAP_FILTER_NOT = ( cast( ber_tag_t ) 0xa2U );`; 1978 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_NOT); }))) { 1979 mixin(enumMixinStr_LDAP_FILTER_NOT); 1980 } 1981 } 1982 1983 1984 1985 1986 static if(!is(typeof(LDAP_FILTER_OR))) { 1987 private enum enumMixinStr_LDAP_FILTER_OR = `enum LDAP_FILTER_OR = ( cast( ber_tag_t ) 0xa1U );`; 1988 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_OR); }))) { 1989 mixin(enumMixinStr_LDAP_FILTER_OR); 1990 } 1991 } 1992 1993 1994 1995 1996 static if(!is(typeof(LDAP_FILTER_AND))) { 1997 private enum enumMixinStr_LDAP_FILTER_AND = `enum LDAP_FILTER_AND = ( cast( ber_tag_t ) 0xa0U );`; 1998 static if(is(typeof({ mixin(enumMixinStr_LDAP_FILTER_AND); }))) { 1999 mixin(enumMixinStr_LDAP_FILTER_AND); 2000 } 2001 } 2002 2003 2004 2005 2006 static if(!is(typeof(LDAP_AUTH_NEGOTIATE))) { 2007 private enum enumMixinStr_LDAP_AUTH_NEGOTIATE = `enum LDAP_AUTH_NEGOTIATE = ( cast( ber_tag_t ) 0x04FFU );`; 2008 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_NEGOTIATE); }))) { 2009 mixin(enumMixinStr_LDAP_AUTH_NEGOTIATE); 2010 } 2011 } 2012 2013 2014 2015 2016 static if(!is(typeof(LDAP_AUTH_KRBV42))) { 2017 private enum enumMixinStr_LDAP_AUTH_KRBV42 = `enum LDAP_AUTH_KRBV42 = ( cast( ber_tag_t ) 0x82U );`; 2018 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_KRBV42); }))) { 2019 mixin(enumMixinStr_LDAP_AUTH_KRBV42); 2020 } 2021 } 2022 2023 2024 2025 2026 static if(!is(typeof(LDAP_AUTH_KRBV41))) { 2027 private enum enumMixinStr_LDAP_AUTH_KRBV41 = `enum LDAP_AUTH_KRBV41 = ( cast( ber_tag_t ) 0x81U );`; 2028 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_KRBV41); }))) { 2029 mixin(enumMixinStr_LDAP_AUTH_KRBV41); 2030 } 2031 } 2032 2033 2034 2035 2036 static if(!is(typeof(LDAP_AUTH_KRBV4))) { 2037 private enum enumMixinStr_LDAP_AUTH_KRBV4 = `enum LDAP_AUTH_KRBV4 = ( cast( ber_tag_t ) 0xffU );`; 2038 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_KRBV4); }))) { 2039 mixin(enumMixinStr_LDAP_AUTH_KRBV4); 2040 } 2041 } 2042 2043 2044 2045 2046 static if(!is(typeof(LDAP_AUTH_SASL))) { 2047 private enum enumMixinStr_LDAP_AUTH_SASL = `enum LDAP_AUTH_SASL = ( cast( ber_tag_t ) 0xa3U );`; 2048 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_SASL); }))) { 2049 mixin(enumMixinStr_LDAP_AUTH_SASL); 2050 } 2051 } 2052 2053 2054 2055 2056 static if(!is(typeof(LDAP_AUTH_SIMPLE))) { 2057 private enum enumMixinStr_LDAP_AUTH_SIMPLE = `enum LDAP_AUTH_SIMPLE = ( cast( ber_tag_t ) 0x80U );`; 2058 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_SIMPLE); }))) { 2059 mixin(enumMixinStr_LDAP_AUTH_SIMPLE); 2060 } 2061 } 2062 2063 2064 2065 2066 static if(!is(typeof(LDAP_AUTH_NONE))) { 2067 private enum enumMixinStr_LDAP_AUTH_NONE = `enum LDAP_AUTH_NONE = ( cast( ber_tag_t ) 0x00U );`; 2068 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_NONE); }))) { 2069 mixin(enumMixinStr_LDAP_AUTH_NONE); 2070 } 2071 } 2072 2073 2074 2075 2076 static if(!is(typeof(LDAP_SASL_NULL))) { 2077 private enum enumMixinStr_LDAP_SASL_NULL = `enum LDAP_SASL_NULL = ( "" );`; 2078 static if(is(typeof({ mixin(enumMixinStr_LDAP_SASL_NULL); }))) { 2079 mixin(enumMixinStr_LDAP_SASL_NULL); 2080 } 2081 } 2082 2083 2084 2085 2086 static if(!is(typeof(LDAP_SASL_SIMPLE))) { 2087 private enum enumMixinStr_LDAP_SASL_SIMPLE = `enum LDAP_SASL_SIMPLE = ( cast( char * ) 0 );`; 2088 static if(is(typeof({ mixin(enumMixinStr_LDAP_SASL_SIMPLE); }))) { 2089 mixin(enumMixinStr_LDAP_SASL_SIMPLE); 2090 } 2091 } 2092 2093 2094 2095 2096 static if(!is(typeof(LDAP_RES_UNSOLICITED))) { 2097 private enum enumMixinStr_LDAP_RES_UNSOLICITED = `enum LDAP_RES_UNSOLICITED = ( 0 );`; 2098 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_UNSOLICITED); }))) { 2099 mixin(enumMixinStr_LDAP_RES_UNSOLICITED); 2100 } 2101 } 2102 2103 2104 2105 2106 static if(!is(typeof(LDAP_RES_ANY))) { 2107 private enum enumMixinStr_LDAP_RES_ANY = `enum LDAP_RES_ANY = ( - 1 );`; 2108 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_ANY); }))) { 2109 mixin(enumMixinStr_LDAP_RES_ANY); 2110 } 2111 } 2112 2113 2114 2115 2116 static if(!is(typeof(LDAP_RES_INTERMEDIATE))) { 2117 private enum enumMixinStr_LDAP_RES_INTERMEDIATE = `enum LDAP_RES_INTERMEDIATE = ( cast( ber_tag_t ) 0x79U );`; 2118 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_INTERMEDIATE); }))) { 2119 mixin(enumMixinStr_LDAP_RES_INTERMEDIATE); 2120 } 2121 } 2122 2123 2124 2125 2126 static if(!is(typeof(LDAP_RES_EXTENDED))) { 2127 private enum enumMixinStr_LDAP_RES_EXTENDED = `enum LDAP_RES_EXTENDED = ( cast( ber_tag_t ) 0x78U );`; 2128 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_EXTENDED); }))) { 2129 mixin(enumMixinStr_LDAP_RES_EXTENDED); 2130 } 2131 } 2132 2133 2134 2135 2136 static if(!is(typeof(LDAP_RES_COMPARE))) { 2137 private enum enumMixinStr_LDAP_RES_COMPARE = `enum LDAP_RES_COMPARE = ( cast( ber_tag_t ) 0x6fU );`; 2138 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_COMPARE); }))) { 2139 mixin(enumMixinStr_LDAP_RES_COMPARE); 2140 } 2141 } 2142 2143 2144 2145 2146 static if(!is(typeof(LDAP_RES_RENAME))) { 2147 private enum enumMixinStr_LDAP_RES_RENAME = `enum LDAP_RES_RENAME = LDAP_RES_MODDN;`; 2148 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_RENAME); }))) { 2149 mixin(enumMixinStr_LDAP_RES_RENAME); 2150 } 2151 } 2152 2153 2154 2155 2156 static if(!is(typeof(LDAP_RES_MODRDN))) { 2157 private enum enumMixinStr_LDAP_RES_MODRDN = `enum LDAP_RES_MODRDN = LDAP_RES_MODDN;`; 2158 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_MODRDN); }))) { 2159 mixin(enumMixinStr_LDAP_RES_MODRDN); 2160 } 2161 } 2162 2163 2164 2165 2166 static if(!is(typeof(LDAP_RES_MODDN))) { 2167 private enum enumMixinStr_LDAP_RES_MODDN = `enum LDAP_RES_MODDN = ( cast( ber_tag_t ) 0x6dU );`; 2168 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_MODDN); }))) { 2169 mixin(enumMixinStr_LDAP_RES_MODDN); 2170 } 2171 } 2172 2173 2174 2175 2176 static if(!is(typeof(LDAP_RES_DELETE))) { 2177 private enum enumMixinStr_LDAP_RES_DELETE = `enum LDAP_RES_DELETE = ( cast( ber_tag_t ) 0x6bU );`; 2178 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_DELETE); }))) { 2179 mixin(enumMixinStr_LDAP_RES_DELETE); 2180 } 2181 } 2182 2183 2184 2185 2186 static if(!is(typeof(LDAP_RES_ADD))) { 2187 private enum enumMixinStr_LDAP_RES_ADD = `enum LDAP_RES_ADD = ( cast( ber_tag_t ) 0x69U );`; 2188 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_ADD); }))) { 2189 mixin(enumMixinStr_LDAP_RES_ADD); 2190 } 2191 } 2192 2193 2194 2195 2196 static if(!is(typeof(LDAP_RES_MODIFY))) { 2197 private enum enumMixinStr_LDAP_RES_MODIFY = `enum LDAP_RES_MODIFY = ( cast( ber_tag_t ) 0x67U );`; 2198 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_MODIFY); }))) { 2199 mixin(enumMixinStr_LDAP_RES_MODIFY); 2200 } 2201 } 2202 2203 2204 2205 2206 static if(!is(typeof(LDAP_RES_SEARCH_RESULT))) { 2207 private enum enumMixinStr_LDAP_RES_SEARCH_RESULT = `enum LDAP_RES_SEARCH_RESULT = ( cast( ber_tag_t ) 0x65U );`; 2208 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_SEARCH_RESULT); }))) { 2209 mixin(enumMixinStr_LDAP_RES_SEARCH_RESULT); 2210 } 2211 } 2212 2213 2214 2215 2216 static if(!is(typeof(LDAP_RES_SEARCH_REFERENCE))) { 2217 private enum enumMixinStr_LDAP_RES_SEARCH_REFERENCE = `enum LDAP_RES_SEARCH_REFERENCE = ( cast( ber_tag_t ) 0x73U );`; 2218 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_SEARCH_REFERENCE); }))) { 2219 mixin(enumMixinStr_LDAP_RES_SEARCH_REFERENCE); 2220 } 2221 } 2222 2223 2224 2225 2226 static if(!is(typeof(LDAP_RES_SEARCH_ENTRY))) { 2227 private enum enumMixinStr_LDAP_RES_SEARCH_ENTRY = `enum LDAP_RES_SEARCH_ENTRY = ( cast( ber_tag_t ) 0x64U );`; 2228 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_SEARCH_ENTRY); }))) { 2229 mixin(enumMixinStr_LDAP_RES_SEARCH_ENTRY); 2230 } 2231 } 2232 2233 2234 2235 2236 static if(!is(typeof(LDAP_RES_BIND))) { 2237 private enum enumMixinStr_LDAP_RES_BIND = `enum LDAP_RES_BIND = ( cast( ber_tag_t ) 0x61U );`; 2238 static if(is(typeof({ mixin(enumMixinStr_LDAP_RES_BIND); }))) { 2239 mixin(enumMixinStr_LDAP_RES_BIND); 2240 } 2241 } 2242 2243 2244 2245 2246 static if(!is(typeof(LDAP_REQ_EXTENDED))) { 2247 private enum enumMixinStr_LDAP_REQ_EXTENDED = `enum LDAP_REQ_EXTENDED = ( cast( ber_tag_t ) 0x77U );`; 2248 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_EXTENDED); }))) { 2249 mixin(enumMixinStr_LDAP_REQ_EXTENDED); 2250 } 2251 } 2252 2253 2254 2255 2256 static if(!is(typeof(LDAP_REQ_ABANDON))) { 2257 private enum enumMixinStr_LDAP_REQ_ABANDON = `enum LDAP_REQ_ABANDON = ( cast( ber_tag_t ) 0x50U );`; 2258 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_ABANDON); }))) { 2259 mixin(enumMixinStr_LDAP_REQ_ABANDON); 2260 } 2261 } 2262 2263 2264 2265 2266 static if(!is(typeof(LDAP_REQ_COMPARE))) { 2267 private enum enumMixinStr_LDAP_REQ_COMPARE = `enum LDAP_REQ_COMPARE = ( cast( ber_tag_t ) 0x6eU );`; 2268 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_COMPARE); }))) { 2269 mixin(enumMixinStr_LDAP_REQ_COMPARE); 2270 } 2271 } 2272 2273 2274 2275 2276 static if(!is(typeof(LDAP_REQ_RENAME))) { 2277 private enum enumMixinStr_LDAP_REQ_RENAME = `enum LDAP_REQ_RENAME = LDAP_REQ_MODDN;`; 2278 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_RENAME); }))) { 2279 mixin(enumMixinStr_LDAP_REQ_RENAME); 2280 } 2281 } 2282 2283 2284 2285 2286 static if(!is(typeof(LDAP_REQ_MODRDN))) { 2287 private enum enumMixinStr_LDAP_REQ_MODRDN = `enum LDAP_REQ_MODRDN = LDAP_REQ_MODDN;`; 2288 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_MODRDN); }))) { 2289 mixin(enumMixinStr_LDAP_REQ_MODRDN); 2290 } 2291 } 2292 2293 2294 2295 2296 static if(!is(typeof(LDAP_REQ_MODDN))) { 2297 private enum enumMixinStr_LDAP_REQ_MODDN = `enum LDAP_REQ_MODDN = ( cast( ber_tag_t ) 0x6cU );`; 2298 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_MODDN); }))) { 2299 mixin(enumMixinStr_LDAP_REQ_MODDN); 2300 } 2301 } 2302 2303 2304 2305 2306 static if(!is(typeof(LDAP_REQ_DELETE))) { 2307 private enum enumMixinStr_LDAP_REQ_DELETE = `enum LDAP_REQ_DELETE = ( cast( ber_tag_t ) 0x4aU );`; 2308 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_DELETE); }))) { 2309 mixin(enumMixinStr_LDAP_REQ_DELETE); 2310 } 2311 } 2312 2313 2314 2315 2316 static if(!is(typeof(LDAP_REQ_ADD))) { 2317 private enum enumMixinStr_LDAP_REQ_ADD = `enum LDAP_REQ_ADD = ( cast( ber_tag_t ) 0x68U );`; 2318 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_ADD); }))) { 2319 mixin(enumMixinStr_LDAP_REQ_ADD); 2320 } 2321 } 2322 2323 2324 2325 2326 static if(!is(typeof(LDAP_REQ_MODIFY))) { 2327 private enum enumMixinStr_LDAP_REQ_MODIFY = `enum LDAP_REQ_MODIFY = ( cast( ber_tag_t ) 0x66U );`; 2328 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_MODIFY); }))) { 2329 mixin(enumMixinStr_LDAP_REQ_MODIFY); 2330 } 2331 } 2332 2333 2334 2335 2336 static if(!is(typeof(LDAP_REQ_SEARCH))) { 2337 private enum enumMixinStr_LDAP_REQ_SEARCH = `enum LDAP_REQ_SEARCH = ( cast( ber_tag_t ) 0x63U );`; 2338 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_SEARCH); }))) { 2339 mixin(enumMixinStr_LDAP_REQ_SEARCH); 2340 } 2341 } 2342 2343 2344 2345 2346 static if(!is(typeof(LDAP_REQ_UNBIND))) { 2347 private enum enumMixinStr_LDAP_REQ_UNBIND = `enum LDAP_REQ_UNBIND = ( cast( ber_tag_t ) 0x42U );`; 2348 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_UNBIND); }))) { 2349 mixin(enumMixinStr_LDAP_REQ_UNBIND); 2350 } 2351 } 2352 2353 2354 2355 2356 static if(!is(typeof(LDAP_REQ_BIND))) { 2357 private enum enumMixinStr_LDAP_REQ_BIND = `enum LDAP_REQ_BIND = ( cast( ber_tag_t ) 0x60U );`; 2358 static if(is(typeof({ mixin(enumMixinStr_LDAP_REQ_BIND); }))) { 2359 mixin(enumMixinStr_LDAP_REQ_BIND); 2360 } 2361 } 2362 2363 2364 2365 2366 static if(!is(typeof(LDAP_TAG_SASL_RES_CREDS))) { 2367 private enum enumMixinStr_LDAP_TAG_SASL_RES_CREDS = `enum LDAP_TAG_SASL_RES_CREDS = ( cast( ber_tag_t ) 0x87U );`; 2368 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_SASL_RES_CREDS); }))) { 2369 mixin(enumMixinStr_LDAP_TAG_SASL_RES_CREDS); 2370 } 2371 } 2372 2373 2374 2375 2376 static if(!is(typeof(LDAP_TAG_IM_RES_VALUE))) { 2377 private enum enumMixinStr_LDAP_TAG_IM_RES_VALUE = `enum LDAP_TAG_IM_RES_VALUE = ( cast( ber_tag_t ) 0x81U );`; 2378 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_IM_RES_VALUE); }))) { 2379 mixin(enumMixinStr_LDAP_TAG_IM_RES_VALUE); 2380 } 2381 } 2382 2383 2384 2385 2386 static if(!is(typeof(LDAP_TAG_IM_RES_OID))) { 2387 private enum enumMixinStr_LDAP_TAG_IM_RES_OID = `enum LDAP_TAG_IM_RES_OID = ( cast( ber_tag_t ) 0x80U );`; 2388 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_IM_RES_OID); }))) { 2389 mixin(enumMixinStr_LDAP_TAG_IM_RES_OID); 2390 } 2391 } 2392 2393 2394 2395 2396 static if(!is(typeof(LDAP_TAG_EXOP_RES_VALUE))) { 2397 private enum enumMixinStr_LDAP_TAG_EXOP_RES_VALUE = `enum LDAP_TAG_EXOP_RES_VALUE = ( cast( ber_tag_t ) 0x8bU );`; 2398 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_RES_VALUE); }))) { 2399 mixin(enumMixinStr_LDAP_TAG_EXOP_RES_VALUE); 2400 } 2401 } 2402 2403 2404 2405 2406 static if(!is(typeof(LDAP_TAG_EXOP_RES_OID))) { 2407 private enum enumMixinStr_LDAP_TAG_EXOP_RES_OID = `enum LDAP_TAG_EXOP_RES_OID = ( cast( ber_tag_t ) 0x8aU );`; 2408 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_RES_OID); }))) { 2409 mixin(enumMixinStr_LDAP_TAG_EXOP_RES_OID); 2410 } 2411 } 2412 2413 2414 2415 2416 static if(!is(typeof(LDAP_TAG_EXOP_REQ_VALUE))) { 2417 private enum enumMixinStr_LDAP_TAG_EXOP_REQ_VALUE = `enum LDAP_TAG_EXOP_REQ_VALUE = ( cast( ber_tag_t ) 0x81U );`; 2418 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_REQ_VALUE); }))) { 2419 mixin(enumMixinStr_LDAP_TAG_EXOP_REQ_VALUE); 2420 } 2421 } 2422 2423 2424 2425 2426 static if(!is(typeof(LDAP_TAG_EXOP_REQ_OID))) { 2427 private enum enumMixinStr_LDAP_TAG_EXOP_REQ_OID = `enum LDAP_TAG_EXOP_REQ_OID = ( cast( ber_tag_t ) 0x80U );`; 2428 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_REQ_OID); }))) { 2429 mixin(enumMixinStr_LDAP_TAG_EXOP_REQ_OID); 2430 } 2431 } 2432 2433 2434 2435 2436 static if(!is(typeof(LDAP_TAG_NEWSUPERIOR))) { 2437 private enum enumMixinStr_LDAP_TAG_NEWSUPERIOR = `enum LDAP_TAG_NEWSUPERIOR = ( cast( ber_tag_t ) 0x80U );`; 2438 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_NEWSUPERIOR); }))) { 2439 mixin(enumMixinStr_LDAP_TAG_NEWSUPERIOR); 2440 } 2441 } 2442 2443 2444 2445 2446 static if(!is(typeof(LDAP_TAG_REFERRAL))) { 2447 private enum enumMixinStr_LDAP_TAG_REFERRAL = `enum LDAP_TAG_REFERRAL = ( cast( ber_tag_t ) 0xa3U );`; 2448 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_REFERRAL); }))) { 2449 mixin(enumMixinStr_LDAP_TAG_REFERRAL); 2450 } 2451 } 2452 2453 2454 2455 2456 static if(!is(typeof(LDAP_TAG_CONTROLS))) { 2457 private enum enumMixinStr_LDAP_TAG_CONTROLS = `enum LDAP_TAG_CONTROLS = ( cast( ber_tag_t ) 0xa0U );`; 2458 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_CONTROLS); }))) { 2459 mixin(enumMixinStr_LDAP_TAG_CONTROLS); 2460 } 2461 } 2462 2463 2464 2465 2466 static if(!is(typeof(LDAP_TAG_LDAPCRED))) { 2467 private enum enumMixinStr_LDAP_TAG_LDAPCRED = `enum LDAP_TAG_LDAPCRED = ( cast( ber_tag_t ) 0x04U );`; 2468 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_LDAPCRED); }))) { 2469 mixin(enumMixinStr_LDAP_TAG_LDAPCRED); 2470 } 2471 } 2472 2473 2474 2475 2476 static if(!is(typeof(LDAP_TAG_LDAPDN))) { 2477 private enum enumMixinStr_LDAP_TAG_LDAPDN = `enum LDAP_TAG_LDAPDN = ( cast( ber_tag_t ) 0x04U );`; 2478 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_LDAPDN); }))) { 2479 mixin(enumMixinStr_LDAP_TAG_LDAPDN); 2480 } 2481 } 2482 2483 2484 2485 2486 static if(!is(typeof(LDAP_TAG_MSGID))) { 2487 private enum enumMixinStr_LDAP_TAG_MSGID = `enum LDAP_TAG_MSGID = ( cast( ber_tag_t ) 0x02U );`; 2488 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_MSGID); }))) { 2489 mixin(enumMixinStr_LDAP_TAG_MSGID); 2490 } 2491 } 2492 2493 2494 2495 2496 static if(!is(typeof(LDAP_TAG_MESSAGE))) { 2497 private enum enumMixinStr_LDAP_TAG_MESSAGE = `enum LDAP_TAG_MESSAGE = ( cast( ber_tag_t ) 0x30U );`; 2498 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_MESSAGE); }))) { 2499 mixin(enumMixinStr_LDAP_TAG_MESSAGE); 2500 } 2501 } 2502 2503 2504 2505 2506 static if(!is(typeof(LDAP_FEATURE_CHILDREN_SCOPE))) { 2507 private enum enumMixinStr_LDAP_FEATURE_CHILDREN_SCOPE = `enum LDAP_FEATURE_CHILDREN_SCOPE = LDAP_FEATURE_SUBORDINATE_SCOPE;`; 2508 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_CHILDREN_SCOPE); }))) { 2509 mixin(enumMixinStr_LDAP_FEATURE_CHILDREN_SCOPE); 2510 } 2511 } 2512 2513 2514 2515 2516 static if(!is(typeof(LDAP_FEATURE_SUBORDINATE_SCOPE))) { 2517 private enum enumMixinStr_LDAP_FEATURE_SUBORDINATE_SCOPE = `enum LDAP_FEATURE_SUBORDINATE_SCOPE = "1.3.6.1.4.1.4203.666.8.1";`; 2518 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_SUBORDINATE_SCOPE); }))) { 2519 mixin(enumMixinStr_LDAP_FEATURE_SUBORDINATE_SCOPE); 2520 } 2521 } 2522 2523 2524 2525 2526 static if(!is(typeof(LDAP_FEATURE_MODIFY_INCREMENT))) { 2527 private enum enumMixinStr_LDAP_FEATURE_MODIFY_INCREMENT = `enum LDAP_FEATURE_MODIFY_INCREMENT = "1.3.6.1.1.14";`; 2528 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_MODIFY_INCREMENT); }))) { 2529 mixin(enumMixinStr_LDAP_FEATURE_MODIFY_INCREMENT); 2530 } 2531 } 2532 2533 2534 2535 2536 static if(!is(typeof(LDAP_FEATURE_LANGUAGE_RANGE_OPTIONS))) { 2537 private enum enumMixinStr_LDAP_FEATURE_LANGUAGE_RANGE_OPTIONS = `enum LDAP_FEATURE_LANGUAGE_RANGE_OPTIONS = "1.3.6.1.4.1.4203.1.5.5";`; 2538 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_LANGUAGE_RANGE_OPTIONS); }))) { 2539 mixin(enumMixinStr_LDAP_FEATURE_LANGUAGE_RANGE_OPTIONS); 2540 } 2541 } 2542 2543 2544 2545 2546 static if(!is(typeof(LDAP_FEATURE_LANGUAGE_TAG_OPTIONS))) { 2547 private enum enumMixinStr_LDAP_FEATURE_LANGUAGE_TAG_OPTIONS = `enum LDAP_FEATURE_LANGUAGE_TAG_OPTIONS = "1.3.6.1.4.1.4203.1.5.4";`; 2548 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_LANGUAGE_TAG_OPTIONS); }))) { 2549 mixin(enumMixinStr_LDAP_FEATURE_LANGUAGE_TAG_OPTIONS); 2550 } 2551 } 2552 2553 2554 2555 2556 static if(!is(typeof(LDAP_FEATURE_ABSOLUTE_FILTERS))) { 2557 private enum enumMixinStr_LDAP_FEATURE_ABSOLUTE_FILTERS = `enum LDAP_FEATURE_ABSOLUTE_FILTERS = "1.3.6.1.4.1.4203.1.5.3";`; 2558 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_ABSOLUTE_FILTERS); }))) { 2559 mixin(enumMixinStr_LDAP_FEATURE_ABSOLUTE_FILTERS); 2560 } 2561 } 2562 2563 2564 2565 2566 static if(!is(typeof(LDAP_FEATURE_OBJECTCLASS_ATTRS))) { 2567 private enum enumMixinStr_LDAP_FEATURE_OBJECTCLASS_ATTRS = `enum LDAP_FEATURE_OBJECTCLASS_ATTRS = "1.3.6.1.4.1.4203.1.5.2";`; 2568 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_OBJECTCLASS_ATTRS); }))) { 2569 mixin(enumMixinStr_LDAP_FEATURE_OBJECTCLASS_ATTRS); 2570 } 2571 } 2572 2573 2574 2575 2576 static if(!is(typeof(LDAP_FEATURE_ALL_OP_ATTRS))) { 2577 private enum enumMixinStr_LDAP_FEATURE_ALL_OP_ATTRS = `enum LDAP_FEATURE_ALL_OP_ATTRS = "1.3.6.1.4.1.4203.1.5.1";`; 2578 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_ALL_OP_ATTRS); }))) { 2579 mixin(enumMixinStr_LDAP_FEATURE_ALL_OP_ATTRS); 2580 } 2581 } 2582 2583 2584 2585 2586 static if(!is(typeof(LDAP_URLEXT_X_FAILEDNAME))) { 2587 private enum enumMixinStr_LDAP_URLEXT_X_FAILEDNAME = `enum LDAP_URLEXT_X_FAILEDNAME = "x-failedName";`; 2588 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_FAILEDNAME); }))) { 2589 mixin(enumMixinStr_LDAP_URLEXT_X_FAILEDNAME); 2590 } 2591 } 2592 2593 2594 2595 2596 static if(!is(typeof(LDAP_URLEXT_X_SEARCHEDSUBTREE))) { 2597 private enum enumMixinStr_LDAP_URLEXT_X_SEARCHEDSUBTREE = `enum LDAP_URLEXT_X_SEARCHEDSUBTREE = "x-searchedSubtree";`; 2598 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_SEARCHEDSUBTREE); }))) { 2599 mixin(enumMixinStr_LDAP_URLEXT_X_SEARCHEDSUBTREE); 2600 } 2601 } 2602 2603 2604 2605 2606 static if(!is(typeof(LDAP_URLEXT_X_REFTYPE))) { 2607 private enum enumMixinStr_LDAP_URLEXT_X_REFTYPE = `enum LDAP_URLEXT_X_REFTYPE = "x-referenceType";`; 2608 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_REFTYPE); }))) { 2609 mixin(enumMixinStr_LDAP_URLEXT_X_REFTYPE); 2610 } 2611 } 2612 2613 2614 2615 2616 static if(!is(typeof(LDAP_URLEXT_X_LOCALREF))) { 2617 private enum enumMixinStr_LDAP_URLEXT_X_LOCALREF = `enum LDAP_URLEXT_X_LOCALREF = "x-localReference";`; 2618 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_LOCALREF); }))) { 2619 mixin(enumMixinStr_LDAP_URLEXT_X_LOCALREF); 2620 } 2621 } 2622 2623 2624 2625 2626 static if(!is(typeof(LDAP_URLEXT_X_FAILEDNAMEOID))) { 2627 private enum enumMixinStr_LDAP_URLEXT_X_FAILEDNAMEOID = `enum LDAP_URLEXT_X_FAILEDNAMEOID = LDAP_X_DISTPROC_BASE ".7";`; 2628 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_FAILEDNAMEOID); }))) { 2629 mixin(enumMixinStr_LDAP_URLEXT_X_FAILEDNAMEOID); 2630 } 2631 } 2632 2633 2634 2635 2636 static if(!is(typeof(LDAP_URLEXT_X_SEARCHEDSUBTREEOID))) { 2637 private enum enumMixinStr_LDAP_URLEXT_X_SEARCHEDSUBTREEOID = `enum LDAP_URLEXT_X_SEARCHEDSUBTREEOID = LDAP_X_DISTPROC_BASE ".6";`; 2638 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_SEARCHEDSUBTREEOID); }))) { 2639 mixin(enumMixinStr_LDAP_URLEXT_X_SEARCHEDSUBTREEOID); 2640 } 2641 } 2642 2643 2644 2645 2646 static if(!is(typeof(LDAP_URLEXT_X_REFTYPEOID))) { 2647 private enum enumMixinStr_LDAP_URLEXT_X_REFTYPEOID = `enum LDAP_URLEXT_X_REFTYPEOID = LDAP_X_DISTPROC_BASE ".5";`; 2648 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_REFTYPEOID); }))) { 2649 mixin(enumMixinStr_LDAP_URLEXT_X_REFTYPEOID); 2650 } 2651 } 2652 2653 2654 2655 2656 static if(!is(typeof(LDAP_URLEXT_X_LOCALREFOID))) { 2657 private enum enumMixinStr_LDAP_URLEXT_X_LOCALREFOID = `enum LDAP_URLEXT_X_LOCALREFOID = LDAP_X_DISTPROC_BASE ".4";`; 2658 static if(is(typeof({ mixin(enumMixinStr_LDAP_URLEXT_X_LOCALREFOID); }))) { 2659 mixin(enumMixinStr_LDAP_URLEXT_X_LOCALREFOID); 2660 } 2661 } 2662 2663 2664 2665 2666 static if(!is(typeof(LDAP_CONTROL_X_RETURNCONTREF))) { 2667 private enum enumMixinStr_LDAP_CONTROL_X_RETURNCONTREF = `enum LDAP_CONTROL_X_RETURNCONTREF = LDAP_X_DISTPROC_BASE ".3";`; 2668 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_RETURNCONTREF); }))) { 2669 mixin(enumMixinStr_LDAP_CONTROL_X_RETURNCONTREF); 2670 } 2671 } 2672 2673 2674 2675 2676 static if(!is(typeof(LDAP_FEATURE_X_CANCHAINOPS))) { 2677 private enum enumMixinStr_LDAP_FEATURE_X_CANCHAINOPS = `enum LDAP_FEATURE_X_CANCHAINOPS = LDAP_X_DISTPROC_BASE ".2";`; 2678 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_X_CANCHAINOPS); }))) { 2679 mixin(enumMixinStr_LDAP_FEATURE_X_CANCHAINOPS); 2680 } 2681 } 2682 2683 2684 2685 2686 static if(!is(typeof(LDAP_EXOP_X_CHAINEDREQUEST))) { 2687 private enum enumMixinStr_LDAP_EXOP_X_CHAINEDREQUEST = `enum LDAP_EXOP_X_CHAINEDREQUEST = LDAP_X_DISTPROC_BASE ".1";`; 2688 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_X_CHAINEDREQUEST); }))) { 2689 mixin(enumMixinStr_LDAP_EXOP_X_CHAINEDREQUEST); 2690 } 2691 } 2692 2693 2694 2695 2696 static if(!is(typeof(LDAP_X_DISTPROC_BASE))) { 2697 private enum enumMixinStr_LDAP_X_DISTPROC_BASE = `enum LDAP_X_DISTPROC_BASE = "1.3.6.1.4.1.4203.666.11.6";`; 2698 static if(is(typeof({ mixin(enumMixinStr_LDAP_X_DISTPROC_BASE); }))) { 2699 mixin(enumMixinStr_LDAP_X_DISTPROC_BASE); 2700 } 2701 } 2702 2703 2704 2705 2706 static if(!is(typeof(LDAP_EXOP_X_TURN))) { 2707 private enum enumMixinStr_LDAP_EXOP_X_TURN = `enum LDAP_EXOP_X_TURN = LDAP_EXOP_TURN;`; 2708 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_X_TURN); }))) { 2709 mixin(enumMixinStr_LDAP_EXOP_X_TURN); 2710 } 2711 } 2712 2713 2714 2715 2716 static if(!is(typeof(LDAP_EXOP_TURN))) { 2717 private enum enumMixinStr_LDAP_EXOP_TURN = `enum LDAP_EXOP_TURN = "1.3.6.1.1.19";`; 2718 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_TURN); }))) { 2719 mixin(enumMixinStr_LDAP_EXOP_TURN); 2720 } 2721 } 2722 2723 2724 2725 2726 static if(!is(typeof(LDAP_EXOP_X_WHO_AM_I))) { 2727 private enum enumMixinStr_LDAP_EXOP_X_WHO_AM_I = `enum LDAP_EXOP_X_WHO_AM_I = LDAP_EXOP_WHO_AM_I;`; 2728 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_X_WHO_AM_I); }))) { 2729 mixin(enumMixinStr_LDAP_EXOP_X_WHO_AM_I); 2730 } 2731 } 2732 2733 2734 2735 2736 static if(!is(typeof(LDAP_EXOP_WHO_AM_I))) { 2737 private enum enumMixinStr_LDAP_EXOP_WHO_AM_I = `enum LDAP_EXOP_WHO_AM_I = "1.3.6.1.4.1.4203.1.11.3";`; 2738 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_WHO_AM_I); }))) { 2739 mixin(enumMixinStr_LDAP_EXOP_WHO_AM_I); 2740 } 2741 } 2742 2743 2744 2745 2746 static if(!is(typeof(LDAP_TAG_EXOP_REFRESH_RES_TTL))) { 2747 private enum enumMixinStr_LDAP_TAG_EXOP_REFRESH_RES_TTL = `enum LDAP_TAG_EXOP_REFRESH_RES_TTL = ( cast( ber_tag_t ) 0x81U );`; 2748 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_REFRESH_RES_TTL); }))) { 2749 mixin(enumMixinStr_LDAP_TAG_EXOP_REFRESH_RES_TTL); 2750 } 2751 } 2752 2753 2754 2755 2756 static if(!is(typeof(LDAP_TAG_EXOP_REFRESH_REQ_TTL))) { 2757 private enum enumMixinStr_LDAP_TAG_EXOP_REFRESH_REQ_TTL = `enum LDAP_TAG_EXOP_REFRESH_REQ_TTL = ( cast( ber_tag_t ) 0x81U );`; 2758 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_REFRESH_REQ_TTL); }))) { 2759 mixin(enumMixinStr_LDAP_TAG_EXOP_REFRESH_REQ_TTL); 2760 } 2761 } 2762 2763 2764 2765 2766 static if(!is(typeof(LDAP_TAG_EXOP_REFRESH_REQ_DN))) { 2767 private enum enumMixinStr_LDAP_TAG_EXOP_REFRESH_REQ_DN = `enum LDAP_TAG_EXOP_REFRESH_REQ_DN = ( cast( ber_tag_t ) 0x80U );`; 2768 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_REFRESH_REQ_DN); }))) { 2769 mixin(enumMixinStr_LDAP_TAG_EXOP_REFRESH_REQ_DN); 2770 } 2771 } 2772 2773 2774 2775 2776 static if(!is(typeof(LDAP_EXOP_REFRESH))) { 2777 private enum enumMixinStr_LDAP_EXOP_REFRESH = `enum LDAP_EXOP_REFRESH = "1.3.6.1.4.1.1466.101.119.1";`; 2778 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_REFRESH); }))) { 2779 mixin(enumMixinStr_LDAP_EXOP_REFRESH); 2780 } 2781 } 2782 2783 2784 2785 2786 static if(!is(typeof(LDAP_EXOP_X_CANCEL))) { 2787 private enum enumMixinStr_LDAP_EXOP_X_CANCEL = `enum LDAP_EXOP_X_CANCEL = LDAP_EXOP_CANCEL;`; 2788 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_X_CANCEL); }))) { 2789 mixin(enumMixinStr_LDAP_EXOP_X_CANCEL); 2790 } 2791 } 2792 2793 2794 2795 2796 static if(!is(typeof(LDAP_EXOP_CANCEL))) { 2797 private enum enumMixinStr_LDAP_EXOP_CANCEL = `enum LDAP_EXOP_CANCEL = "1.3.6.1.1.8";`; 2798 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_CANCEL); }))) { 2799 mixin(enumMixinStr_LDAP_EXOP_CANCEL); 2800 } 2801 } 2802 2803 2804 2805 2806 static if(!is(typeof(LDAP_TAG_EXOP_MODIFY_PASSWD_GEN))) { 2807 private enum enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_GEN = `enum LDAP_TAG_EXOP_MODIFY_PASSWD_GEN = ( cast( ber_tag_t ) 0x80U );`; 2808 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_GEN); }))) { 2809 mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_GEN); 2810 } 2811 } 2812 2813 2814 2815 2816 static if(!is(typeof(LDAP_TAG_EXOP_MODIFY_PASSWD_NEW))) { 2817 private enum enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_NEW = `enum LDAP_TAG_EXOP_MODIFY_PASSWD_NEW = ( cast( ber_tag_t ) 0x82U );`; 2818 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_NEW); }))) { 2819 mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_NEW); 2820 } 2821 } 2822 2823 2824 2825 2826 static if(!is(typeof(LDAP_TAG_EXOP_MODIFY_PASSWD_OLD))) { 2827 private enum enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_OLD = `enum LDAP_TAG_EXOP_MODIFY_PASSWD_OLD = ( cast( ber_tag_t ) 0x81U );`; 2828 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_OLD); }))) { 2829 mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_OLD); 2830 } 2831 } 2832 2833 2834 2835 2836 static if(!is(typeof(LDAP_TAG_EXOP_MODIFY_PASSWD_ID))) { 2837 private enum enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_ID = `enum LDAP_TAG_EXOP_MODIFY_PASSWD_ID = ( cast( ber_tag_t ) 0x80U );`; 2838 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_ID); }))) { 2839 mixin(enumMixinStr_LDAP_TAG_EXOP_MODIFY_PASSWD_ID); 2840 } 2841 } 2842 2843 2844 2845 2846 static if(!is(typeof(LDAP_EXOP_MODIFY_PASSWD))) { 2847 private enum enumMixinStr_LDAP_EXOP_MODIFY_PASSWD = `enum LDAP_EXOP_MODIFY_PASSWD = "1.3.6.1.4.1.4203.1.11.1";`; 2848 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_MODIFY_PASSWD); }))) { 2849 mixin(enumMixinStr_LDAP_EXOP_MODIFY_PASSWD); 2850 } 2851 } 2852 2853 2854 2855 2856 static if(!is(typeof(LDAP_EXOP_START_TLS))) { 2857 private enum enumMixinStr_LDAP_EXOP_START_TLS = `enum LDAP_EXOP_START_TLS = "1.3.6.1.4.1.1466.20037";`; 2858 static if(is(typeof({ mixin(enumMixinStr_LDAP_EXOP_START_TLS); }))) { 2859 mixin(enumMixinStr_LDAP_EXOP_START_TLS); 2860 } 2861 } 2862 2863 2864 2865 2866 static if(!is(typeof(LDAP_NOTICE_DISCONNECT))) { 2867 private enum enumMixinStr_LDAP_NOTICE_DISCONNECT = `enum LDAP_NOTICE_DISCONNECT = LDAP_NOTICE_OF_DISCONNECTION;`; 2868 static if(is(typeof({ mixin(enumMixinStr_LDAP_NOTICE_DISCONNECT); }))) { 2869 mixin(enumMixinStr_LDAP_NOTICE_DISCONNECT); 2870 } 2871 } 2872 2873 2874 2875 2876 static if(!is(typeof(LDAP_NOTICE_OF_DISCONNECTION))) { 2877 private enum enumMixinStr_LDAP_NOTICE_OF_DISCONNECTION = `enum LDAP_NOTICE_OF_DISCONNECTION = "1.3.6.1.4.1.1466.20036";`; 2878 static if(is(typeof({ mixin(enumMixinStr_LDAP_NOTICE_OF_DISCONNECTION); }))) { 2879 mixin(enumMixinStr_LDAP_NOTICE_OF_DISCONNECTION); 2880 } 2881 } 2882 2883 2884 2885 2886 static if(!is(typeof(LDAP_CONTROL_VLVRESPONSE))) { 2887 private enum enumMixinStr_LDAP_CONTROL_VLVRESPONSE = `enum LDAP_CONTROL_VLVRESPONSE = "2.16.840.1.113730.3.4.10";`; 2888 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_VLVRESPONSE); }))) { 2889 mixin(enumMixinStr_LDAP_CONTROL_VLVRESPONSE); 2890 } 2891 } 2892 2893 2894 2895 2896 static if(!is(typeof(LDAP_CONTROL_VLVREQUEST))) { 2897 private enum enumMixinStr_LDAP_CONTROL_VLVREQUEST = `enum LDAP_CONTROL_VLVREQUEST = "2.16.840.1.113730.3.4.9";`; 2898 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_VLVREQUEST); }))) { 2899 mixin(enumMixinStr_LDAP_CONTROL_VLVREQUEST); 2900 } 2901 } 2902 2903 2904 2905 2906 static if(!is(typeof(LDAP_CONTROL_PERSIST_ENTRY_CHANGE_RENAME))) { 2907 private enum enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_RENAME = `enum LDAP_CONTROL_PERSIST_ENTRY_CHANGE_RENAME = 0x8;`; 2908 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_RENAME); }))) { 2909 mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_RENAME); 2910 } 2911 } 2912 2913 2914 2915 2916 static if(!is(typeof(LDAP_CONTROL_PERSIST_ENTRY_CHANGE_MODIFY))) { 2917 private enum enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_MODIFY = `enum LDAP_CONTROL_PERSIST_ENTRY_CHANGE_MODIFY = 0x4;`; 2918 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_MODIFY); }))) { 2919 mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_MODIFY); 2920 } 2921 } 2922 2923 2924 2925 2926 static if(!is(typeof(LDAP_CONTROL_PERSIST_ENTRY_CHANGE_DELETE))) { 2927 private enum enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_DELETE = `enum LDAP_CONTROL_PERSIST_ENTRY_CHANGE_DELETE = 0x2;`; 2928 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_DELETE); }))) { 2929 mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_DELETE); 2930 } 2931 } 2932 2933 2934 2935 2936 static if(!is(typeof(LDAP_CONTROL_PERSIST_ENTRY_CHANGE_ADD))) { 2937 private enum enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_ADD = `enum LDAP_CONTROL_PERSIST_ENTRY_CHANGE_ADD = 0x1;`; 2938 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_ADD); }))) { 2939 mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_ADD); 2940 } 2941 } 2942 2943 2944 2945 2946 static if(!is(typeof(LDAP_CONTROL_PERSIST_ENTRY_CHANGE_NOTICE))) { 2947 private enum enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_NOTICE = `enum LDAP_CONTROL_PERSIST_ENTRY_CHANGE_NOTICE = "2.16.840.1.113730.3.4.7";`; 2948 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_NOTICE); }))) { 2949 mixin(enumMixinStr_LDAP_CONTROL_PERSIST_ENTRY_CHANGE_NOTICE); 2950 } 2951 } 2952 2953 2954 2955 2956 static if(!is(typeof(LDAP_CONTROL_PERSIST_REQUEST))) { 2957 private enum enumMixinStr_LDAP_CONTROL_PERSIST_REQUEST = `enum LDAP_CONTROL_PERSIST_REQUEST = "2.16.840.1.113730.3.4.3";`; 2958 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PERSIST_REQUEST); }))) { 2959 mixin(enumMixinStr_LDAP_CONTROL_PERSIST_REQUEST); 2960 } 2961 } 2962 2963 2964 2965 2966 static if(!is(typeof(LDAP_CONTROL_DUPENT))) { 2967 private enum enumMixinStr_LDAP_CONTROL_DUPENT = `enum LDAP_CONTROL_DUPENT = LDAP_CONTROL_DUPENT_REQUEST;`; 2968 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_DUPENT); }))) { 2969 mixin(enumMixinStr_LDAP_CONTROL_DUPENT); 2970 } 2971 } 2972 2973 2974 2975 2976 static if(!is(typeof(LDAP_CONTROL_DUPENT_ENTRY))) { 2977 private enum enumMixinStr_LDAP_CONTROL_DUPENT_ENTRY = `enum LDAP_CONTROL_DUPENT_ENTRY = "2.16.840.1.113719.1.27.101.3";`; 2978 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_DUPENT_ENTRY); }))) { 2979 mixin(enumMixinStr_LDAP_CONTROL_DUPENT_ENTRY); 2980 } 2981 } 2982 2983 2984 2985 2986 static if(!is(typeof(LDAP_CONTROL_DUPENT_RESPONSE))) { 2987 private enum enumMixinStr_LDAP_CONTROL_DUPENT_RESPONSE = `enum LDAP_CONTROL_DUPENT_RESPONSE = "2.16.840.1.113719.1.27.101.2";`; 2988 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_DUPENT_RESPONSE); }))) { 2989 mixin(enumMixinStr_LDAP_CONTROL_DUPENT_RESPONSE); 2990 } 2991 } 2992 2993 2994 2995 2996 static if(!is(typeof(LDAP_CONTROL_DUPENT_REQUEST))) { 2997 private enum enumMixinStr_LDAP_CONTROL_DUPENT_REQUEST = `enum LDAP_CONTROL_DUPENT_REQUEST = "2.16.840.1.113719.1.27.101.1";`; 2998 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_DUPENT_REQUEST); }))) { 2999 mixin(enumMixinStr_LDAP_CONTROL_DUPENT_REQUEST); 3000 } 3001 } 3002 3003 3004 3005 3006 static if(!is(typeof(LDAP_CONTROL_X_SESSION_TRACKING_USERNAME))) { 3007 private enum enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_USERNAME = `enum LDAP_CONTROL_X_SESSION_TRACKING_USERNAME = LDAP_CONTROL_X_SESSION_TRACKING ".3";`; 3008 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_USERNAME); }))) { 3009 mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_USERNAME); 3010 } 3011 } 3012 3013 3014 3015 3016 static if(!is(typeof(LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_MULTI_SESSION_ID))) { 3017 private enum enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_MULTI_SESSION_ID = `enum LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_MULTI_SESSION_ID = LDAP_CONTROL_X_SESSION_TRACKING ".2";`; 3018 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_MULTI_SESSION_ID); }))) { 3019 mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_MULTI_SESSION_ID); 3020 } 3021 } 3022 3023 3024 3025 3026 static if(!is(typeof(LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_SESSION_ID))) { 3027 private enum enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_SESSION_ID = `enum LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_SESSION_ID = LDAP_CONTROL_X_SESSION_TRACKING ".1";`; 3028 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_SESSION_ID); }))) { 3029 mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_SESSION_ID); 3030 } 3031 } 3032 3033 3034 3035 3036 static if(!is(typeof(LDAP_CONTROL_X_SESSION_TRACKING))) { 3037 private enum enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING = `enum LDAP_CONTROL_X_SESSION_TRACKING = "1.3.6.1.4.1.21008.108.63.1";`; 3038 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING); }))) { 3039 mixin(enumMixinStr_LDAP_CONTROL_X_SESSION_TRACKING); 3040 } 3041 } 3042 3043 3044 3045 3046 static if(!is(typeof(LDAP_CONTROL_X_EXTENDED_DN))) { 3047 private enum enumMixinStr_LDAP_CONTROL_X_EXTENDED_DN = `enum LDAP_CONTROL_X_EXTENDED_DN = "1.2.840.113556.1.4.529";`; 3048 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_EXTENDED_DN); }))) { 3049 mixin(enumMixinStr_LDAP_CONTROL_X_EXTENDED_DN); 3050 } 3051 } 3052 3053 3054 3055 3056 static if(!is(typeof(LDAP_CONTROL_X_TREE_DELETE))) { 3057 private enum enumMixinStr_LDAP_CONTROL_X_TREE_DELETE = `enum LDAP_CONTROL_X_TREE_DELETE = "1.2.840.113556.1.4.805";`; 3058 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_TREE_DELETE); }))) { 3059 mixin(enumMixinStr_LDAP_CONTROL_X_TREE_DELETE); 3060 } 3061 } 3062 3063 3064 3065 3066 static if(!is(typeof(LDAP_SEARCH_FLAG_PHANTOM_ROOT))) { 3067 private enum enumMixinStr_LDAP_SEARCH_FLAG_PHANTOM_ROOT = `enum LDAP_SEARCH_FLAG_PHANTOM_ROOT = 2;`; 3068 static if(is(typeof({ mixin(enumMixinStr_LDAP_SEARCH_FLAG_PHANTOM_ROOT); }))) { 3069 mixin(enumMixinStr_LDAP_SEARCH_FLAG_PHANTOM_ROOT); 3070 } 3071 } 3072 3073 3074 3075 3076 static if(!is(typeof(LDAP_SEARCH_FLAG_DOMAIN_SCOPE))) { 3077 private enum enumMixinStr_LDAP_SEARCH_FLAG_DOMAIN_SCOPE = `enum LDAP_SEARCH_FLAG_DOMAIN_SCOPE = 1;`; 3078 static if(is(typeof({ mixin(enumMixinStr_LDAP_SEARCH_FLAG_DOMAIN_SCOPE); }))) { 3079 mixin(enumMixinStr_LDAP_SEARCH_FLAG_DOMAIN_SCOPE); 3080 } 3081 } 3082 3083 3084 3085 3086 static if(!is(typeof(LDAP_CONTROL_X_SEARCH_OPTIONS))) { 3087 private enum enumMixinStr_LDAP_CONTROL_X_SEARCH_OPTIONS = `enum LDAP_CONTROL_X_SEARCH_OPTIONS = "1.2.840.113556.1.4.1340";`; 3088 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_SEARCH_OPTIONS); }))) { 3089 mixin(enumMixinStr_LDAP_CONTROL_X_SEARCH_OPTIONS); 3090 } 3091 } 3092 3093 3094 3095 3096 static if(!is(typeof(LDAP_CONTROL_X_PERMISSIVE_MODIFY))) { 3097 private enum enumMixinStr_LDAP_CONTROL_X_PERMISSIVE_MODIFY = `enum LDAP_CONTROL_X_PERMISSIVE_MODIFY = "1.2.840.113556.1.4.1413";`; 3098 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_PERMISSIVE_MODIFY); }))) { 3099 mixin(enumMixinStr_LDAP_CONTROL_X_PERMISSIVE_MODIFY); 3100 } 3101 } 3102 3103 3104 3105 3106 static if(!is(typeof(LDAP_CONTROL_X_DOMAIN_SCOPE))) { 3107 private enum enumMixinStr_LDAP_CONTROL_X_DOMAIN_SCOPE = `enum LDAP_CONTROL_X_DOMAIN_SCOPE = "1.2.840.113556.1.4.1339";`; 3108 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_DOMAIN_SCOPE); }))) { 3109 mixin(enumMixinStr_LDAP_CONTROL_X_DOMAIN_SCOPE); 3110 } 3111 } 3112 3113 3114 3115 3116 static if(!is(typeof(LDAP_CONTROL_X_INCREMENTAL_VALUES))) { 3117 private enum enumMixinStr_LDAP_CONTROL_X_INCREMENTAL_VALUES = `enum LDAP_CONTROL_X_INCREMENTAL_VALUES = "1.2.840.113556.1.4.802";`; 3118 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_INCREMENTAL_VALUES); }))) { 3119 mixin(enumMixinStr_LDAP_CONTROL_X_INCREMENTAL_VALUES); 3120 } 3121 } 3122 3123 3124 3125 3126 static if(!is(typeof(LDAP_REFERRALS_REQUIRED))) { 3127 private enum enumMixinStr_LDAP_REFERRALS_REQUIRED = `enum LDAP_REFERRALS_REQUIRED = 3;`; 3128 static if(is(typeof({ mixin(enumMixinStr_LDAP_REFERRALS_REQUIRED); }))) { 3129 mixin(enumMixinStr_LDAP_REFERRALS_REQUIRED); 3130 } 3131 } 3132 3133 3134 3135 3136 static if(!is(typeof(LDAP_REFERRALS_PREFERRED))) { 3137 private enum enumMixinStr_LDAP_REFERRALS_PREFERRED = `enum LDAP_REFERRALS_PREFERRED = 2;`; 3138 static if(is(typeof({ mixin(enumMixinStr_LDAP_REFERRALS_PREFERRED); }))) { 3139 mixin(enumMixinStr_LDAP_REFERRALS_PREFERRED); 3140 } 3141 } 3142 3143 3144 3145 3146 static if(!is(typeof(LDAP_CHAINING_REQUIRED))) { 3147 private enum enumMixinStr_LDAP_CHAINING_REQUIRED = `enum LDAP_CHAINING_REQUIRED = 1;`; 3148 static if(is(typeof({ mixin(enumMixinStr_LDAP_CHAINING_REQUIRED); }))) { 3149 mixin(enumMixinStr_LDAP_CHAINING_REQUIRED); 3150 } 3151 } 3152 3153 3154 3155 3156 static if(!is(typeof(LDAP_CHAINING_PREFERRED))) { 3157 private enum enumMixinStr_LDAP_CHAINING_PREFERRED = `enum LDAP_CHAINING_PREFERRED = 0;`; 3158 static if(is(typeof({ mixin(enumMixinStr_LDAP_CHAINING_PREFERRED); }))) { 3159 mixin(enumMixinStr_LDAP_CHAINING_PREFERRED); 3160 } 3161 } 3162 3163 3164 3165 3166 static if(!is(typeof(LDAP_CONTROL_X_CHAINING_BEHAVIOR))) { 3167 private enum enumMixinStr_LDAP_CONTROL_X_CHAINING_BEHAVIOR = `enum LDAP_CONTROL_X_CHAINING_BEHAVIOR = "1.3.6.1.4.1.4203.666.11.3";`; 3168 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_CHAINING_BEHAVIOR); }))) { 3169 mixin(enumMixinStr_LDAP_CONTROL_X_CHAINING_BEHAVIOR); 3170 } 3171 } 3172 3173 3174 3175 3176 static if(!is(typeof(LDAP_CONTROL_X_WHATFAILED))) { 3177 private enum enumMixinStr_LDAP_CONTROL_X_WHATFAILED = `enum LDAP_CONTROL_X_WHATFAILED = "1.3.6.1.4.1.4203.666.5.17";`; 3178 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_WHATFAILED); }))) { 3179 mixin(enumMixinStr_LDAP_CONTROL_X_WHATFAILED); 3180 } 3181 } 3182 3183 3184 3185 3186 static if(!is(typeof(LDAP_CONTROL_X_DEREF))) { 3187 private enum enumMixinStr_LDAP_CONTROL_X_DEREF = `enum LDAP_CONTROL_X_DEREF = "1.3.6.1.4.1.4203.666.5.16";`; 3188 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_X_DEREF); }))) { 3189 mixin(enumMixinStr_LDAP_CONTROL_X_DEREF); 3190 } 3191 } 3192 3193 3194 3195 3196 static if(!is(typeof(LDAP_CONTROL_VALSORT))) { 3197 private enum enumMixinStr_LDAP_CONTROL_VALSORT = `enum LDAP_CONTROL_VALSORT = "1.3.6.1.4.1.4203.666.5.14";`; 3198 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_VALSORT); }))) { 3199 mixin(enumMixinStr_LDAP_CONTROL_VALSORT); 3200 } 3201 } 3202 3203 3204 3205 3206 static if(!is(typeof(LDAP_CONTROL_SLURP))) { 3207 private enum enumMixinStr_LDAP_CONTROL_SLURP = `enum LDAP_CONTROL_SLURP = "1.3.6.1.4.1.4203.666.5.13";`; 3208 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_SLURP); }))) { 3209 mixin(enumMixinStr_LDAP_CONTROL_SLURP); 3210 } 3211 } 3212 3213 3214 3215 3216 static if(!is(typeof(LDAP_CONTROL_MANAGEDIT))) { 3217 private enum enumMixinStr_LDAP_CONTROL_MANAGEDIT = `enum LDAP_CONTROL_MANAGEDIT = LDAP_CONTROL_RELAX;`; 3218 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_MANAGEDIT); }))) { 3219 mixin(enumMixinStr_LDAP_CONTROL_MANAGEDIT); 3220 } 3221 } 3222 3223 3224 3225 3226 static if(!is(typeof(LDAP_CONTROL_RELAX))) { 3227 private enum enumMixinStr_LDAP_CONTROL_RELAX = `enum LDAP_CONTROL_RELAX = "1.3.6.1.4.1.4203.666.5.12";`; 3228 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_RELAX); }))) { 3229 mixin(enumMixinStr_LDAP_CONTROL_RELAX); 3230 } 3231 } 3232 3233 3234 3235 3236 static if(!is(typeof(LDAP_CONTROL_NO_SUBORDINATES))) { 3237 private enum enumMixinStr_LDAP_CONTROL_NO_SUBORDINATES = `enum LDAP_CONTROL_NO_SUBORDINATES = "1.3.6.1.4.1.4203.666.5.11";`; 3238 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_NO_SUBORDINATES); }))) { 3239 mixin(enumMixinStr_LDAP_CONTROL_NO_SUBORDINATES); 3240 } 3241 } 3242 3243 3244 3245 3246 static if(!is(typeof(LDAP_CONTROL_NOOP))) { 3247 private enum enumMixinStr_LDAP_CONTROL_NOOP = `enum LDAP_CONTROL_NOOP = "1.3.6.1.4.1.4203.666.5.2";`; 3248 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_NOOP); }))) { 3249 mixin(enumMixinStr_LDAP_CONTROL_NOOP); 3250 } 3251 } 3252 3253 3254 3255 3256 static if(!is(typeof(LDAP_CONTROL_PASSWORDPOLICYRESPONSE))) { 3257 private enum enumMixinStr_LDAP_CONTROL_PASSWORDPOLICYRESPONSE = `enum LDAP_CONTROL_PASSWORDPOLICYRESPONSE = "1.3.6.1.4.1.42.2.27.8.5.1";`; 3258 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PASSWORDPOLICYRESPONSE); }))) { 3259 mixin(enumMixinStr_LDAP_CONTROL_PASSWORDPOLICYRESPONSE); 3260 } 3261 } 3262 3263 3264 3265 3266 static if(!is(typeof(LDAP_CONTROL_PASSWORDPOLICYREQUEST))) { 3267 private enum enumMixinStr_LDAP_CONTROL_PASSWORDPOLICYREQUEST = `enum LDAP_CONTROL_PASSWORDPOLICYREQUEST = "1.3.6.1.4.1.42.2.27.8.5.1";`; 3268 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PASSWORDPOLICYREQUEST); }))) { 3269 mixin(enumMixinStr_LDAP_CONTROL_PASSWORDPOLICYREQUEST); 3270 } 3271 } 3272 3273 3274 3275 3276 static if(!is(typeof(LDAP_CONTROL_DONTUSECOPY))) { 3277 private enum enumMixinStr_LDAP_CONTROL_DONTUSECOPY = `enum LDAP_CONTROL_DONTUSECOPY = "1.3.6.1.1.22";`; 3278 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_DONTUSECOPY); }))) { 3279 mixin(enumMixinStr_LDAP_CONTROL_DONTUSECOPY); 3280 } 3281 } 3282 3283 3284 3285 3286 static if(!is(typeof(LDAP_SYNC_NEW_COOKIE))) { 3287 private enum enumMixinStr_LDAP_SYNC_NEW_COOKIE = `enum LDAP_SYNC_NEW_COOKIE = 4;`; 3288 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_NEW_COOKIE); }))) { 3289 mixin(enumMixinStr_LDAP_SYNC_NEW_COOKIE); 3290 } 3291 } 3292 3293 3294 3295 3296 static if(!is(typeof(LDAP_SYNC_DELETE))) { 3297 private enum enumMixinStr_LDAP_SYNC_DELETE = `enum LDAP_SYNC_DELETE = 3;`; 3298 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_DELETE); }))) { 3299 mixin(enumMixinStr_LDAP_SYNC_DELETE); 3300 } 3301 } 3302 3303 3304 3305 3306 static if(!is(typeof(LDAP_SYNC_MODIFY))) { 3307 private enum enumMixinStr_LDAP_SYNC_MODIFY = `enum LDAP_SYNC_MODIFY = 2;`; 3308 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_MODIFY); }))) { 3309 mixin(enumMixinStr_LDAP_SYNC_MODIFY); 3310 } 3311 } 3312 3313 3314 3315 3316 static if(!is(typeof(LDAP_SYNC_ADD))) { 3317 private enum enumMixinStr_LDAP_SYNC_ADD = `enum LDAP_SYNC_ADD = 1;`; 3318 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_ADD); }))) { 3319 mixin(enumMixinStr_LDAP_SYNC_ADD); 3320 } 3321 } 3322 3323 3324 3325 3326 static if(!is(typeof(LDAP_AVA_NULL))) { 3327 private enum enumMixinStr_LDAP_AVA_NULL = `enum LDAP_AVA_NULL = 0x0000U;`; 3328 static if(is(typeof({ mixin(enumMixinStr_LDAP_AVA_NULL); }))) { 3329 mixin(enumMixinStr_LDAP_AVA_NULL); 3330 } 3331 } 3332 3333 3334 3335 3336 static if(!is(typeof(LDAP_AVA_STRING))) { 3337 private enum enumMixinStr_LDAP_AVA_STRING = `enum LDAP_AVA_STRING = 0x0001U;`; 3338 static if(is(typeof({ mixin(enumMixinStr_LDAP_AVA_STRING); }))) { 3339 mixin(enumMixinStr_LDAP_AVA_STRING); 3340 } 3341 } 3342 3343 3344 3345 3346 static if(!is(typeof(LDAP_AVA_BINARY))) { 3347 private enum enumMixinStr_LDAP_AVA_BINARY = `enum LDAP_AVA_BINARY = 0x0002U;`; 3348 static if(is(typeof({ mixin(enumMixinStr_LDAP_AVA_BINARY); }))) { 3349 mixin(enumMixinStr_LDAP_AVA_BINARY); 3350 } 3351 } 3352 3353 3354 3355 3356 static if(!is(typeof(LDAP_AVA_NONPRINTABLE))) { 3357 private enum enumMixinStr_LDAP_AVA_NONPRINTABLE = `enum LDAP_AVA_NONPRINTABLE = 0x0004U;`; 3358 static if(is(typeof({ mixin(enumMixinStr_LDAP_AVA_NONPRINTABLE); }))) { 3359 mixin(enumMixinStr_LDAP_AVA_NONPRINTABLE); 3360 } 3361 } 3362 3363 3364 3365 3366 static if(!is(typeof(LDAP_AVA_FREE_ATTR))) { 3367 private enum enumMixinStr_LDAP_AVA_FREE_ATTR = `enum LDAP_AVA_FREE_ATTR = 0x0010U;`; 3368 static if(is(typeof({ mixin(enumMixinStr_LDAP_AVA_FREE_ATTR); }))) { 3369 mixin(enumMixinStr_LDAP_AVA_FREE_ATTR); 3370 } 3371 } 3372 3373 3374 3375 3376 static if(!is(typeof(LDAP_AVA_FREE_VALUE))) { 3377 private enum enumMixinStr_LDAP_AVA_FREE_VALUE = `enum LDAP_AVA_FREE_VALUE = 0x0020U;`; 3378 static if(is(typeof({ mixin(enumMixinStr_LDAP_AVA_FREE_VALUE); }))) { 3379 mixin(enumMixinStr_LDAP_AVA_FREE_VALUE); 3380 } 3381 } 3382 3383 3384 3385 3386 static if(!is(typeof(LDAP_SYNC_PRESENT))) { 3387 private enum enumMixinStr_LDAP_SYNC_PRESENT = `enum LDAP_SYNC_PRESENT = 0;`; 3388 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_PRESENT); }))) { 3389 mixin(enumMixinStr_LDAP_SYNC_PRESENT); 3390 } 3391 } 3392 3393 3394 3395 3396 static if(!is(typeof(LDAP_TAG_RELOAD_HINT))) { 3397 private enum enumMixinStr_LDAP_TAG_RELOAD_HINT = `enum LDAP_TAG_RELOAD_HINT = ( cast( ber_tag_t ) 0x01U );`; 3398 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_RELOAD_HINT); }))) { 3399 mixin(enumMixinStr_LDAP_TAG_RELOAD_HINT); 3400 } 3401 } 3402 3403 3404 3405 3406 static if(!is(typeof(LDAP_DN_FORMAT_LDAP))) { 3407 private enum enumMixinStr_LDAP_DN_FORMAT_LDAP = `enum LDAP_DN_FORMAT_LDAP = 0x0000U;`; 3408 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_LDAP); }))) { 3409 mixin(enumMixinStr_LDAP_DN_FORMAT_LDAP); 3410 } 3411 } 3412 3413 3414 3415 3416 static if(!is(typeof(LDAP_DN_FORMAT_LDAPV3))) { 3417 private enum enumMixinStr_LDAP_DN_FORMAT_LDAPV3 = `enum LDAP_DN_FORMAT_LDAPV3 = 0x0010U;`; 3418 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_LDAPV3); }))) { 3419 mixin(enumMixinStr_LDAP_DN_FORMAT_LDAPV3); 3420 } 3421 } 3422 3423 3424 3425 3426 static if(!is(typeof(LDAP_DN_FORMAT_LDAPV2))) { 3427 private enum enumMixinStr_LDAP_DN_FORMAT_LDAPV2 = `enum LDAP_DN_FORMAT_LDAPV2 = 0x0020U;`; 3428 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_LDAPV2); }))) { 3429 mixin(enumMixinStr_LDAP_DN_FORMAT_LDAPV2); 3430 } 3431 } 3432 3433 3434 3435 3436 static if(!is(typeof(LDAP_DN_FORMAT_DCE))) { 3437 private enum enumMixinStr_LDAP_DN_FORMAT_DCE = `enum LDAP_DN_FORMAT_DCE = 0x0030U;`; 3438 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_DCE); }))) { 3439 mixin(enumMixinStr_LDAP_DN_FORMAT_DCE); 3440 } 3441 } 3442 3443 3444 3445 3446 static if(!is(typeof(LDAP_DN_FORMAT_UFN))) { 3447 private enum enumMixinStr_LDAP_DN_FORMAT_UFN = `enum LDAP_DN_FORMAT_UFN = 0x0040U;`; 3448 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_UFN); }))) { 3449 mixin(enumMixinStr_LDAP_DN_FORMAT_UFN); 3450 } 3451 } 3452 3453 3454 3455 3456 static if(!is(typeof(LDAP_DN_FORMAT_AD_CANONICAL))) { 3457 private enum enumMixinStr_LDAP_DN_FORMAT_AD_CANONICAL = `enum LDAP_DN_FORMAT_AD_CANONICAL = 0x0050U;`; 3458 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_AD_CANONICAL); }))) { 3459 mixin(enumMixinStr_LDAP_DN_FORMAT_AD_CANONICAL); 3460 } 3461 } 3462 3463 3464 3465 3466 static if(!is(typeof(LDAP_DN_FORMAT_LBER))) { 3467 private enum enumMixinStr_LDAP_DN_FORMAT_LBER = `enum LDAP_DN_FORMAT_LBER = 0x00F0U;`; 3468 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_LBER); }))) { 3469 mixin(enumMixinStr_LDAP_DN_FORMAT_LBER); 3470 } 3471 } 3472 3473 3474 3475 3476 static if(!is(typeof(LDAP_DN_FORMAT_MASK))) { 3477 private enum enumMixinStr_LDAP_DN_FORMAT_MASK = `enum LDAP_DN_FORMAT_MASK = 0x00F0U;`; 3478 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_FORMAT_MASK); }))) { 3479 mixin(enumMixinStr_LDAP_DN_FORMAT_MASK); 3480 } 3481 } 3482 3483 3484 3485 3486 static if(!is(typeof(LDAP_DN_PRETTY))) { 3487 private enum enumMixinStr_LDAP_DN_PRETTY = `enum LDAP_DN_PRETTY = 0x0100U;`; 3488 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_PRETTY); }))) { 3489 mixin(enumMixinStr_LDAP_DN_PRETTY); 3490 } 3491 } 3492 3493 3494 3495 3496 static if(!is(typeof(LDAP_DN_SKIP))) { 3497 private enum enumMixinStr_LDAP_DN_SKIP = `enum LDAP_DN_SKIP = 0x0200U;`; 3498 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_SKIP); }))) { 3499 mixin(enumMixinStr_LDAP_DN_SKIP); 3500 } 3501 } 3502 3503 3504 3505 3506 static if(!is(typeof(LDAP_DN_P_NOLEADTRAILSPACES))) { 3507 private enum enumMixinStr_LDAP_DN_P_NOLEADTRAILSPACES = `enum LDAP_DN_P_NOLEADTRAILSPACES = 0x1000U;`; 3508 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_P_NOLEADTRAILSPACES); }))) { 3509 mixin(enumMixinStr_LDAP_DN_P_NOLEADTRAILSPACES); 3510 } 3511 } 3512 3513 3514 3515 3516 static if(!is(typeof(LDAP_DN_P_NOSPACEAFTERRDN))) { 3517 private enum enumMixinStr_LDAP_DN_P_NOSPACEAFTERRDN = `enum LDAP_DN_P_NOSPACEAFTERRDN = 0x2000U;`; 3518 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_P_NOSPACEAFTERRDN); }))) { 3519 mixin(enumMixinStr_LDAP_DN_P_NOSPACEAFTERRDN); 3520 } 3521 } 3522 3523 3524 3525 3526 static if(!is(typeof(LDAP_DN_PEDANTIC))) { 3527 private enum enumMixinStr_LDAP_DN_PEDANTIC = `enum LDAP_DN_PEDANTIC = 0xF000U;`; 3528 static if(is(typeof({ mixin(enumMixinStr_LDAP_DN_PEDANTIC); }))) { 3529 mixin(enumMixinStr_LDAP_DN_PEDANTIC); 3530 } 3531 } 3532 3533 3534 3535 3536 static if(!is(typeof(LDAP_TAG_REFRESHDONE))) { 3537 private enum enumMixinStr_LDAP_TAG_REFRESHDONE = `enum LDAP_TAG_REFRESHDONE = ( cast( ber_tag_t ) 0x01U );`; 3538 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_REFRESHDONE); }))) { 3539 mixin(enumMixinStr_LDAP_TAG_REFRESHDONE); 3540 } 3541 } 3542 3543 3544 3545 3546 static if(!is(typeof(LDAP_TAG_REFRESHDELETES))) { 3547 private enum enumMixinStr_LDAP_TAG_REFRESHDELETES = `enum LDAP_TAG_REFRESHDELETES = ( cast( ber_tag_t ) 0x01U );`; 3548 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_REFRESHDELETES); }))) { 3549 mixin(enumMixinStr_LDAP_TAG_REFRESHDELETES); 3550 } 3551 } 3552 3553 3554 3555 3556 static if(!is(typeof(LDAP_TAG_SYNC_COOKIE))) { 3557 private enum enumMixinStr_LDAP_TAG_SYNC_COOKIE = `enum LDAP_TAG_SYNC_COOKIE = ( cast( ber_tag_t ) 0x04U );`; 3558 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_SYNC_COOKIE); }))) { 3559 mixin(enumMixinStr_LDAP_TAG_SYNC_COOKIE); 3560 } 3561 } 3562 3563 3564 3565 3566 static if(!is(typeof(LDAP_TAG_SYNC_ID_SET))) { 3567 private enum enumMixinStr_LDAP_TAG_SYNC_ID_SET = `enum LDAP_TAG_SYNC_ID_SET = ( cast( ber_tag_t ) 0xa3U );`; 3568 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_SYNC_ID_SET); }))) { 3569 mixin(enumMixinStr_LDAP_TAG_SYNC_ID_SET); 3570 } 3571 } 3572 3573 3574 3575 3576 static if(!is(typeof(LDAP_TAG_SYNC_REFRESH_PRESENT))) { 3577 private enum enumMixinStr_LDAP_TAG_SYNC_REFRESH_PRESENT = `enum LDAP_TAG_SYNC_REFRESH_PRESENT = ( cast( ber_tag_t ) 0xa2U );`; 3578 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_SYNC_REFRESH_PRESENT); }))) { 3579 mixin(enumMixinStr_LDAP_TAG_SYNC_REFRESH_PRESENT); 3580 } 3581 } 3582 3583 3584 3585 3586 static if(!is(typeof(LDAP_TAG_SYNC_REFRESH_DELETE))) { 3587 private enum enumMixinStr_LDAP_TAG_SYNC_REFRESH_DELETE = `enum LDAP_TAG_SYNC_REFRESH_DELETE = ( cast( ber_tag_t ) 0xa1U );`; 3588 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_SYNC_REFRESH_DELETE); }))) { 3589 mixin(enumMixinStr_LDAP_TAG_SYNC_REFRESH_DELETE); 3590 } 3591 } 3592 3593 3594 3595 3596 static if(!is(typeof(LDAP_TAG_SYNC_NEW_COOKIE))) { 3597 private enum enumMixinStr_LDAP_TAG_SYNC_NEW_COOKIE = `enum LDAP_TAG_SYNC_NEW_COOKIE = ( cast( ber_tag_t ) 0x80U );`; 3598 static if(is(typeof({ mixin(enumMixinStr_LDAP_TAG_SYNC_NEW_COOKIE); }))) { 3599 mixin(enumMixinStr_LDAP_TAG_SYNC_NEW_COOKIE); 3600 } 3601 } 3602 3603 3604 3605 3606 static if(!is(typeof(LDAP_SYNC_REFRESH_DELETES))) { 3607 private enum enumMixinStr_LDAP_SYNC_REFRESH_DELETES = `enum LDAP_SYNC_REFRESH_DELETES = 1;`; 3608 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_REFRESH_DELETES); }))) { 3609 mixin(enumMixinStr_LDAP_SYNC_REFRESH_DELETES); 3610 } 3611 } 3612 3613 3614 3615 3616 static if(!is(typeof(LDAP_SYNC_REFRESH_PRESENTS))) { 3617 private enum enumMixinStr_LDAP_SYNC_REFRESH_PRESENTS = `enum LDAP_SYNC_REFRESH_PRESENTS = 0;`; 3618 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_REFRESH_PRESENTS); }))) { 3619 mixin(enumMixinStr_LDAP_SYNC_REFRESH_PRESENTS); 3620 } 3621 } 3622 3623 3624 3625 3626 static if(!is(typeof(LDAP_SYNC_REFRESH_AND_PERSIST))) { 3627 private enum enumMixinStr_LDAP_SYNC_REFRESH_AND_PERSIST = `enum LDAP_SYNC_REFRESH_AND_PERSIST = 0x03;`; 3628 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_REFRESH_AND_PERSIST); }))) { 3629 mixin(enumMixinStr_LDAP_SYNC_REFRESH_AND_PERSIST); 3630 } 3631 } 3632 3633 3634 3635 3636 static if(!is(typeof(LDAP_SYNC_RESERVED))) { 3637 private enum enumMixinStr_LDAP_SYNC_RESERVED = `enum LDAP_SYNC_RESERVED = 0x02;`; 3638 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_RESERVED); }))) { 3639 mixin(enumMixinStr_LDAP_SYNC_RESERVED); 3640 } 3641 } 3642 3643 3644 3645 3646 static if(!is(typeof(LDAP_SYNC_REFRESH_ONLY))) { 3647 private enum enumMixinStr_LDAP_SYNC_REFRESH_ONLY = `enum LDAP_SYNC_REFRESH_ONLY = 0x01;`; 3648 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_REFRESH_ONLY); }))) { 3649 mixin(enumMixinStr_LDAP_SYNC_REFRESH_ONLY); 3650 } 3651 } 3652 3653 3654 3655 3656 static if(!is(typeof(LDAP_SYNC_NONE))) { 3657 private enum enumMixinStr_LDAP_SYNC_NONE = `enum LDAP_SYNC_NONE = 0x00;`; 3658 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_NONE); }))) { 3659 mixin(enumMixinStr_LDAP_SYNC_NONE); 3660 } 3661 } 3662 3663 3664 3665 3666 static if(!is(typeof(LDAP_SYNC_INFO))) { 3667 private enum enumMixinStr_LDAP_SYNC_INFO = `enum LDAP_SYNC_INFO = LDAP_SYNC_OID ".4";`; 3668 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_INFO); }))) { 3669 mixin(enumMixinStr_LDAP_SYNC_INFO); 3670 } 3671 } 3672 3673 3674 3675 3676 static if(!is(typeof(LDAP_CONTROL_SYNC_DONE))) { 3677 private enum enumMixinStr_LDAP_CONTROL_SYNC_DONE = `enum LDAP_CONTROL_SYNC_DONE = LDAP_SYNC_OID ".3";`; 3678 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_SYNC_DONE); }))) { 3679 mixin(enumMixinStr_LDAP_CONTROL_SYNC_DONE); 3680 } 3681 } 3682 3683 3684 3685 3686 static if(!is(typeof(LDAP_CONTROL_SYNC_STATE))) { 3687 private enum enumMixinStr_LDAP_CONTROL_SYNC_STATE = `enum LDAP_CONTROL_SYNC_STATE = LDAP_SYNC_OID ".2";`; 3688 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_SYNC_STATE); }))) { 3689 mixin(enumMixinStr_LDAP_CONTROL_SYNC_STATE); 3690 } 3691 } 3692 3693 3694 3695 3696 static if(!is(typeof(LDAP_CONTROL_SYNC))) { 3697 private enum enumMixinStr_LDAP_CONTROL_SYNC = `enum LDAP_CONTROL_SYNC = LDAP_SYNC_OID ".1";`; 3698 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_SYNC); }))) { 3699 mixin(enumMixinStr_LDAP_CONTROL_SYNC); 3700 } 3701 } 3702 3703 3704 3705 3706 static if(!is(typeof(LDAP_SYNC_OID))) { 3707 private enum enumMixinStr_LDAP_SYNC_OID = `enum LDAP_SYNC_OID = "1.3.6.1.4.1.4203.1.9.1";`; 3708 static if(is(typeof({ mixin(enumMixinStr_LDAP_SYNC_OID); }))) { 3709 mixin(enumMixinStr_LDAP_SYNC_OID); 3710 } 3711 } 3712 3713 3714 3715 3716 static if(!is(typeof(LDAP_CONTROL_PAGEDRESULTS))) { 3717 private enum enumMixinStr_LDAP_CONTROL_PAGEDRESULTS = `enum LDAP_CONTROL_PAGEDRESULTS = "1.2.840.113556.1.4.319";`; 3718 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PAGEDRESULTS); }))) { 3719 mixin(enumMixinStr_LDAP_CONTROL_PAGEDRESULTS); 3720 } 3721 } 3722 3723 3724 3725 3726 static if(!is(typeof(LDAP_CONTROL_SORTRESPONSE))) { 3727 private enum enumMixinStr_LDAP_CONTROL_SORTRESPONSE = `enum LDAP_CONTROL_SORTRESPONSE = "1.2.840.113556.1.4.474";`; 3728 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_SORTRESPONSE); }))) { 3729 mixin(enumMixinStr_LDAP_CONTROL_SORTRESPONSE); 3730 } 3731 } 3732 3733 3734 3735 3736 static if(!is(typeof(LDAP_CONTROL_SORTREQUEST))) { 3737 private enum enumMixinStr_LDAP_CONTROL_SORTREQUEST = `enum LDAP_CONTROL_SORTREQUEST = "1.2.840.113556.1.4.473";`; 3738 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_SORTREQUEST); }))) { 3739 mixin(enumMixinStr_LDAP_CONTROL_SORTREQUEST); 3740 } 3741 } 3742 3743 3744 3745 3746 static if(!is(typeof(LDAP_CONTROL_POST_READ))) { 3747 private enum enumMixinStr_LDAP_CONTROL_POST_READ = `enum LDAP_CONTROL_POST_READ = "1.3.6.1.1.13.2";`; 3748 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_POST_READ); }))) { 3749 mixin(enumMixinStr_LDAP_CONTROL_POST_READ); 3750 } 3751 } 3752 3753 3754 3755 3756 static if(!is(typeof(LDAP_CONTROL_PRE_READ))) { 3757 private enum enumMixinStr_LDAP_CONTROL_PRE_READ = `enum LDAP_CONTROL_PRE_READ = "1.3.6.1.1.13.1";`; 3758 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PRE_READ); }))) { 3759 mixin(enumMixinStr_LDAP_CONTROL_PRE_READ); 3760 } 3761 } 3762 3763 3764 3765 3766 static if(!is(typeof(LDAP_CONTROL_ASSERT))) { 3767 private enum enumMixinStr_LDAP_CONTROL_ASSERT = `enum LDAP_CONTROL_ASSERT = "1.3.6.1.1.12";`; 3768 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_ASSERT); }))) { 3769 mixin(enumMixinStr_LDAP_CONTROL_ASSERT); 3770 } 3771 } 3772 3773 3774 3775 3776 static if(!is(typeof(LDAP_CONTROL_VALUESRETURNFILTER))) { 3777 private enum enumMixinStr_LDAP_CONTROL_VALUESRETURNFILTER = `enum LDAP_CONTROL_VALUESRETURNFILTER = "1.2.826.0.1.3344810.2.3";`; 3778 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_VALUESRETURNFILTER); }))) { 3779 mixin(enumMixinStr_LDAP_CONTROL_VALUESRETURNFILTER); 3780 } 3781 } 3782 3783 3784 3785 3786 static if(!is(typeof(LDAP_CONTROL_SUBENTRIES))) { 3787 private enum enumMixinStr_LDAP_CONTROL_SUBENTRIES = `enum LDAP_CONTROL_SUBENTRIES = "1.3.6.1.4.1.4203.1.10.1";`; 3788 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_SUBENTRIES); }))) { 3789 mixin(enumMixinStr_LDAP_CONTROL_SUBENTRIES); 3790 } 3791 } 3792 3793 3794 3795 3796 static if(!is(typeof(LDAP_CONTROL_PROXY_AUTHZ))) { 3797 private enum enumMixinStr_LDAP_CONTROL_PROXY_AUTHZ = `enum LDAP_CONTROL_PROXY_AUTHZ = "2.16.840.1.113730.3.4.18";`; 3798 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_PROXY_AUTHZ); }))) { 3799 mixin(enumMixinStr_LDAP_CONTROL_PROXY_AUTHZ); 3800 } 3801 } 3802 3803 3804 3805 3806 static if(!is(typeof(LDAP_CONTROL_MANAGEDSAIT))) { 3807 private enum enumMixinStr_LDAP_CONTROL_MANAGEDSAIT = `enum LDAP_CONTROL_MANAGEDSAIT = "2.16.840.1.113730.3.4.2";`; 3808 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONTROL_MANAGEDSAIT); }))) { 3809 mixin(enumMixinStr_LDAP_CONTROL_MANAGEDSAIT); 3810 } 3811 } 3812 3813 3814 3815 3816 static if(!is(typeof(LDAP_FEATURE_INFO_VERSION))) { 3817 private enum enumMixinStr_LDAP_FEATURE_INFO_VERSION = `enum LDAP_FEATURE_INFO_VERSION = ( 1 );`; 3818 static if(is(typeof({ mixin(enumMixinStr_LDAP_FEATURE_INFO_VERSION); }))) { 3819 mixin(enumMixinStr_LDAP_FEATURE_INFO_VERSION); 3820 } 3821 } 3822 3823 3824 3825 3826 static if(!is(typeof(LDAP_API_INFO_VERSION))) { 3827 private enum enumMixinStr_LDAP_API_INFO_VERSION = `enum LDAP_API_INFO_VERSION = ( 1 );`; 3828 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_INFO_VERSION); }))) { 3829 mixin(enumMixinStr_LDAP_API_INFO_VERSION); 3830 } 3831 } 3832 3833 3834 3835 3836 static if(!is(typeof(LDAP_OPT_OFF))) { 3837 private enum enumMixinStr_LDAP_OPT_OFF = `enum LDAP_OPT_OFF = ( cast( void * ) 0 );`; 3838 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_OFF); }))) { 3839 mixin(enumMixinStr_LDAP_OPT_OFF); 3840 } 3841 } 3842 3843 3844 3845 3846 static if(!is(typeof(LDAP_OPT_ON))) { 3847 private enum enumMixinStr_LDAP_OPT_ON = `enum LDAP_OPT_ON = ( cast( void * ) & ber_pvt_opt_on );`; 3848 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_ON); }))) { 3849 mixin(enumMixinStr_LDAP_OPT_ON); 3850 } 3851 } 3852 3853 3854 3855 3856 static if(!is(typeof(LDAP_OPT_ERROR))) { 3857 private enum enumMixinStr_LDAP_OPT_ERROR = `enum LDAP_OPT_ERROR = ( - 1 );`; 3858 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_ERROR); }))) { 3859 mixin(enumMixinStr_LDAP_OPT_ERROR); 3860 } 3861 } 3862 3863 3864 3865 3866 static if(!is(typeof(LDAP_OPT_SUCCESS))) { 3867 private enum enumMixinStr_LDAP_OPT_SUCCESS = `enum LDAP_OPT_SUCCESS = 0;`; 3868 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SUCCESS); }))) { 3869 mixin(enumMixinStr_LDAP_OPT_SUCCESS); 3870 } 3871 } 3872 3873 3874 3875 3876 static if(!is(typeof(LDAP_OPT_PRIVATE_EXTENSION_BASE))) { 3877 private enum enumMixinStr_LDAP_OPT_PRIVATE_EXTENSION_BASE = `enum LDAP_OPT_PRIVATE_EXTENSION_BASE = 0x7000;`; 3878 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_PRIVATE_EXTENSION_BASE); }))) { 3879 mixin(enumMixinStr_LDAP_OPT_PRIVATE_EXTENSION_BASE); 3880 } 3881 } 3882 3883 3884 3885 3886 static if(!is(typeof(LDAP_OPT_X_KEEPALIVE_INTERVAL))) { 3887 private enum enumMixinStr_LDAP_OPT_X_KEEPALIVE_INTERVAL = `enum LDAP_OPT_X_KEEPALIVE_INTERVAL = 0x6302;`; 3888 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_KEEPALIVE_INTERVAL); }))) { 3889 mixin(enumMixinStr_LDAP_OPT_X_KEEPALIVE_INTERVAL); 3890 } 3891 } 3892 3893 3894 3895 3896 static if(!is(typeof(LDAP_OPT_X_KEEPALIVE_PROBES))) { 3897 private enum enumMixinStr_LDAP_OPT_X_KEEPALIVE_PROBES = `enum LDAP_OPT_X_KEEPALIVE_PROBES = 0x6301;`; 3898 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_KEEPALIVE_PROBES); }))) { 3899 mixin(enumMixinStr_LDAP_OPT_X_KEEPALIVE_PROBES); 3900 } 3901 } 3902 3903 3904 3905 3906 static if(!is(typeof(LDAP_OPT_X_KEEPALIVE_IDLE))) { 3907 private enum enumMixinStr_LDAP_OPT_X_KEEPALIVE_IDLE = `enum LDAP_OPT_X_KEEPALIVE_IDLE = 0x6300;`; 3908 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_KEEPALIVE_IDLE); }))) { 3909 mixin(enumMixinStr_LDAP_OPT_X_KEEPALIVE_IDLE); 3910 } 3911 } 3912 3913 3914 3915 3916 static if(!is(typeof(LDAP_OPT_X_GSSAPI_ALLOW_REMOTE_PRINCIPAL))) { 3917 private enum enumMixinStr_LDAP_OPT_X_GSSAPI_ALLOW_REMOTE_PRINCIPAL = `enum LDAP_OPT_X_GSSAPI_ALLOW_REMOTE_PRINCIPAL = 0x6201;`; 3918 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_GSSAPI_ALLOW_REMOTE_PRINCIPAL); }))) { 3919 mixin(enumMixinStr_LDAP_OPT_X_GSSAPI_ALLOW_REMOTE_PRINCIPAL); 3920 } 3921 } 3922 3923 3924 3925 3926 static if(!is(typeof(LDAP_OPT_X_GSSAPI_DO_NOT_FREE_CONTEXT))) { 3927 private enum enumMixinStr_LDAP_OPT_X_GSSAPI_DO_NOT_FREE_CONTEXT = `enum LDAP_OPT_X_GSSAPI_DO_NOT_FREE_CONTEXT = 0x6200;`; 3928 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_GSSAPI_DO_NOT_FREE_CONTEXT); }))) { 3929 mixin(enumMixinStr_LDAP_OPT_X_GSSAPI_DO_NOT_FREE_CONTEXT); 3930 } 3931 } 3932 3933 3934 3935 3936 static if(!is(typeof(LDAP_OPT_X_SASL_GSS_CREDS))) { 3937 private enum enumMixinStr_LDAP_OPT_X_SASL_GSS_CREDS = `enum LDAP_OPT_X_SASL_GSS_CREDS = 0x610d;`; 3938 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_GSS_CREDS); }))) { 3939 mixin(enumMixinStr_LDAP_OPT_X_SASL_GSS_CREDS); 3940 } 3941 } 3942 3943 3944 3945 3946 static if(!is(typeof(LDAP_OPT_X_SASL_USERNAME))) { 3947 private enum enumMixinStr_LDAP_OPT_X_SASL_USERNAME = `enum LDAP_OPT_X_SASL_USERNAME = 0x610c;`; 3948 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_USERNAME); }))) { 3949 mixin(enumMixinStr_LDAP_OPT_X_SASL_USERNAME); 3950 } 3951 } 3952 3953 3954 3955 3956 static if(!is(typeof(LDAP_OPT_X_SASL_NOCANON))) { 3957 private enum enumMixinStr_LDAP_OPT_X_SASL_NOCANON = `enum LDAP_OPT_X_SASL_NOCANON = 0x610b;`; 3958 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_NOCANON); }))) { 3959 mixin(enumMixinStr_LDAP_OPT_X_SASL_NOCANON); 3960 } 3961 } 3962 3963 3964 3965 3966 static if(!is(typeof(LDAP_OPT_X_SASL_MECHLIST))) { 3967 private enum enumMixinStr_LDAP_OPT_X_SASL_MECHLIST = `enum LDAP_OPT_X_SASL_MECHLIST = 0x610a;`; 3968 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_MECHLIST); }))) { 3969 mixin(enumMixinStr_LDAP_OPT_X_SASL_MECHLIST); 3970 } 3971 } 3972 3973 3974 3975 3976 static if(!is(typeof(LDAP_OPT_X_SASL_MAXBUFSIZE))) { 3977 private enum enumMixinStr_LDAP_OPT_X_SASL_MAXBUFSIZE = `enum LDAP_OPT_X_SASL_MAXBUFSIZE = 0x6109;`; 3978 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_MAXBUFSIZE); }))) { 3979 mixin(enumMixinStr_LDAP_OPT_X_SASL_MAXBUFSIZE); 3980 } 3981 } 3982 3983 3984 3985 3986 static if(!is(typeof(LDAP_OPT_X_SASL_SSF_MAX))) { 3987 private enum enumMixinStr_LDAP_OPT_X_SASL_SSF_MAX = `enum LDAP_OPT_X_SASL_SSF_MAX = 0x6108;`; 3988 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF_MAX); }))) { 3989 mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF_MAX); 3990 } 3991 } 3992 3993 3994 3995 3996 static if(!is(typeof(LDAP_OPT_X_SASL_SSF_MIN))) { 3997 private enum enumMixinStr_LDAP_OPT_X_SASL_SSF_MIN = `enum LDAP_OPT_X_SASL_SSF_MIN = 0x6107;`; 3998 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF_MIN); }))) { 3999 mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF_MIN); 4000 } 4001 } 4002 4003 4004 4005 4006 static if(!is(typeof(LDAP_OPT_X_SASL_SECPROPS))) { 4007 private enum enumMixinStr_LDAP_OPT_X_SASL_SECPROPS = `enum LDAP_OPT_X_SASL_SECPROPS = 0x6106;`; 4008 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_SECPROPS); }))) { 4009 mixin(enumMixinStr_LDAP_OPT_X_SASL_SECPROPS); 4010 } 4011 } 4012 4013 4014 4015 4016 static if(!is(typeof(LDAP_OPT_X_SASL_SSF_EXTERNAL))) { 4017 private enum enumMixinStr_LDAP_OPT_X_SASL_SSF_EXTERNAL = `enum LDAP_OPT_X_SASL_SSF_EXTERNAL = 0x6105;`; 4018 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF_EXTERNAL); }))) { 4019 mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF_EXTERNAL); 4020 } 4021 } 4022 4023 4024 4025 4026 static if(!is(typeof(LDAP_OPT_X_SASL_SSF))) { 4027 private enum enumMixinStr_LDAP_OPT_X_SASL_SSF = `enum LDAP_OPT_X_SASL_SSF = 0x6104;`; 4028 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF); }))) { 4029 mixin(enumMixinStr_LDAP_OPT_X_SASL_SSF); 4030 } 4031 } 4032 4033 4034 4035 4036 static if(!is(typeof(LDAP_OPT_X_SASL_AUTHZID))) { 4037 private enum enumMixinStr_LDAP_OPT_X_SASL_AUTHZID = `enum LDAP_OPT_X_SASL_AUTHZID = 0x6103;`; 4038 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_AUTHZID); }))) { 4039 mixin(enumMixinStr_LDAP_OPT_X_SASL_AUTHZID); 4040 } 4041 } 4042 4043 4044 4045 4046 static if(!is(typeof(LDAP_OPT_X_SASL_AUTHCID))) { 4047 private enum enumMixinStr_LDAP_OPT_X_SASL_AUTHCID = `enum LDAP_OPT_X_SASL_AUTHCID = 0x6102;`; 4048 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_AUTHCID); }))) { 4049 mixin(enumMixinStr_LDAP_OPT_X_SASL_AUTHCID); 4050 } 4051 } 4052 4053 4054 4055 4056 static if(!is(typeof(LDAP_OPT_X_SASL_REALM))) { 4057 private enum enumMixinStr_LDAP_OPT_X_SASL_REALM = `enum LDAP_OPT_X_SASL_REALM = 0x6101;`; 4058 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_REALM); }))) { 4059 mixin(enumMixinStr_LDAP_OPT_X_SASL_REALM); 4060 } 4061 } 4062 4063 4064 4065 4066 static if(!is(typeof(LDAP_OPT_X_SASL_MECH))) { 4067 private enum enumMixinStr_LDAP_OPT_X_SASL_MECH = `enum LDAP_OPT_X_SASL_MECH = 0x6100;`; 4068 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_SASL_MECH); }))) { 4069 mixin(enumMixinStr_LDAP_OPT_X_SASL_MECH); 4070 } 4071 } 4072 4073 4074 4075 4076 static if(!is(typeof(LDAP_OPT_X_TLS_PROTOCOL_TLS1_2))) { 4077 private enum enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_2 = `enum LDAP_OPT_X_TLS_PROTOCOL_TLS1_2 = ( ( 3 << 8 ) + 3 );`; 4078 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_2); }))) { 4079 mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_2); 4080 } 4081 } 4082 4083 4084 4085 4086 static if(!is(typeof(LDAP_OPT_X_TLS_PROTOCOL_TLS1_1))) { 4087 private enum enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_1 = `enum LDAP_OPT_X_TLS_PROTOCOL_TLS1_1 = ( ( 3 << 8 ) + 2 );`; 4088 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_1); }))) { 4089 mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_1); 4090 } 4091 } 4092 4093 4094 4095 4096 static if(!is(typeof(LDAP_OPT_X_TLS_PROTOCOL_TLS1_0))) { 4097 private enum enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_0 = `enum LDAP_OPT_X_TLS_PROTOCOL_TLS1_0 = ( ( 3 << 8 ) + 1 );`; 4098 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_0); }))) { 4099 mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_TLS1_0); 4100 } 4101 } 4102 4103 4104 4105 4106 static if(!is(typeof(LDAP_OPT_X_TLS_PROTOCOL_SSL3))) { 4107 private enum enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_SSL3 = `enum LDAP_OPT_X_TLS_PROTOCOL_SSL3 = ( 3 << 8 );`; 4108 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_SSL3); }))) { 4109 mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_SSL3); 4110 } 4111 } 4112 4113 4114 4115 4116 static if(!is(typeof(LDAP_OPT_X_TLS_PROTOCOL_SSL2))) { 4117 private enum enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_SSL2 = `enum LDAP_OPT_X_TLS_PROTOCOL_SSL2 = ( 2 << 8 );`; 4118 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_SSL2); }))) { 4119 mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_SSL2); 4120 } 4121 } 4122 4123 4124 4125 4126 4127 4128 static if(!is(typeof(LDAP_OPT_X_TLS_CRL_ALL))) { 4129 private enum enumMixinStr_LDAP_OPT_X_TLS_CRL_ALL = `enum LDAP_OPT_X_TLS_CRL_ALL = 2;`; 4130 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CRL_ALL); }))) { 4131 mixin(enumMixinStr_LDAP_OPT_X_TLS_CRL_ALL); 4132 } 4133 } 4134 4135 4136 4137 4138 static if(!is(typeof(LDAP_OPT_X_TLS_CRL_PEER))) { 4139 private enum enumMixinStr_LDAP_OPT_X_TLS_CRL_PEER = `enum LDAP_OPT_X_TLS_CRL_PEER = 1;`; 4140 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CRL_PEER); }))) { 4141 mixin(enumMixinStr_LDAP_OPT_X_TLS_CRL_PEER); 4142 } 4143 } 4144 4145 4146 4147 4148 static if(!is(typeof(LDAP_OPT_X_TLS_CRL_NONE))) { 4149 private enum enumMixinStr_LDAP_OPT_X_TLS_CRL_NONE = `enum LDAP_OPT_X_TLS_CRL_NONE = 0;`; 4150 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CRL_NONE); }))) { 4151 mixin(enumMixinStr_LDAP_OPT_X_TLS_CRL_NONE); 4152 } 4153 } 4154 4155 4156 4157 4158 static if(!is(typeof(LDAP_OPT_X_TLS_TRY))) { 4159 private enum enumMixinStr_LDAP_OPT_X_TLS_TRY = `enum LDAP_OPT_X_TLS_TRY = 4;`; 4160 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_TRY); }))) { 4161 mixin(enumMixinStr_LDAP_OPT_X_TLS_TRY); 4162 } 4163 } 4164 4165 4166 4167 4168 static if(!is(typeof(LDAP_OPT_X_TLS_ALLOW))) { 4169 private enum enumMixinStr_LDAP_OPT_X_TLS_ALLOW = `enum LDAP_OPT_X_TLS_ALLOW = 3;`; 4170 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_ALLOW); }))) { 4171 mixin(enumMixinStr_LDAP_OPT_X_TLS_ALLOW); 4172 } 4173 } 4174 4175 4176 4177 4178 static if(!is(typeof(LDAP_OPT_X_TLS_DEMAND))) { 4179 private enum enumMixinStr_LDAP_OPT_X_TLS_DEMAND = `enum LDAP_OPT_X_TLS_DEMAND = 2;`; 4180 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_DEMAND); }))) { 4181 mixin(enumMixinStr_LDAP_OPT_X_TLS_DEMAND); 4182 } 4183 } 4184 4185 4186 4187 4188 static if(!is(typeof(LDAP_OPT_X_TLS_HARD))) { 4189 private enum enumMixinStr_LDAP_OPT_X_TLS_HARD = `enum LDAP_OPT_X_TLS_HARD = 1;`; 4190 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_HARD); }))) { 4191 mixin(enumMixinStr_LDAP_OPT_X_TLS_HARD); 4192 } 4193 } 4194 4195 4196 4197 4198 static if(!is(typeof(LDAP_OPT_X_TLS_NEVER))) { 4199 private enum enumMixinStr_LDAP_OPT_X_TLS_NEVER = `enum LDAP_OPT_X_TLS_NEVER = 0;`; 4200 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_NEVER); }))) { 4201 mixin(enumMixinStr_LDAP_OPT_X_TLS_NEVER); 4202 } 4203 } 4204 4205 4206 4207 4208 static if(!is(typeof(LDAP_OPT_X_TLS_ECNAME))) { 4209 private enum enumMixinStr_LDAP_OPT_X_TLS_ECNAME = `enum LDAP_OPT_X_TLS_ECNAME = 0x6012;`; 4210 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_ECNAME); }))) { 4211 mixin(enumMixinStr_LDAP_OPT_X_TLS_ECNAME); 4212 } 4213 } 4214 4215 4216 4217 4218 static if(!is(typeof(LDAP_OPT_X_TLS_PACKAGE))) { 4219 private enum enumMixinStr_LDAP_OPT_X_TLS_PACKAGE = `enum LDAP_OPT_X_TLS_PACKAGE = 0x6011;`; 4220 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_PACKAGE); }))) { 4221 mixin(enumMixinStr_LDAP_OPT_X_TLS_PACKAGE); 4222 } 4223 } 4224 4225 4226 4227 4228 static if(!is(typeof(LDAP_OPT_X_TLS_CRLFILE))) { 4229 private enum enumMixinStr_LDAP_OPT_X_TLS_CRLFILE = `enum LDAP_OPT_X_TLS_CRLFILE = 0x6010;`; 4230 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CRLFILE); }))) { 4231 mixin(enumMixinStr_LDAP_OPT_X_TLS_CRLFILE); 4232 } 4233 } 4234 4235 4236 4237 4238 static if(!is(typeof(LDAP_OPT_X_TLS_NEWCTX))) { 4239 private enum enumMixinStr_LDAP_OPT_X_TLS_NEWCTX = `enum LDAP_OPT_X_TLS_NEWCTX = 0x600f;`; 4240 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_NEWCTX); }))) { 4241 mixin(enumMixinStr_LDAP_OPT_X_TLS_NEWCTX); 4242 } 4243 } 4244 4245 4246 4247 4248 static if(!is(typeof(LDAP_OPT_X_TLS_DHFILE))) { 4249 private enum enumMixinStr_LDAP_OPT_X_TLS_DHFILE = `enum LDAP_OPT_X_TLS_DHFILE = 0x600e;`; 4250 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_DHFILE); }))) { 4251 mixin(enumMixinStr_LDAP_OPT_X_TLS_DHFILE); 4252 } 4253 } 4254 4255 4256 4257 4258 static if(!is(typeof(LDAP_OPT_X_TLS_CONNECT_ARG))) { 4259 private enum enumMixinStr_LDAP_OPT_X_TLS_CONNECT_ARG = `enum LDAP_OPT_X_TLS_CONNECT_ARG = 0x600d;`; 4260 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CONNECT_ARG); }))) { 4261 mixin(enumMixinStr_LDAP_OPT_X_TLS_CONNECT_ARG); 4262 } 4263 } 4264 4265 4266 4267 4268 static if(!is(typeof(LDAP_OPT_X_TLS_CONNECT_CB))) { 4269 private enum enumMixinStr_LDAP_OPT_X_TLS_CONNECT_CB = `enum LDAP_OPT_X_TLS_CONNECT_CB = 0x600c;`; 4270 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CONNECT_CB); }))) { 4271 mixin(enumMixinStr_LDAP_OPT_X_TLS_CONNECT_CB); 4272 } 4273 } 4274 4275 4276 4277 4278 static if(!is(typeof(LDAP_OPT_X_TLS_CRLCHECK))) { 4279 private enum enumMixinStr_LDAP_OPT_X_TLS_CRLCHECK = `enum LDAP_OPT_X_TLS_CRLCHECK = 0x600b;`; 4280 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CRLCHECK); }))) { 4281 mixin(enumMixinStr_LDAP_OPT_X_TLS_CRLCHECK); 4282 } 4283 } 4284 4285 4286 4287 4288 static if(!is(typeof(LDAP_OPT_X_TLS_SSL_CTX))) { 4289 private enum enumMixinStr_LDAP_OPT_X_TLS_SSL_CTX = `enum LDAP_OPT_X_TLS_SSL_CTX = 0x600a;`; 4290 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_SSL_CTX); }))) { 4291 mixin(enumMixinStr_LDAP_OPT_X_TLS_SSL_CTX); 4292 } 4293 } 4294 4295 4296 4297 4298 static if(!is(typeof(LDAP_OPT_X_TLS_RANDOM_FILE))) { 4299 private enum enumMixinStr_LDAP_OPT_X_TLS_RANDOM_FILE = `enum LDAP_OPT_X_TLS_RANDOM_FILE = 0x6009;`; 4300 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_RANDOM_FILE); }))) { 4301 mixin(enumMixinStr_LDAP_OPT_X_TLS_RANDOM_FILE); 4302 } 4303 } 4304 4305 4306 4307 4308 static if(!is(typeof(LDAP_OPT_X_TLS_CIPHER_SUITE))) { 4309 private enum enumMixinStr_LDAP_OPT_X_TLS_CIPHER_SUITE = `enum LDAP_OPT_X_TLS_CIPHER_SUITE = 0x6008;`; 4310 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CIPHER_SUITE); }))) { 4311 mixin(enumMixinStr_LDAP_OPT_X_TLS_CIPHER_SUITE); 4312 } 4313 } 4314 4315 4316 4317 4318 static if(!is(typeof(LDAP_OPT_X_TLS_PROTOCOL_MIN))) { 4319 private enum enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_MIN = `enum LDAP_OPT_X_TLS_PROTOCOL_MIN = 0x6007;`; 4320 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_MIN); }))) { 4321 mixin(enumMixinStr_LDAP_OPT_X_TLS_PROTOCOL_MIN); 4322 } 4323 } 4324 4325 4326 4327 4328 static if(!is(typeof(LDAP_OPT_X_TLS_REQUIRE_CERT))) { 4329 private enum enumMixinStr_LDAP_OPT_X_TLS_REQUIRE_CERT = `enum LDAP_OPT_X_TLS_REQUIRE_CERT = 0x6006;`; 4330 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_REQUIRE_CERT); }))) { 4331 mixin(enumMixinStr_LDAP_OPT_X_TLS_REQUIRE_CERT); 4332 } 4333 } 4334 4335 4336 4337 4338 static if(!is(typeof(LDAP_OPT_X_TLS_KEYFILE))) { 4339 private enum enumMixinStr_LDAP_OPT_X_TLS_KEYFILE = `enum LDAP_OPT_X_TLS_KEYFILE = 0x6005;`; 4340 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_KEYFILE); }))) { 4341 mixin(enumMixinStr_LDAP_OPT_X_TLS_KEYFILE); 4342 } 4343 } 4344 4345 4346 4347 4348 static if(!is(typeof(LDAP_OPT_X_TLS_CERTFILE))) { 4349 private enum enumMixinStr_LDAP_OPT_X_TLS_CERTFILE = `enum LDAP_OPT_X_TLS_CERTFILE = 0x6004;`; 4350 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CERTFILE); }))) { 4351 mixin(enumMixinStr_LDAP_OPT_X_TLS_CERTFILE); 4352 } 4353 } 4354 4355 4356 4357 4358 static if(!is(typeof(LDAP_OPT_X_TLS_CACERTDIR))) { 4359 private enum enumMixinStr_LDAP_OPT_X_TLS_CACERTDIR = `enum LDAP_OPT_X_TLS_CACERTDIR = 0x6003;`; 4360 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CACERTDIR); }))) { 4361 mixin(enumMixinStr_LDAP_OPT_X_TLS_CACERTDIR); 4362 } 4363 } 4364 4365 4366 4367 4368 static if(!is(typeof(LDAP_OPT_X_TLS_CACERTFILE))) { 4369 private enum enumMixinStr_LDAP_OPT_X_TLS_CACERTFILE = `enum LDAP_OPT_X_TLS_CACERTFILE = 0x6002;`; 4370 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CACERTFILE); }))) { 4371 mixin(enumMixinStr_LDAP_OPT_X_TLS_CACERTFILE); 4372 } 4373 } 4374 4375 4376 4377 4378 static if(!is(typeof(LDAP_OPT_X_TLS_CTX))) { 4379 private enum enumMixinStr_LDAP_OPT_X_TLS_CTX = `enum LDAP_OPT_X_TLS_CTX = 0x6001;`; 4380 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS_CTX); }))) { 4381 mixin(enumMixinStr_LDAP_OPT_X_TLS_CTX); 4382 } 4383 } 4384 4385 4386 4387 4388 static if(!is(typeof(LDAP_OPT_X_TLS))) { 4389 private enum enumMixinStr_LDAP_OPT_X_TLS = `enum LDAP_OPT_X_TLS = 0x6000;`; 4390 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_X_TLS); }))) { 4391 mixin(enumMixinStr_LDAP_OPT_X_TLS); 4392 } 4393 } 4394 4395 4396 4397 4398 static if(!is(typeof(LDAP_OPT_SESSION_REFCNT))) { 4399 private enum enumMixinStr_LDAP_OPT_SESSION_REFCNT = `enum LDAP_OPT_SESSION_REFCNT = 0x5012;`; 4400 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SESSION_REFCNT); }))) { 4401 mixin(enumMixinStr_LDAP_OPT_SESSION_REFCNT); 4402 } 4403 } 4404 4405 4406 4407 4408 static if(!is(typeof(LDAP_OPT_CONNECT_CB))) { 4409 private enum enumMixinStr_LDAP_OPT_CONNECT_CB = `enum LDAP_OPT_CONNECT_CB = 0x5011;`; 4410 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_CONNECT_CB); }))) { 4411 mixin(enumMixinStr_LDAP_OPT_CONNECT_CB); 4412 } 4413 } 4414 4415 4416 4417 4418 static if(!is(typeof(LDAP_OPT_CONNECT_ASYNC))) { 4419 private enum enumMixinStr_LDAP_OPT_CONNECT_ASYNC = `enum LDAP_OPT_CONNECT_ASYNC = 0x5010;`; 4420 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_CONNECT_ASYNC); }))) { 4421 mixin(enumMixinStr_LDAP_OPT_CONNECT_ASYNC); 4422 } 4423 } 4424 4425 4426 4427 4428 static if(!is(typeof(LDAP_OPT_DEFBASE))) { 4429 private enum enumMixinStr_LDAP_OPT_DEFBASE = `enum LDAP_OPT_DEFBASE = 0x5009;`; 4430 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_DEFBASE); }))) { 4431 mixin(enumMixinStr_LDAP_OPT_DEFBASE); 4432 } 4433 } 4434 4435 4436 4437 4438 static if(!is(typeof(LDAP_OPT_SOCKBUF))) { 4439 private enum enumMixinStr_LDAP_OPT_SOCKBUF = `enum LDAP_OPT_SOCKBUF = 0x5008;`; 4440 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SOCKBUF); }))) { 4441 mixin(enumMixinStr_LDAP_OPT_SOCKBUF); 4442 } 4443 } 4444 4445 4446 4447 4448 static if(!is(typeof(LDAP_OPT_REFERRAL_URLS))) { 4449 private enum enumMixinStr_LDAP_OPT_REFERRAL_URLS = `enum LDAP_OPT_REFERRAL_URLS = 0x5007;`; 4450 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_REFERRAL_URLS); }))) { 4451 mixin(enumMixinStr_LDAP_OPT_REFERRAL_URLS); 4452 } 4453 } 4454 4455 4456 4457 4458 static if(!is(typeof(LDAP_OPT_URI))) { 4459 private enum enumMixinStr_LDAP_OPT_URI = `enum LDAP_OPT_URI = 0x5006;`; 4460 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_URI); }))) { 4461 mixin(enumMixinStr_LDAP_OPT_URI); 4462 } 4463 } 4464 4465 4466 4467 4468 static if(!is(typeof(LDAP_OPT_NETWORK_TIMEOUT))) { 4469 private enum enumMixinStr_LDAP_OPT_NETWORK_TIMEOUT = `enum LDAP_OPT_NETWORK_TIMEOUT = 0x5005;`; 4470 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_NETWORK_TIMEOUT); }))) { 4471 mixin(enumMixinStr_LDAP_OPT_NETWORK_TIMEOUT); 4472 } 4473 } 4474 4475 4476 4477 4478 static if(!is(typeof(LDAP_OPT_REFHOPLIMIT))) { 4479 private enum enumMixinStr_LDAP_OPT_REFHOPLIMIT = `enum LDAP_OPT_REFHOPLIMIT = 0x5003;`; 4480 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_REFHOPLIMIT); }))) { 4481 mixin(enumMixinStr_LDAP_OPT_REFHOPLIMIT); 4482 } 4483 } 4484 4485 4486 4487 4488 static if(!is(typeof(LDAP_OPT_TIMEOUT))) { 4489 private enum enumMixinStr_LDAP_OPT_TIMEOUT = `enum LDAP_OPT_TIMEOUT = 0x5002;`; 4490 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_TIMEOUT); }))) { 4491 mixin(enumMixinStr_LDAP_OPT_TIMEOUT); 4492 } 4493 } 4494 4495 4496 4497 4498 static if(!is(typeof(LDAP_OPT_DEBUG_LEVEL))) { 4499 private enum enumMixinStr_LDAP_OPT_DEBUG_LEVEL = `enum LDAP_OPT_DEBUG_LEVEL = 0x5001;`; 4500 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_DEBUG_LEVEL); }))) { 4501 mixin(enumMixinStr_LDAP_OPT_DEBUG_LEVEL); 4502 } 4503 } 4504 4505 4506 4507 4508 static if(!is(typeof(LDAP_OPT_API_EXTENSION_BASE))) { 4509 private enum enumMixinStr_LDAP_OPT_API_EXTENSION_BASE = `enum LDAP_OPT_API_EXTENSION_BASE = 0x4000;`; 4510 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_API_EXTENSION_BASE); }))) { 4511 mixin(enumMixinStr_LDAP_OPT_API_EXTENSION_BASE); 4512 } 4513 } 4514 4515 4516 4517 4518 static if(!is(typeof(LDAP_OPT_SECURITY_CONTEXT))) { 4519 private enum enumMixinStr_LDAP_OPT_SECURITY_CONTEXT = `enum LDAP_OPT_SECURITY_CONTEXT = 0x0099;`; 4520 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SECURITY_CONTEXT); }))) { 4521 mixin(enumMixinStr_LDAP_OPT_SECURITY_CONTEXT); 4522 } 4523 } 4524 4525 4526 4527 4528 static if(!is(typeof(LDAP_OPT_SASL_METHOD))) { 4529 private enum enumMixinStr_LDAP_OPT_SASL_METHOD = `enum LDAP_OPT_SASL_METHOD = 0x0097;`; 4530 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SASL_METHOD); }))) { 4531 mixin(enumMixinStr_LDAP_OPT_SASL_METHOD); 4532 } 4533 } 4534 4535 4536 4537 4538 static if(!is(typeof(LDAP_OPT_ENCRYPT))) { 4539 private enum enumMixinStr_LDAP_OPT_ENCRYPT = `enum LDAP_OPT_ENCRYPT = 0x0096;`; 4540 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_ENCRYPT); }))) { 4541 mixin(enumMixinStr_LDAP_OPT_ENCRYPT); 4542 } 4543 } 4544 4545 4546 4547 4548 static if(!is(typeof(LDAP_OPT_SIGN))) { 4549 private enum enumMixinStr_LDAP_OPT_SIGN = `enum LDAP_OPT_SIGN = 0x0095;`; 4550 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SIGN); }))) { 4551 mixin(enumMixinStr_LDAP_OPT_SIGN); 4552 } 4553 } 4554 4555 4556 4557 4558 static if(!is(typeof(LDAP_OPT_SSPI_FLAGS))) { 4559 private enum enumMixinStr_LDAP_OPT_SSPI_FLAGS = `enum LDAP_OPT_SSPI_FLAGS = 0x0092;`; 4560 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SSPI_FLAGS); }))) { 4561 mixin(enumMixinStr_LDAP_OPT_SSPI_FLAGS); 4562 } 4563 } 4564 4565 4566 4567 4568 static if(!is(typeof(LDAP_OPT_MATCHED_DN))) { 4569 private enum enumMixinStr_LDAP_OPT_MATCHED_DN = `enum LDAP_OPT_MATCHED_DN = 0x0033;`; 4570 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_MATCHED_DN); }))) { 4571 mixin(enumMixinStr_LDAP_OPT_MATCHED_DN); 4572 } 4573 } 4574 4575 4576 4577 4578 static if(!is(typeof(LDAP_OPT_ERROR_STRING))) { 4579 private enum enumMixinStr_LDAP_OPT_ERROR_STRING = `enum LDAP_OPT_ERROR_STRING = LDAP_OPT_DIAGNOSTIC_MESSAGE;`; 4580 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_ERROR_STRING); }))) { 4581 mixin(enumMixinStr_LDAP_OPT_ERROR_STRING); 4582 } 4583 } 4584 4585 4586 4587 4588 static if(!is(typeof(LDAP_OPT_DIAGNOSTIC_MESSAGE))) { 4589 private enum enumMixinStr_LDAP_OPT_DIAGNOSTIC_MESSAGE = `enum LDAP_OPT_DIAGNOSTIC_MESSAGE = 0x0032;`; 4590 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_DIAGNOSTIC_MESSAGE); }))) { 4591 mixin(enumMixinStr_LDAP_OPT_DIAGNOSTIC_MESSAGE); 4592 } 4593 } 4594 4595 4596 4597 4598 static if(!is(typeof(LDAP_OPT_ERROR_NUMBER))) { 4599 private enum enumMixinStr_LDAP_OPT_ERROR_NUMBER = `enum LDAP_OPT_ERROR_NUMBER = LDAP_OPT_RESULT_CODE;`; 4600 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_ERROR_NUMBER); }))) { 4601 mixin(enumMixinStr_LDAP_OPT_ERROR_NUMBER); 4602 } 4603 } 4604 4605 4606 4607 4608 static if(!is(typeof(LDAP_OPT_RESULT_CODE))) { 4609 private enum enumMixinStr_LDAP_OPT_RESULT_CODE = `enum LDAP_OPT_RESULT_CODE = 0x0031;`; 4610 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_RESULT_CODE); }))) { 4611 mixin(enumMixinStr_LDAP_OPT_RESULT_CODE); 4612 } 4613 } 4614 4615 4616 4617 4618 static if(!is(typeof(LDAP_OPT_HOST_NAME))) { 4619 private enum enumMixinStr_LDAP_OPT_HOST_NAME = `enum LDAP_OPT_HOST_NAME = 0x0030;`; 4620 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_HOST_NAME); }))) { 4621 mixin(enumMixinStr_LDAP_OPT_HOST_NAME); 4622 } 4623 } 4624 4625 4626 4627 4628 static if(!is(typeof(LDAP_OPT_API_FEATURE_INFO))) { 4629 private enum enumMixinStr_LDAP_OPT_API_FEATURE_INFO = `enum LDAP_OPT_API_FEATURE_INFO = 0x0015;`; 4630 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_API_FEATURE_INFO); }))) { 4631 mixin(enumMixinStr_LDAP_OPT_API_FEATURE_INFO); 4632 } 4633 } 4634 4635 4636 4637 4638 static if(!is(typeof(LDAP_OPT_CLIENT_CONTROLS))) { 4639 private enum enumMixinStr_LDAP_OPT_CLIENT_CONTROLS = `enum LDAP_OPT_CLIENT_CONTROLS = 0x0013;`; 4640 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_CLIENT_CONTROLS); }))) { 4641 mixin(enumMixinStr_LDAP_OPT_CLIENT_CONTROLS); 4642 } 4643 } 4644 4645 4646 4647 4648 static if(!is(typeof(LDAP_OPT_SERVER_CONTROLS))) { 4649 private enum enumMixinStr_LDAP_OPT_SERVER_CONTROLS = `enum LDAP_OPT_SERVER_CONTROLS = 0x0012;`; 4650 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SERVER_CONTROLS); }))) { 4651 mixin(enumMixinStr_LDAP_OPT_SERVER_CONTROLS); 4652 } 4653 } 4654 4655 4656 4657 4658 static if(!is(typeof(LDAP_OPT_PROTOCOL_VERSION))) { 4659 private enum enumMixinStr_LDAP_OPT_PROTOCOL_VERSION = `enum LDAP_OPT_PROTOCOL_VERSION = 0x0011;`; 4660 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_PROTOCOL_VERSION); }))) { 4661 mixin(enumMixinStr_LDAP_OPT_PROTOCOL_VERSION); 4662 } 4663 } 4664 4665 4666 4667 4668 static if(!is(typeof(LDAP_OPT_RESTART))) { 4669 private enum enumMixinStr_LDAP_OPT_RESTART = `enum LDAP_OPT_RESTART = 0x0009;`; 4670 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_RESTART); }))) { 4671 mixin(enumMixinStr_LDAP_OPT_RESTART); 4672 } 4673 } 4674 4675 4676 4677 4678 static if(!is(typeof(LDAP_OPT_REFERRALS))) { 4679 private enum enumMixinStr_LDAP_OPT_REFERRALS = `enum LDAP_OPT_REFERRALS = 0x0008;`; 4680 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_REFERRALS); }))) { 4681 mixin(enumMixinStr_LDAP_OPT_REFERRALS); 4682 } 4683 } 4684 4685 4686 4687 4688 static if(!is(typeof(LDAP_OPT_TIMELIMIT))) { 4689 private enum enumMixinStr_LDAP_OPT_TIMELIMIT = `enum LDAP_OPT_TIMELIMIT = 0x0004;`; 4690 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_TIMELIMIT); }))) { 4691 mixin(enumMixinStr_LDAP_OPT_TIMELIMIT); 4692 } 4693 } 4694 4695 4696 4697 4698 static if(!is(typeof(LDAP_OPT_SIZELIMIT))) { 4699 private enum enumMixinStr_LDAP_OPT_SIZELIMIT = `enum LDAP_OPT_SIZELIMIT = 0x0003;`; 4700 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_SIZELIMIT); }))) { 4701 mixin(enumMixinStr_LDAP_OPT_SIZELIMIT); 4702 } 4703 } 4704 4705 4706 4707 4708 static if(!is(typeof(LDAP_OPT_DEREF))) { 4709 private enum enumMixinStr_LDAP_OPT_DEREF = `enum LDAP_OPT_DEREF = 0x0002;`; 4710 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_DEREF); }))) { 4711 mixin(enumMixinStr_LDAP_OPT_DEREF); 4712 } 4713 } 4714 4715 4716 4717 4718 static if(!is(typeof(LDAP_OPT_DESC))) { 4719 private enum enumMixinStr_LDAP_OPT_DESC = `enum LDAP_OPT_DESC = 0x0001;`; 4720 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_DESC); }))) { 4721 mixin(enumMixinStr_LDAP_OPT_DESC); 4722 } 4723 } 4724 4725 4726 4727 4728 static if(!is(typeof(LDAP_OPT_API_INFO))) { 4729 private enum enumMixinStr_LDAP_OPT_API_INFO = `enum LDAP_OPT_API_INFO = 0x0000;`; 4730 static if(is(typeof({ mixin(enumMixinStr_LDAP_OPT_API_INFO); }))) { 4731 mixin(enumMixinStr_LDAP_OPT_API_INFO); 4732 } 4733 } 4734 4735 4736 4737 4738 static if(!is(typeof(LDAP_MAXINT))) { 4739 private enum enumMixinStr_LDAP_MAXINT = `enum LDAP_MAXINT = ( 2147483647 );`; 4740 static if(is(typeof({ mixin(enumMixinStr_LDAP_MAXINT); }))) { 4741 mixin(enumMixinStr_LDAP_MAXINT); 4742 } 4743 } 4744 4745 4746 4747 4748 static if(!is(typeof(LDAP_ALL_OPERATIONAL_ATTRIBUTES))) { 4749 private enum enumMixinStr_LDAP_ALL_OPERATIONAL_ATTRIBUTES = `enum LDAP_ALL_OPERATIONAL_ATTRIBUTES = "+";`; 4750 static if(is(typeof({ mixin(enumMixinStr_LDAP_ALL_OPERATIONAL_ATTRIBUTES); }))) { 4751 mixin(enumMixinStr_LDAP_ALL_OPERATIONAL_ATTRIBUTES); 4752 } 4753 } 4754 4755 4756 4757 4758 static if(!is(typeof(LDAP_ALL_USER_ATTRIBUTES))) { 4759 private enum enumMixinStr_LDAP_ALL_USER_ATTRIBUTES = `enum LDAP_ALL_USER_ATTRIBUTES = "*";`; 4760 static if(is(typeof({ mixin(enumMixinStr_LDAP_ALL_USER_ATTRIBUTES); }))) { 4761 mixin(enumMixinStr_LDAP_ALL_USER_ATTRIBUTES); 4762 } 4763 } 4764 4765 4766 4767 4768 static if(!is(typeof(LDAP_NO_ATTRS))) { 4769 private enum enumMixinStr_LDAP_NO_ATTRS = `enum LDAP_NO_ATTRS = "1.1";`; 4770 static if(is(typeof({ mixin(enumMixinStr_LDAP_NO_ATTRS); }))) { 4771 mixin(enumMixinStr_LDAP_NO_ATTRS); 4772 } 4773 } 4774 4775 4776 4777 4778 static if(!is(typeof(LDAP_ROOT_DSE))) { 4779 private enum enumMixinStr_LDAP_ROOT_DSE = `enum LDAP_ROOT_DSE = "";`; 4780 static if(is(typeof({ mixin(enumMixinStr_LDAP_ROOT_DSE); }))) { 4781 mixin(enumMixinStr_LDAP_ROOT_DSE); 4782 } 4783 } 4784 4785 4786 4787 4788 static if(!is(typeof(LDAPS_PORT))) { 4789 private enum enumMixinStr_LDAPS_PORT = `enum LDAPS_PORT = 636;`; 4790 static if(is(typeof({ mixin(enumMixinStr_LDAPS_PORT); }))) { 4791 mixin(enumMixinStr_LDAPS_PORT); 4792 } 4793 } 4794 4795 4796 4797 4798 static if(!is(typeof(LDAP_PORT))) { 4799 private enum enumMixinStr_LDAP_PORT = `enum LDAP_PORT = 389;`; 4800 static if(is(typeof({ mixin(enumMixinStr_LDAP_PORT); }))) { 4801 mixin(enumMixinStr_LDAP_PORT); 4802 } 4803 } 4804 4805 4806 4807 4808 static if(!is(typeof(LDAP_API_FEATURE_X_OPENLDAP))) { 4809 private enum enumMixinStr_LDAP_API_FEATURE_X_OPENLDAP = `enum LDAP_API_FEATURE_X_OPENLDAP = LDAP_VENDOR_VERSION;`; 4810 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_X_OPENLDAP); }))) { 4811 mixin(enumMixinStr_LDAP_API_FEATURE_X_OPENLDAP); 4812 } 4813 } 4814 4815 4816 4817 4818 static if(!is(typeof(LDAP_VENDOR_NAME))) { 4819 private enum enumMixinStr_LDAP_VENDOR_NAME = `enum LDAP_VENDOR_NAME = "OpenLDAP";`; 4820 static if(is(typeof({ mixin(enumMixinStr_LDAP_VENDOR_NAME); }))) { 4821 mixin(enumMixinStr_LDAP_VENDOR_NAME); 4822 } 4823 } 4824 4825 4826 4827 4828 static if(!is(typeof(LDAP_API_VERSION))) { 4829 private enum enumMixinStr_LDAP_API_VERSION = `enum LDAP_API_VERSION = 3001;`; 4830 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_VERSION); }))) { 4831 mixin(enumMixinStr_LDAP_API_VERSION); 4832 } 4833 } 4834 4835 4836 4837 4838 static if(!is(typeof(LDAP_VERSION_MAX))) { 4839 private enum enumMixinStr_LDAP_VERSION_MAX = `enum LDAP_VERSION_MAX = LDAP_VERSION3;`; 4840 static if(is(typeof({ mixin(enumMixinStr_LDAP_VERSION_MAX); }))) { 4841 mixin(enumMixinStr_LDAP_VERSION_MAX); 4842 } 4843 } 4844 4845 4846 4847 4848 static if(!is(typeof(LDAP_VERSION))) { 4849 private enum enumMixinStr_LDAP_VERSION = `enum LDAP_VERSION = LDAP_VERSION2;`; 4850 static if(is(typeof({ mixin(enumMixinStr_LDAP_VERSION); }))) { 4851 mixin(enumMixinStr_LDAP_VERSION); 4852 } 4853 } 4854 4855 4856 4857 4858 static if(!is(typeof(LDAP_VERSION_MIN))) { 4859 private enum enumMixinStr_LDAP_VERSION_MIN = `enum LDAP_VERSION_MIN = LDAP_VERSION2;`; 4860 static if(is(typeof({ mixin(enumMixinStr_LDAP_VERSION_MIN); }))) { 4861 mixin(enumMixinStr_LDAP_VERSION_MIN); 4862 } 4863 } 4864 4865 4866 4867 4868 static if(!is(typeof(LDAP_VERSION3))) { 4869 private enum enumMixinStr_LDAP_VERSION3 = `enum LDAP_VERSION3 = 3;`; 4870 static if(is(typeof({ mixin(enumMixinStr_LDAP_VERSION3); }))) { 4871 mixin(enumMixinStr_LDAP_VERSION3); 4872 } 4873 } 4874 4875 4876 4877 4878 static if(!is(typeof(LDAP_VERSION2))) { 4879 private enum enumMixinStr_LDAP_VERSION2 = `enum LDAP_VERSION2 = 2;`; 4880 static if(is(typeof({ mixin(enumMixinStr_LDAP_VERSION2); }))) { 4881 mixin(enumMixinStr_LDAP_VERSION2); 4882 } 4883 } 4884 4885 4886 4887 4888 static if(!is(typeof(LDAP_VERSION1))) { 4889 private enum enumMixinStr_LDAP_VERSION1 = `enum LDAP_VERSION1 = 1;`; 4890 static if(is(typeof({ mixin(enumMixinStr_LDAP_VERSION1); }))) { 4891 mixin(enumMixinStr_LDAP_VERSION1); 4892 } 4893 } 4894 4895 4896 4897 4898 4899 4900 static if(!is(typeof(LBER_LEN_T))) { 4901 private enum enumMixinStr_LBER_LEN_T = `enum LBER_LEN_T = long;`; 4902 static if(is(typeof({ mixin(enumMixinStr_LBER_LEN_T); }))) { 4903 mixin(enumMixinStr_LBER_LEN_T); 4904 } 4905 } 4906 4907 4908 4909 4910 static if(!is(typeof(LBER_SOCKET_T))) { 4911 private enum enumMixinStr_LBER_SOCKET_T = `enum LBER_SOCKET_T = int;`; 4912 static if(is(typeof({ mixin(enumMixinStr_LBER_SOCKET_T); }))) { 4913 mixin(enumMixinStr_LBER_SOCKET_T); 4914 } 4915 } 4916 4917 4918 4919 4920 static if(!is(typeof(LBER_TAG_T))) { 4921 private enum enumMixinStr_LBER_TAG_T = `enum LBER_TAG_T = long;`; 4922 static if(is(typeof({ mixin(enumMixinStr_LBER_TAG_T); }))) { 4923 mixin(enumMixinStr_LBER_TAG_T); 4924 } 4925 } 4926 4927 4928 4929 4930 static if(!is(typeof(LBER_INT_T))) { 4931 private enum enumMixinStr_LBER_INT_T = `enum LBER_INT_T = int;`; 4932 static if(is(typeof({ mixin(enumMixinStr_LBER_INT_T); }))) { 4933 mixin(enumMixinStr_LBER_INT_T); 4934 } 4935 } 4936 4937 4938 4939 4940 4941 4942 static if(!is(typeof(LBER_ERROR_MEMORY))) { 4943 private enum enumMixinStr_LBER_ERROR_MEMORY = `enum LBER_ERROR_MEMORY = 0x2;`; 4944 static if(is(typeof({ mixin(enumMixinStr_LBER_ERROR_MEMORY); }))) { 4945 mixin(enumMixinStr_LBER_ERROR_MEMORY); 4946 } 4947 } 4948 4949 4950 4951 4952 static if(!is(typeof(LBER_ERROR_PARAM))) { 4953 private enum enumMixinStr_LBER_ERROR_PARAM = `enum LBER_ERROR_PARAM = 0x1;`; 4954 static if(is(typeof({ mixin(enumMixinStr_LBER_ERROR_PARAM); }))) { 4955 mixin(enumMixinStr_LBER_ERROR_PARAM); 4956 } 4957 } 4958 4959 4960 4961 4962 static if(!is(typeof(LBER_ERROR_NONE))) { 4963 private enum enumMixinStr_LBER_ERROR_NONE = `enum LBER_ERROR_NONE = 0;`; 4964 static if(is(typeof({ mixin(enumMixinStr_LBER_ERROR_NONE); }))) { 4965 mixin(enumMixinStr_LBER_ERROR_NONE); 4966 } 4967 } 4968 4969 4970 4971 4972 static if(!is(typeof(ber_errno))) { 4973 private enum enumMixinStr_ber_errno = `enum ber_errno = ( * ( ber_errno_addr ) ( ) );`; 4974 static if(is(typeof({ mixin(enumMixinStr_ber_errno); }))) { 4975 mixin(enumMixinStr_ber_errno); 4976 } 4977 } 4978 static if(!is(typeof(LBER_FLUSH_FREE_ALWAYS))) { 4979 private enum enumMixinStr_LBER_FLUSH_FREE_ALWAYS = `enum LBER_FLUSH_FREE_ALWAYS = ( LBER_FLUSH_FREE_ON_SUCCESS | LBER_FLUSH_FREE_ON_ERROR );`; 4980 static if(is(typeof({ mixin(enumMixinStr_LBER_FLUSH_FREE_ALWAYS); }))) { 4981 mixin(enumMixinStr_LBER_FLUSH_FREE_ALWAYS); 4982 } 4983 } 4984 4985 4986 4987 4988 static if(!is(typeof(LBER_FLUSH_FREE_ON_ERROR))) { 4989 private enum enumMixinStr_LBER_FLUSH_FREE_ON_ERROR = `enum LBER_FLUSH_FREE_ON_ERROR = ( 0x2 );`; 4990 static if(is(typeof({ mixin(enumMixinStr_LBER_FLUSH_FREE_ON_ERROR); }))) { 4991 mixin(enumMixinStr_LBER_FLUSH_FREE_ON_ERROR); 4992 } 4993 } 4994 4995 4996 4997 4998 static if(!is(typeof(LBER_FLUSH_FREE_ON_SUCCESS))) { 4999 private enum enumMixinStr_LBER_FLUSH_FREE_ON_SUCCESS = `enum LBER_FLUSH_FREE_ON_SUCCESS = ( 0x1 );`; 5000 static if(is(typeof({ mixin(enumMixinStr_LBER_FLUSH_FREE_ON_SUCCESS); }))) { 5001 mixin(enumMixinStr_LBER_FLUSH_FREE_ON_SUCCESS); 5002 } 5003 } 5004 5005 5006 5007 5008 static if(!is(typeof(LBER_FLUSH_FREE_NEVER))) { 5009 private enum enumMixinStr_LBER_FLUSH_FREE_NEVER = `enum LBER_FLUSH_FREE_NEVER = ( 0x0 );`; 5010 static if(is(typeof({ mixin(enumMixinStr_LBER_FLUSH_FREE_NEVER); }))) { 5011 mixin(enumMixinStr_LBER_FLUSH_FREE_NEVER); 5012 } 5013 } 5014 5015 5016 5017 5018 static if(!is(typeof(LBER_BV_STRING))) { 5019 private enum enumMixinStr_LBER_BV_STRING = `enum LBER_BV_STRING = 0x04;`; 5020 static if(is(typeof({ mixin(enumMixinStr_LBER_BV_STRING); }))) { 5021 mixin(enumMixinStr_LBER_BV_STRING); 5022 } 5023 } 5024 5025 5026 5027 5028 static if(!is(typeof(LBER_BV_NOTERM))) { 5029 private enum enumMixinStr_LBER_BV_NOTERM = `enum LBER_BV_NOTERM = 0x02;`; 5030 static if(is(typeof({ mixin(enumMixinStr_LBER_BV_NOTERM); }))) { 5031 mixin(enumMixinStr_LBER_BV_NOTERM); 5032 } 5033 } 5034 5035 5036 5037 5038 static if(!is(typeof(LBER_BV_ALLOC))) { 5039 private enum enumMixinStr_LBER_BV_ALLOC = `enum LBER_BV_ALLOC = 0x01;`; 5040 static if(is(typeof({ mixin(enumMixinStr_LBER_BV_ALLOC); }))) { 5041 mixin(enumMixinStr_LBER_BV_ALLOC); 5042 } 5043 } 5044 static if(!is(typeof(LBER_OPT_ERROR))) { 5045 private enum enumMixinStr_LBER_OPT_ERROR = `enum LBER_OPT_ERROR = ( - 1 );`; 5046 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_ERROR); }))) { 5047 mixin(enumMixinStr_LBER_OPT_ERROR); 5048 } 5049 } 5050 5051 5052 5053 5054 static if(!is(typeof(LBER_OPT_SUCCESS))) { 5055 private enum enumMixinStr_LBER_OPT_SUCCESS = `enum LBER_OPT_SUCCESS = ( 0 );`; 5056 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_SUCCESS); }))) { 5057 mixin(enumMixinStr_LBER_OPT_SUCCESS); 5058 } 5059 } 5060 5061 5062 5063 5064 static if(!is(typeof(LBER_OPT_OFF))) { 5065 private enum enumMixinStr_LBER_OPT_OFF = `enum LBER_OPT_OFF = ( cast( void * ) 0 );`; 5066 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_OFF); }))) { 5067 mixin(enumMixinStr_LBER_OPT_OFF); 5068 } 5069 } 5070 5071 5072 5073 5074 static if(!is(typeof(LBER_OPT_ON))) { 5075 private enum enumMixinStr_LBER_OPT_ON = `enum LBER_OPT_ON = ( cast( void * ) & ber_pvt_opt_on );`; 5076 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_ON); }))) { 5077 mixin(enumMixinStr_LBER_OPT_ON); 5078 } 5079 } 5080 5081 5082 5083 5084 static if(!is(typeof(LBER_OPT_SOCKBUF_DEBUG))) { 5085 private enum enumMixinStr_LBER_OPT_SOCKBUF_DEBUG = `enum LBER_OPT_SOCKBUF_DEBUG = 0x1002;`; 5086 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_SOCKBUF_DEBUG); }))) { 5087 mixin(enumMixinStr_LBER_OPT_SOCKBUF_DEBUG); 5088 } 5089 } 5090 5091 5092 5093 5094 static if(!is(typeof(LBER_OPT_SOCKBUF_OPTIONS))) { 5095 private enum enumMixinStr_LBER_OPT_SOCKBUF_OPTIONS = `enum LBER_OPT_SOCKBUF_OPTIONS = 0x1001;`; 5096 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_SOCKBUF_OPTIONS); }))) { 5097 mixin(enumMixinStr_LBER_OPT_SOCKBUF_OPTIONS); 5098 } 5099 } 5100 5101 5102 5103 5104 static if(!is(typeof(LBER_OPT_SOCKBUF_DESC))) { 5105 private enum enumMixinStr_LBER_OPT_SOCKBUF_DESC = `enum LBER_OPT_SOCKBUF_DESC = 0x1000;`; 5106 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_SOCKBUF_DESC); }))) { 5107 mixin(enumMixinStr_LBER_OPT_SOCKBUF_DESC); 5108 } 5109 } 5110 5111 5112 5113 5114 static if(!is(typeof(LBER_SBIOD_LEVEL_APPLICATION))) { 5115 private enum enumMixinStr_LBER_SBIOD_LEVEL_APPLICATION = `enum LBER_SBIOD_LEVEL_APPLICATION = 30;`; 5116 static if(is(typeof({ mixin(enumMixinStr_LBER_SBIOD_LEVEL_APPLICATION); }))) { 5117 mixin(enumMixinStr_LBER_SBIOD_LEVEL_APPLICATION); 5118 } 5119 } 5120 5121 5122 5123 5124 static if(!is(typeof(LBER_SBIOD_LEVEL_TRANSPORT))) { 5125 private enum enumMixinStr_LBER_SBIOD_LEVEL_TRANSPORT = `enum LBER_SBIOD_LEVEL_TRANSPORT = 20;`; 5126 static if(is(typeof({ mixin(enumMixinStr_LBER_SBIOD_LEVEL_TRANSPORT); }))) { 5127 mixin(enumMixinStr_LBER_SBIOD_LEVEL_TRANSPORT); 5128 } 5129 } 5130 5131 5132 5133 5134 static if(!is(typeof(LBER_SBIOD_LEVEL_PROVIDER))) { 5135 private enum enumMixinStr_LBER_SBIOD_LEVEL_PROVIDER = `enum LBER_SBIOD_LEVEL_PROVIDER = 10;`; 5136 static if(is(typeof({ mixin(enumMixinStr_LBER_SBIOD_LEVEL_PROVIDER); }))) { 5137 mixin(enumMixinStr_LBER_SBIOD_LEVEL_PROVIDER); 5138 } 5139 } 5140 5141 5142 5143 5144 static if(!is(typeof(LBER_SB_OPT_OPT_MAX))) { 5145 private enum enumMixinStr_LBER_SB_OPT_OPT_MAX = `enum LBER_SB_OPT_OPT_MAX = 15;`; 5146 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_OPT_MAX); }))) { 5147 mixin(enumMixinStr_LBER_SB_OPT_OPT_MAX); 5148 } 5149 } 5150 5151 5152 5153 5154 static if(!is(typeof(LDAP_API_FEATURE_CANCEL))) { 5155 private enum enumMixinStr_LDAP_API_FEATURE_CANCEL = `enum LDAP_API_FEATURE_CANCEL = 1000;`; 5156 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_CANCEL); }))) { 5157 mixin(enumMixinStr_LDAP_API_FEATURE_CANCEL); 5158 } 5159 } 5160 5161 5162 5163 5164 static if(!is(typeof(LBER_SB_OPT_UNGET_BUF))) { 5165 private enum enumMixinStr_LBER_SB_OPT_UNGET_BUF = `enum LBER_SB_OPT_UNGET_BUF = 15;`; 5166 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_UNGET_BUF); }))) { 5167 mixin(enumMixinStr_LBER_SB_OPT_UNGET_BUF); 5168 } 5169 } 5170 5171 5172 5173 5174 static if(!is(typeof(LBER_SB_OPT_SET_MAX_INCOMING))) { 5175 private enum enumMixinStr_LBER_SB_OPT_SET_MAX_INCOMING = `enum LBER_SB_OPT_SET_MAX_INCOMING = 14;`; 5176 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_SET_MAX_INCOMING); }))) { 5177 mixin(enumMixinStr_LBER_SB_OPT_SET_MAX_INCOMING); 5178 } 5179 } 5180 5181 5182 5183 5184 static if(!is(typeof(LBER_SB_OPT_GET_MAX_INCOMING))) { 5185 private enum enumMixinStr_LBER_SB_OPT_GET_MAX_INCOMING = `enum LBER_SB_OPT_GET_MAX_INCOMING = 13;`; 5186 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_GET_MAX_INCOMING); }))) { 5187 mixin(enumMixinStr_LBER_SB_OPT_GET_MAX_INCOMING); 5188 } 5189 } 5190 5191 5192 5193 5194 static if(!is(typeof(LBER_SB_OPT_NEEDS_WRITE))) { 5195 private enum enumMixinStr_LBER_SB_OPT_NEEDS_WRITE = `enum LBER_SB_OPT_NEEDS_WRITE = 12;`; 5196 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_NEEDS_WRITE); }))) { 5197 mixin(enumMixinStr_LBER_SB_OPT_NEEDS_WRITE); 5198 } 5199 } 5200 5201 5202 5203 5204 static if(!is(typeof(LBER_SB_OPT_NEEDS_READ))) { 5205 private enum enumMixinStr_LBER_SB_OPT_NEEDS_READ = `enum LBER_SB_OPT_NEEDS_READ = 11;`; 5206 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_NEEDS_READ); }))) { 5207 mixin(enumMixinStr_LBER_SB_OPT_NEEDS_READ); 5208 } 5209 } 5210 5211 5212 5213 5214 static if(!is(typeof(LBER_SB_OPT_DRAIN))) { 5215 private enum enumMixinStr_LBER_SB_OPT_DRAIN = `enum LBER_SB_OPT_DRAIN = 10;`; 5216 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_DRAIN); }))) { 5217 mixin(enumMixinStr_LBER_SB_OPT_DRAIN); 5218 } 5219 } 5220 5221 5222 5223 5224 static if(!is(typeof(LDAP_API_FEATURE_TURN))) { 5225 private enum enumMixinStr_LDAP_API_FEATURE_TURN = `enum LDAP_API_FEATURE_TURN = 1000;`; 5226 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_TURN); }))) { 5227 mixin(enumMixinStr_LDAP_API_FEATURE_TURN); 5228 } 5229 } 5230 5231 5232 5233 5234 static if(!is(typeof(LBER_SB_OPT_SET_READAHEAD))) { 5235 private enum enumMixinStr_LBER_SB_OPT_SET_READAHEAD = `enum LBER_SB_OPT_SET_READAHEAD = 9;`; 5236 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_SET_READAHEAD); }))) { 5237 mixin(enumMixinStr_LBER_SB_OPT_SET_READAHEAD); 5238 } 5239 } 5240 5241 5242 5243 5244 static if(!is(typeof(LBER_SB_OPT_DATA_READY))) { 5245 private enum enumMixinStr_LBER_SB_OPT_DATA_READY = `enum LBER_SB_OPT_DATA_READY = 8;`; 5246 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_DATA_READY); }))) { 5247 mixin(enumMixinStr_LBER_SB_OPT_DATA_READY); 5248 } 5249 } 5250 5251 5252 5253 5254 static if(!is(typeof(LBER_SB_OPT_GET_SSL))) { 5255 private enum enumMixinStr_LBER_SB_OPT_GET_SSL = `enum LBER_SB_OPT_GET_SSL = 7;`; 5256 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_GET_SSL); }))) { 5257 mixin(enumMixinStr_LBER_SB_OPT_GET_SSL); 5258 } 5259 } 5260 5261 5262 5263 5264 static if(!is(typeof(LBER_SB_OPT_SET_NONBLOCK))) { 5265 private enum enumMixinStr_LBER_SB_OPT_SET_NONBLOCK = `enum LBER_SB_OPT_SET_NONBLOCK = 4;`; 5266 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_SET_NONBLOCK); }))) { 5267 mixin(enumMixinStr_LBER_SB_OPT_SET_NONBLOCK); 5268 } 5269 } 5270 5271 5272 5273 5274 static if(!is(typeof(LBER_SB_OPT_HAS_IO))) { 5275 private enum enumMixinStr_LBER_SB_OPT_HAS_IO = `enum LBER_SB_OPT_HAS_IO = 3;`; 5276 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_HAS_IO); }))) { 5277 mixin(enumMixinStr_LBER_SB_OPT_HAS_IO); 5278 } 5279 } 5280 5281 5282 5283 5284 static if(!is(typeof(LBER_SB_OPT_SET_FD))) { 5285 private enum enumMixinStr_LBER_SB_OPT_SET_FD = `enum LBER_SB_OPT_SET_FD = 2;`; 5286 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_SET_FD); }))) { 5287 mixin(enumMixinStr_LBER_SB_OPT_SET_FD); 5288 } 5289 } 5290 5291 5292 5293 5294 static if(!is(typeof(LBER_SB_OPT_GET_FD))) { 5295 private enum enumMixinStr_LBER_SB_OPT_GET_FD = `enum LBER_SB_OPT_GET_FD = 1;`; 5296 static if(is(typeof({ mixin(enumMixinStr_LBER_SB_OPT_GET_FD); }))) { 5297 mixin(enumMixinStr_LBER_SB_OPT_GET_FD); 5298 } 5299 } 5300 5301 5302 5303 5304 static if(!is(typeof(LBER_OPT_LOG_PROC))) { 5305 private enum enumMixinStr_LBER_OPT_LOG_PROC = `enum LBER_OPT_LOG_PROC = 0x8006;`; 5306 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_LOG_PROC); }))) { 5307 mixin(enumMixinStr_LBER_OPT_LOG_PROC); 5308 } 5309 } 5310 5311 5312 5313 5314 static if(!is(typeof(LDAP_API_FEATURE_PAGED_RESULTS))) { 5315 private enum enumMixinStr_LDAP_API_FEATURE_PAGED_RESULTS = `enum LDAP_API_FEATURE_PAGED_RESULTS = 2000;`; 5316 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_PAGED_RESULTS); }))) { 5317 mixin(enumMixinStr_LDAP_API_FEATURE_PAGED_RESULTS); 5318 } 5319 } 5320 5321 5322 5323 5324 static if(!is(typeof(LBER_OPT_MEMORY_INUSE))) { 5325 private enum enumMixinStr_LBER_OPT_MEMORY_INUSE = `enum LBER_OPT_MEMORY_INUSE = 0x8005;`; 5326 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_MEMORY_INUSE); }))) { 5327 mixin(enumMixinStr_LBER_OPT_MEMORY_INUSE); 5328 } 5329 } 5330 5331 5332 5333 5334 static if(!is(typeof(LBER_OPT_LOG_PRINT_FILE))) { 5335 private enum enumMixinStr_LBER_OPT_LOG_PRINT_FILE = `enum LBER_OPT_LOG_PRINT_FILE = 0x8004;`; 5336 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_LOG_PRINT_FILE); }))) { 5337 mixin(enumMixinStr_LBER_OPT_LOG_PRINT_FILE); 5338 } 5339 } 5340 5341 5342 5343 5344 static if(!is(typeof(LBER_OPT_ERROR_FN))) { 5345 private enum enumMixinStr_LBER_OPT_ERROR_FN = `enum LBER_OPT_ERROR_FN = 0x8003;`; 5346 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_ERROR_FN); }))) { 5347 mixin(enumMixinStr_LBER_OPT_ERROR_FN); 5348 } 5349 } 5350 5351 5352 5353 5354 static if(!is(typeof(LBER_OPT_MEMORY_FNS))) { 5355 private enum enumMixinStr_LBER_OPT_MEMORY_FNS = `enum LBER_OPT_MEMORY_FNS = 0x8002;`; 5356 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_MEMORY_FNS); }))) { 5357 mixin(enumMixinStr_LBER_OPT_MEMORY_FNS); 5358 } 5359 } 5360 5361 5362 5363 5364 static if(!is(typeof(LBER_OPT_LOG_PRINT_FN))) { 5365 private enum enumMixinStr_LBER_OPT_LOG_PRINT_FN = `enum LBER_OPT_LOG_PRINT_FN = 0x8001;`; 5366 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_LOG_PRINT_FN); }))) { 5367 mixin(enumMixinStr_LBER_OPT_LOG_PRINT_FN); 5368 } 5369 } 5370 5371 5372 5373 5374 static if(!is(typeof(LBER_OPT_BYTES_TO_WRITE))) { 5375 private enum enumMixinStr_LBER_OPT_BYTES_TO_WRITE = `enum LBER_OPT_BYTES_TO_WRITE = LBER_OPT_BER_BYTES_TO_WRITE;`; 5376 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_BYTES_TO_WRITE); }))) { 5377 mixin(enumMixinStr_LBER_OPT_BYTES_TO_WRITE); 5378 } 5379 } 5380 5381 5382 5383 5384 static if(!is(typeof(LBER_OPT_TOTAL_BYTES))) { 5385 private enum enumMixinStr_LBER_OPT_TOTAL_BYTES = `enum LBER_OPT_TOTAL_BYTES = LBER_OPT_BER_TOTAL_BYTES;`; 5386 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_TOTAL_BYTES); }))) { 5387 mixin(enumMixinStr_LBER_OPT_TOTAL_BYTES); 5388 } 5389 } 5390 5391 5392 5393 5394 static if(!is(typeof(LBER_OPT_REMAINING_BYTES))) { 5395 private enum enumMixinStr_LBER_OPT_REMAINING_BYTES = `enum LBER_OPT_REMAINING_BYTES = LBER_OPT_BER_REMAINING_BYTES;`; 5396 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_REMAINING_BYTES); }))) { 5397 mixin(enumMixinStr_LBER_OPT_REMAINING_BYTES); 5398 } 5399 } 5400 5401 5402 5403 5404 static if(!is(typeof(LBER_OPT_DEBUG_LEVEL))) { 5405 private enum enumMixinStr_LBER_OPT_DEBUG_LEVEL = `enum LBER_OPT_DEBUG_LEVEL = LBER_OPT_BER_DEBUG;`; 5406 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_DEBUG_LEVEL); }))) { 5407 mixin(enumMixinStr_LBER_OPT_DEBUG_LEVEL); 5408 } 5409 } 5410 5411 5412 5413 5414 static if(!is(typeof(LDAP_API_FEATURE_SERVER_SIDE_SORT))) { 5415 private enum enumMixinStr_LDAP_API_FEATURE_SERVER_SIDE_SORT = `enum LDAP_API_FEATURE_SERVER_SIDE_SORT = 2000;`; 5416 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_SERVER_SIDE_SORT); }))) { 5417 mixin(enumMixinStr_LDAP_API_FEATURE_SERVER_SIDE_SORT); 5418 } 5419 } 5420 5421 5422 5423 5424 static if(!is(typeof(LBER_OPT_BER_MEMCTX))) { 5425 private enum enumMixinStr_LBER_OPT_BER_MEMCTX = `enum LBER_OPT_BER_MEMCTX = 0x06;`; 5426 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_BER_MEMCTX); }))) { 5427 mixin(enumMixinStr_LBER_OPT_BER_MEMCTX); 5428 } 5429 } 5430 5431 5432 5433 5434 static if(!is(typeof(LBER_OPT_BER_BYTES_TO_WRITE))) { 5435 private enum enumMixinStr_LBER_OPT_BER_BYTES_TO_WRITE = `enum LBER_OPT_BER_BYTES_TO_WRITE = 0x05;`; 5436 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_BER_BYTES_TO_WRITE); }))) { 5437 mixin(enumMixinStr_LBER_OPT_BER_BYTES_TO_WRITE); 5438 } 5439 } 5440 5441 5442 5443 5444 static if(!is(typeof(LBER_OPT_BER_TOTAL_BYTES))) { 5445 private enum enumMixinStr_LBER_OPT_BER_TOTAL_BYTES = `enum LBER_OPT_BER_TOTAL_BYTES = 0x04;`; 5446 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_BER_TOTAL_BYTES); }))) { 5447 mixin(enumMixinStr_LBER_OPT_BER_TOTAL_BYTES); 5448 } 5449 } 5450 5451 5452 5453 5454 static if(!is(typeof(LBER_OPT_BER_REMAINING_BYTES))) { 5455 private enum enumMixinStr_LBER_OPT_BER_REMAINING_BYTES = `enum LBER_OPT_BER_REMAINING_BYTES = 0x03;`; 5456 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_BER_REMAINING_BYTES); }))) { 5457 mixin(enumMixinStr_LBER_OPT_BER_REMAINING_BYTES); 5458 } 5459 } 5460 5461 5462 5463 5464 static if(!is(typeof(LBER_OPT_BER_DEBUG))) { 5465 private enum enumMixinStr_LBER_OPT_BER_DEBUG = `enum LBER_OPT_BER_DEBUG = 0x02;`; 5466 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_BER_DEBUG); }))) { 5467 mixin(enumMixinStr_LBER_OPT_BER_DEBUG); 5468 } 5469 } 5470 5471 5472 5473 5474 static if(!is(typeof(LBER_OPT_BER_OPTIONS))) { 5475 private enum enumMixinStr_LBER_OPT_BER_OPTIONS = `enum LBER_OPT_BER_OPTIONS = 0x01;`; 5476 static if(is(typeof({ mixin(enumMixinStr_LBER_OPT_BER_OPTIONS); }))) { 5477 mixin(enumMixinStr_LBER_OPT_BER_OPTIONS); 5478 } 5479 } 5480 5481 5482 5483 5484 static if(!is(typeof(LBER_USE_DER))) { 5485 private enum enumMixinStr_LBER_USE_DER = `enum LBER_USE_DER = 0x01;`; 5486 static if(is(typeof({ mixin(enumMixinStr_LBER_USE_DER); }))) { 5487 mixin(enumMixinStr_LBER_USE_DER); 5488 } 5489 } 5490 5491 5492 5493 5494 static if(!is(typeof(LBER_SET))) { 5495 private enum enumMixinStr_LBER_SET = `enum LBER_SET = ( cast( ber_tag_t ) 0x31UL );`; 5496 static if(is(typeof({ mixin(enumMixinStr_LBER_SET); }))) { 5497 mixin(enumMixinStr_LBER_SET); 5498 } 5499 } 5500 5501 5502 5503 5504 static if(!is(typeof(LBER_SEQUENCE))) { 5505 private enum enumMixinStr_LBER_SEQUENCE = `enum LBER_SEQUENCE = ( cast( ber_tag_t ) 0x30UL );`; 5506 static if(is(typeof({ mixin(enumMixinStr_LBER_SEQUENCE); }))) { 5507 mixin(enumMixinStr_LBER_SEQUENCE); 5508 } 5509 } 5510 5511 5512 5513 5514 static if(!is(typeof(LBER_ENUMERATED))) { 5515 private enum enumMixinStr_LBER_ENUMERATED = `enum LBER_ENUMERATED = ( cast( ber_tag_t ) 0x0aUL );`; 5516 static if(is(typeof({ mixin(enumMixinStr_LBER_ENUMERATED); }))) { 5517 mixin(enumMixinStr_LBER_ENUMERATED); 5518 } 5519 } 5520 5521 5522 5523 5524 static if(!is(typeof(LBER_NULL))) { 5525 private enum enumMixinStr_LBER_NULL = `enum LBER_NULL = ( cast( ber_tag_t ) 0x05UL );`; 5526 static if(is(typeof({ mixin(enumMixinStr_LBER_NULL); }))) { 5527 mixin(enumMixinStr_LBER_NULL); 5528 } 5529 } 5530 5531 5532 5533 5534 static if(!is(typeof(LBER_OCTETSTRING))) { 5535 private enum enumMixinStr_LBER_OCTETSTRING = `enum LBER_OCTETSTRING = ( cast( ber_tag_t ) 0x04UL );`; 5536 static if(is(typeof({ mixin(enumMixinStr_LBER_OCTETSTRING); }))) { 5537 mixin(enumMixinStr_LBER_OCTETSTRING); 5538 } 5539 } 5540 5541 5542 5543 5544 static if(!is(typeof(LBER_BITSTRING))) { 5545 private enum enumMixinStr_LBER_BITSTRING = `enum LBER_BITSTRING = ( cast( ber_tag_t ) 0x03UL );`; 5546 static if(is(typeof({ mixin(enumMixinStr_LBER_BITSTRING); }))) { 5547 mixin(enumMixinStr_LBER_BITSTRING); 5548 } 5549 } 5550 5551 5552 5553 5554 static if(!is(typeof(LBER_INTEGER))) { 5555 private enum enumMixinStr_LBER_INTEGER = `enum LBER_INTEGER = ( cast( ber_tag_t ) 0x02UL );`; 5556 static if(is(typeof({ mixin(enumMixinStr_LBER_INTEGER); }))) { 5557 mixin(enumMixinStr_LBER_INTEGER); 5558 } 5559 } 5560 5561 5562 5563 5564 static if(!is(typeof(LBER_BOOLEAN))) { 5565 private enum enumMixinStr_LBER_BOOLEAN = `enum LBER_BOOLEAN = ( cast( ber_tag_t ) 0x01UL );`; 5566 static if(is(typeof({ mixin(enumMixinStr_LBER_BOOLEAN); }))) { 5567 mixin(enumMixinStr_LBER_BOOLEAN); 5568 } 5569 } 5570 5571 5572 5573 5574 static if(!is(typeof(LBER_DEFAULT))) { 5575 private enum enumMixinStr_LBER_DEFAULT = `enum LBER_DEFAULT = ( cast( ber_tag_t ) - 1 );`; 5576 static if(is(typeof({ mixin(enumMixinStr_LBER_DEFAULT); }))) { 5577 mixin(enumMixinStr_LBER_DEFAULT); 5578 } 5579 } 5580 5581 5582 5583 5584 static if(!is(typeof(LBER_ERROR))) { 5585 private enum enumMixinStr_LBER_ERROR = `enum LBER_ERROR = ( cast( ber_tag_t ) - 1 );`; 5586 static if(is(typeof({ mixin(enumMixinStr_LBER_ERROR); }))) { 5587 mixin(enumMixinStr_LBER_ERROR); 5588 } 5589 } 5590 5591 5592 5593 5594 static if(!is(typeof(LDAP_API_FEATURE_VIRTUAL_LIST_VIEW))) { 5595 private enum enumMixinStr_LDAP_API_FEATURE_VIRTUAL_LIST_VIEW = `enum LDAP_API_FEATURE_VIRTUAL_LIST_VIEW = 2000;`; 5596 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_VIRTUAL_LIST_VIEW); }))) { 5597 mixin(enumMixinStr_LDAP_API_FEATURE_VIRTUAL_LIST_VIEW); 5598 } 5599 } 5600 5601 5602 5603 5604 static if(!is(typeof(LBER_MORE_TAG_MASK))) { 5605 private enum enumMixinStr_LBER_MORE_TAG_MASK = `enum LBER_MORE_TAG_MASK = ( cast( ber_tag_t ) 0x80U );`; 5606 static if(is(typeof({ mixin(enumMixinStr_LBER_MORE_TAG_MASK); }))) { 5607 mixin(enumMixinStr_LBER_MORE_TAG_MASK); 5608 } 5609 } 5610 5611 5612 5613 5614 static if(!is(typeof(LBER_BIG_TAG_MASK))) { 5615 private enum enumMixinStr_LBER_BIG_TAG_MASK = `enum LBER_BIG_TAG_MASK = ( cast( ber_tag_t ) 0x1fU );`; 5616 static if(is(typeof({ mixin(enumMixinStr_LBER_BIG_TAG_MASK); }))) { 5617 mixin(enumMixinStr_LBER_BIG_TAG_MASK); 5618 } 5619 } 5620 5621 5622 5623 5624 static if(!is(typeof(LBER_ENCODING_MASK))) { 5625 private enum enumMixinStr_LBER_ENCODING_MASK = `enum LBER_ENCODING_MASK = ( cast( ber_tag_t ) 0x20U );`; 5626 static if(is(typeof({ mixin(enumMixinStr_LBER_ENCODING_MASK); }))) { 5627 mixin(enumMixinStr_LBER_ENCODING_MASK); 5628 } 5629 } 5630 5631 5632 5633 5634 static if(!is(typeof(LBER_CONSTRUCTED))) { 5635 private enum enumMixinStr_LBER_CONSTRUCTED = `enum LBER_CONSTRUCTED = ( cast( ber_tag_t ) 0x20U );`; 5636 static if(is(typeof({ mixin(enumMixinStr_LBER_CONSTRUCTED); }))) { 5637 mixin(enumMixinStr_LBER_CONSTRUCTED); 5638 } 5639 } 5640 5641 5642 5643 5644 static if(!is(typeof(LBER_PRIMITIVE))) { 5645 private enum enumMixinStr_LBER_PRIMITIVE = `enum LBER_PRIMITIVE = ( cast( ber_tag_t ) 0x00U );`; 5646 static if(is(typeof({ mixin(enumMixinStr_LBER_PRIMITIVE); }))) { 5647 mixin(enumMixinStr_LBER_PRIMITIVE); 5648 } 5649 } 5650 5651 5652 5653 5654 static if(!is(typeof(LBER_CLASS_MASK))) { 5655 private enum enumMixinStr_LBER_CLASS_MASK = `enum LBER_CLASS_MASK = ( cast( ber_tag_t ) 0xc0U );`; 5656 static if(is(typeof({ mixin(enumMixinStr_LBER_CLASS_MASK); }))) { 5657 mixin(enumMixinStr_LBER_CLASS_MASK); 5658 } 5659 } 5660 5661 5662 5663 5664 static if(!is(typeof(LBER_CLASS_PRIVATE))) { 5665 private enum enumMixinStr_LBER_CLASS_PRIVATE = `enum LBER_CLASS_PRIVATE = ( cast( ber_tag_t ) 0xc0U );`; 5666 static if(is(typeof({ mixin(enumMixinStr_LBER_CLASS_PRIVATE); }))) { 5667 mixin(enumMixinStr_LBER_CLASS_PRIVATE); 5668 } 5669 } 5670 5671 5672 5673 5674 static if(!is(typeof(LBER_CLASS_CONTEXT))) { 5675 private enum enumMixinStr_LBER_CLASS_CONTEXT = `enum LBER_CLASS_CONTEXT = ( cast( ber_tag_t ) 0x80U );`; 5676 static if(is(typeof({ mixin(enumMixinStr_LBER_CLASS_CONTEXT); }))) { 5677 mixin(enumMixinStr_LBER_CLASS_CONTEXT); 5678 } 5679 } 5680 5681 5682 5683 5684 static if(!is(typeof(LBER_CLASS_APPLICATION))) { 5685 private enum enumMixinStr_LBER_CLASS_APPLICATION = `enum LBER_CLASS_APPLICATION = ( cast( ber_tag_t ) 0x40U );`; 5686 static if(is(typeof({ mixin(enumMixinStr_LBER_CLASS_APPLICATION); }))) { 5687 mixin(enumMixinStr_LBER_CLASS_APPLICATION); 5688 } 5689 } 5690 5691 5692 5693 5694 static if(!is(typeof(LBER_CLASS_UNIVERSAL))) { 5695 private enum enumMixinStr_LBER_CLASS_UNIVERSAL = `enum LBER_CLASS_UNIVERSAL = ( cast( ber_tag_t ) 0x00U );`; 5696 static if(is(typeof({ mixin(enumMixinStr_LBER_CLASS_UNIVERSAL); }))) { 5697 mixin(enumMixinStr_LBER_CLASS_UNIVERSAL); 5698 } 5699 } 5700 5701 5702 5703 5704 5705 5706 static if(!is(typeof(LDAP_API_FEATURE_WHOAMI))) { 5707 private enum enumMixinStr_LDAP_API_FEATURE_WHOAMI = `enum LDAP_API_FEATURE_WHOAMI = 1000;`; 5708 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_WHOAMI); }))) { 5709 mixin(enumMixinStr_LDAP_API_FEATURE_WHOAMI); 5710 } 5711 } 5712 static if(!is(typeof(LDAP_API_FEATURE_PASSWD_MODIFY))) { 5713 private enum enumMixinStr_LDAP_API_FEATURE_PASSWD_MODIFY = `enum LDAP_API_FEATURE_PASSWD_MODIFY = 1000;`; 5714 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_PASSWD_MODIFY); }))) { 5715 mixin(enumMixinStr_LDAP_API_FEATURE_PASSWD_MODIFY); 5716 } 5717 } 5718 static if(!is(typeof(__GLIBC_MINOR__))) { 5719 private enum enumMixinStr___GLIBC_MINOR__ = `enum __GLIBC_MINOR__ = 30;`; 5720 static if(is(typeof({ mixin(enumMixinStr___GLIBC_MINOR__); }))) { 5721 mixin(enumMixinStr___GLIBC_MINOR__); 5722 } 5723 } 5724 5725 5726 5727 5728 static if(!is(typeof(__GLIBC__))) { 5729 private enum enumMixinStr___GLIBC__ = `enum __GLIBC__ = 2;`; 5730 static if(is(typeof({ mixin(enumMixinStr___GLIBC__); }))) { 5731 mixin(enumMixinStr___GLIBC__); 5732 } 5733 } 5734 5735 5736 5737 5738 static if(!is(typeof(__GNU_LIBRARY__))) { 5739 private enum enumMixinStr___GNU_LIBRARY__ = `enum __GNU_LIBRARY__ = 6;`; 5740 static if(is(typeof({ mixin(enumMixinStr___GNU_LIBRARY__); }))) { 5741 mixin(enumMixinStr___GNU_LIBRARY__); 5742 } 5743 } 5744 5745 5746 5747 5748 static if(!is(typeof(__GLIBC_USE_DEPRECATED_SCANF))) { 5749 private enum enumMixinStr___GLIBC_USE_DEPRECATED_SCANF = `enum __GLIBC_USE_DEPRECATED_SCANF = 0;`; 5750 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_DEPRECATED_SCANF); }))) { 5751 mixin(enumMixinStr___GLIBC_USE_DEPRECATED_SCANF); 5752 } 5753 } 5754 5755 5756 5757 5758 static if(!is(typeof(__GLIBC_USE_DEPRECATED_GETS))) { 5759 private enum enumMixinStr___GLIBC_USE_DEPRECATED_GETS = `enum __GLIBC_USE_DEPRECATED_GETS = 0;`; 5760 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); }))) { 5761 mixin(enumMixinStr___GLIBC_USE_DEPRECATED_GETS); 5762 } 5763 } 5764 5765 5766 5767 5768 static if(!is(typeof(__USE_FORTIFY_LEVEL))) { 5769 private enum enumMixinStr___USE_FORTIFY_LEVEL = `enum __USE_FORTIFY_LEVEL = 0;`; 5770 static if(is(typeof({ mixin(enumMixinStr___USE_FORTIFY_LEVEL); }))) { 5771 mixin(enumMixinStr___USE_FORTIFY_LEVEL); 5772 } 5773 } 5774 5775 5776 5777 5778 static if(!is(typeof(__USE_ATFILE))) { 5779 private enum enumMixinStr___USE_ATFILE = `enum __USE_ATFILE = 1;`; 5780 static if(is(typeof({ mixin(enumMixinStr___USE_ATFILE); }))) { 5781 mixin(enumMixinStr___USE_ATFILE); 5782 } 5783 } 5784 5785 5786 5787 5788 static if(!is(typeof(__USE_MISC))) { 5789 private enum enumMixinStr___USE_MISC = `enum __USE_MISC = 1;`; 5790 static if(is(typeof({ mixin(enumMixinStr___USE_MISC); }))) { 5791 mixin(enumMixinStr___USE_MISC); 5792 } 5793 } 5794 5795 5796 5797 5798 static if(!is(typeof(LDAP_API_FEATURE_PASSWORD_POLICY))) { 5799 private enum enumMixinStr_LDAP_API_FEATURE_PASSWORD_POLICY = `enum LDAP_API_FEATURE_PASSWORD_POLICY = 1000;`; 5800 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_PASSWORD_POLICY); }))) { 5801 mixin(enumMixinStr_LDAP_API_FEATURE_PASSWORD_POLICY); 5802 } 5803 } 5804 5805 5806 5807 5808 static if(!is(typeof(_ATFILE_SOURCE))) { 5809 private enum enumMixinStr__ATFILE_SOURCE = `enum _ATFILE_SOURCE = 1;`; 5810 static if(is(typeof({ mixin(enumMixinStr__ATFILE_SOURCE); }))) { 5811 mixin(enumMixinStr__ATFILE_SOURCE); 5812 } 5813 } 5814 5815 5816 5817 5818 static if(!is(typeof(__USE_XOPEN2K8))) { 5819 private enum enumMixinStr___USE_XOPEN2K8 = `enum __USE_XOPEN2K8 = 1;`; 5820 static if(is(typeof({ mixin(enumMixinStr___USE_XOPEN2K8); }))) { 5821 mixin(enumMixinStr___USE_XOPEN2K8); 5822 } 5823 } 5824 5825 5826 5827 5828 static if(!is(typeof(__USE_ISOC99))) { 5829 private enum enumMixinStr___USE_ISOC99 = `enum __USE_ISOC99 = 1;`; 5830 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC99); }))) { 5831 mixin(enumMixinStr___USE_ISOC99); 5832 } 5833 } 5834 5835 5836 5837 5838 static if(!is(typeof(__USE_ISOC95))) { 5839 private enum enumMixinStr___USE_ISOC95 = `enum __USE_ISOC95 = 1;`; 5840 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC95); }))) { 5841 mixin(enumMixinStr___USE_ISOC95); 5842 } 5843 } 5844 5845 5846 5847 5848 static if(!is(typeof(__USE_XOPEN2K))) { 5849 private enum enumMixinStr___USE_XOPEN2K = `enum __USE_XOPEN2K = 1;`; 5850 static if(is(typeof({ mixin(enumMixinStr___USE_XOPEN2K); }))) { 5851 mixin(enumMixinStr___USE_XOPEN2K); 5852 } 5853 } 5854 5855 5856 5857 5858 static if(!is(typeof(__USE_POSIX199506))) { 5859 private enum enumMixinStr___USE_POSIX199506 = `enum __USE_POSIX199506 = 1;`; 5860 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX199506); }))) { 5861 mixin(enumMixinStr___USE_POSIX199506); 5862 } 5863 } 5864 5865 5866 5867 5868 static if(!is(typeof(__USE_POSIX199309))) { 5869 private enum enumMixinStr___USE_POSIX199309 = `enum __USE_POSIX199309 = 1;`; 5870 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX199309); }))) { 5871 mixin(enumMixinStr___USE_POSIX199309); 5872 } 5873 } 5874 5875 5876 5877 5878 static if(!is(typeof(__USE_POSIX2))) { 5879 private enum enumMixinStr___USE_POSIX2 = `enum __USE_POSIX2 = 1;`; 5880 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX2); }))) { 5881 mixin(enumMixinStr___USE_POSIX2); 5882 } 5883 } 5884 5885 5886 5887 5888 static if(!is(typeof(__USE_POSIX))) { 5889 private enum enumMixinStr___USE_POSIX = `enum __USE_POSIX = 1;`; 5890 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX); }))) { 5891 mixin(enumMixinStr___USE_POSIX); 5892 } 5893 } 5894 5895 5896 5897 5898 static if(!is(typeof(_POSIX_C_SOURCE))) { 5899 private enum enumMixinStr__POSIX_C_SOURCE = `enum _POSIX_C_SOURCE = 200809L;`; 5900 static if(is(typeof({ mixin(enumMixinStr__POSIX_C_SOURCE); }))) { 5901 mixin(enumMixinStr__POSIX_C_SOURCE); 5902 } 5903 } 5904 5905 5906 5907 5908 static if(!is(typeof(_POSIX_SOURCE))) { 5909 private enum enumMixinStr__POSIX_SOURCE = `enum _POSIX_SOURCE = 1;`; 5910 static if(is(typeof({ mixin(enumMixinStr__POSIX_SOURCE); }))) { 5911 mixin(enumMixinStr__POSIX_SOURCE); 5912 } 5913 } 5914 5915 5916 5917 5918 static if(!is(typeof(LDAP_API_FEATURE_REFRESH))) { 5919 private enum enumMixinStr_LDAP_API_FEATURE_REFRESH = `enum LDAP_API_FEATURE_REFRESH = 1000;`; 5920 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_REFRESH); }))) { 5921 mixin(enumMixinStr_LDAP_API_FEATURE_REFRESH); 5922 } 5923 } 5924 5925 5926 5927 5928 static if(!is(typeof(__USE_POSIX_IMPLICITLY))) { 5929 private enum enumMixinStr___USE_POSIX_IMPLICITLY = `enum __USE_POSIX_IMPLICITLY = 1;`; 5930 static if(is(typeof({ mixin(enumMixinStr___USE_POSIX_IMPLICITLY); }))) { 5931 mixin(enumMixinStr___USE_POSIX_IMPLICITLY); 5932 } 5933 } 5934 5935 5936 5937 5938 static if(!is(typeof(__USE_ISOC11))) { 5939 private enum enumMixinStr___USE_ISOC11 = `enum __USE_ISOC11 = 1;`; 5940 static if(is(typeof({ mixin(enumMixinStr___USE_ISOC11); }))) { 5941 mixin(enumMixinStr___USE_ISOC11); 5942 } 5943 } 5944 5945 5946 5947 5948 static if(!is(typeof(_DEFAULT_SOURCE))) { 5949 private enum enumMixinStr__DEFAULT_SOURCE = `enum _DEFAULT_SOURCE = 1;`; 5950 static if(is(typeof({ mixin(enumMixinStr__DEFAULT_SOURCE); }))) { 5951 mixin(enumMixinStr__DEFAULT_SOURCE); 5952 } 5953 } 5954 static if(!is(typeof(_FEATURES_H))) { 5955 private enum enumMixinStr__FEATURES_H = `enum _FEATURES_H = 1;`; 5956 static if(is(typeof({ mixin(enumMixinStr__FEATURES_H); }))) { 5957 mixin(enumMixinStr__FEATURES_H); 5958 } 5959 } 5960 5961 5962 5963 5964 static if(!is(typeof(__SYSCALL_WORDSIZE))) { 5965 private enum enumMixinStr___SYSCALL_WORDSIZE = `enum __SYSCALL_WORDSIZE = 64;`; 5966 static if(is(typeof({ mixin(enumMixinStr___SYSCALL_WORDSIZE); }))) { 5967 mixin(enumMixinStr___SYSCALL_WORDSIZE); 5968 } 5969 } 5970 5971 5972 5973 5974 static if(!is(typeof(__WORDSIZE_TIME64_COMPAT32))) { 5975 private enum enumMixinStr___WORDSIZE_TIME64_COMPAT32 = `enum __WORDSIZE_TIME64_COMPAT32 = 1;`; 5976 static if(is(typeof({ mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); }))) { 5977 mixin(enumMixinStr___WORDSIZE_TIME64_COMPAT32); 5978 } 5979 } 5980 5981 5982 5983 5984 static if(!is(typeof(__WORDSIZE))) { 5985 private enum enumMixinStr___WORDSIZE = `enum __WORDSIZE = 64;`; 5986 static if(is(typeof({ mixin(enumMixinStr___WORDSIZE); }))) { 5987 mixin(enumMixinStr___WORDSIZE); 5988 } 5989 } 5990 5991 5992 5993 5994 static if(!is(typeof(_BITS_TYPES_LOCALE_T_H))) { 5995 private enum enumMixinStr__BITS_TYPES_LOCALE_T_H = `enum _BITS_TYPES_LOCALE_T_H = 1;`; 5996 static if(is(typeof({ mixin(enumMixinStr__BITS_TYPES_LOCALE_T_H); }))) { 5997 mixin(enumMixinStr__BITS_TYPES_LOCALE_T_H); 5998 } 5999 } 6000 6001 6002 6003 6004 static if(!is(typeof(_BITS_TYPES___LOCALE_T_H))) { 6005 private enum enumMixinStr__BITS_TYPES___LOCALE_T_H = `enum _BITS_TYPES___LOCALE_T_H = 1;`; 6006 static if(is(typeof({ mixin(enumMixinStr__BITS_TYPES___LOCALE_T_H); }))) { 6007 mixin(enumMixinStr__BITS_TYPES___LOCALE_T_H); 6008 } 6009 } 6010 6011 6012 6013 6014 static if(!is(typeof(__GLIBC_USE_IEC_60559_TYPES_EXT))) { 6015 private enum enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT = `enum __GLIBC_USE_IEC_60559_TYPES_EXT = 0;`; 6016 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); }))) { 6017 mixin(enumMixinStr___GLIBC_USE_IEC_60559_TYPES_EXT); 6018 } 6019 } 6020 6021 6022 6023 6024 static if(!is(typeof(__GLIBC_USE_IEC_60559_FUNCS_EXT))) { 6025 private enum enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT = `enum __GLIBC_USE_IEC_60559_FUNCS_EXT = 0;`; 6026 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); }))) { 6027 mixin(enumMixinStr___GLIBC_USE_IEC_60559_FUNCS_EXT); 6028 } 6029 } 6030 6031 6032 6033 6034 static if(!is(typeof(__GLIBC_USE_IEC_60559_BFP_EXT))) { 6035 private enum enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT = `enum __GLIBC_USE_IEC_60559_BFP_EXT = 0;`; 6036 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); }))) { 6037 mixin(enumMixinStr___GLIBC_USE_IEC_60559_BFP_EXT); 6038 } 6039 } 6040 6041 6042 6043 6044 static if(!is(typeof(__GLIBC_USE_LIB_EXT2))) { 6045 private enum enumMixinStr___GLIBC_USE_LIB_EXT2 = `enum __GLIBC_USE_LIB_EXT2 = 0;`; 6046 static if(is(typeof({ mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); }))) { 6047 mixin(enumMixinStr___GLIBC_USE_LIB_EXT2); 6048 } 6049 } 6050 6051 6052 6053 6054 static if(!is(typeof(LDAP_AUTH_NTLM_REQUEST))) { 6055 private enum enumMixinStr_LDAP_AUTH_NTLM_REQUEST = `enum LDAP_AUTH_NTLM_REQUEST = ( cast( ber_tag_t ) 0x8aU );`; 6056 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_NTLM_REQUEST); }))) { 6057 mixin(enumMixinStr_LDAP_AUTH_NTLM_REQUEST); 6058 } 6059 } 6060 6061 6062 6063 6064 static if(!is(typeof(LDAP_AUTH_NTLM_RESPONSE))) { 6065 private enum enumMixinStr_LDAP_AUTH_NTLM_RESPONSE = `enum LDAP_AUTH_NTLM_RESPONSE = ( cast( ber_tag_t ) 0x8bU );`; 6066 static if(is(typeof({ mixin(enumMixinStr_LDAP_AUTH_NTLM_RESPONSE); }))) { 6067 mixin(enumMixinStr_LDAP_AUTH_NTLM_RESPONSE); 6068 } 6069 } 6070 static if(!is(typeof(LDAP_CONST))) { 6071 private enum enumMixinStr_LDAP_CONST = `enum LDAP_CONST = const;`; 6072 static if(is(typeof({ mixin(enumMixinStr_LDAP_CONST); }))) { 6073 mixin(enumMixinStr_LDAP_CONST); 6074 } 6075 } 6076 static if(!is(typeof(_LDAP_FEATURES_H))) { 6077 private enum enumMixinStr__LDAP_FEATURES_H = `enum _LDAP_FEATURES_H = 1;`; 6078 static if(is(typeof({ mixin(enumMixinStr__LDAP_FEATURES_H); }))) { 6079 mixin(enumMixinStr__LDAP_FEATURES_H); 6080 } 6081 } 6082 6083 6084 6085 6086 static if(!is(typeof(LDAP_VENDOR_VERSION))) { 6087 private enum enumMixinStr_LDAP_VENDOR_VERSION = `enum LDAP_VENDOR_VERSION = 20448;`; 6088 static if(is(typeof({ mixin(enumMixinStr_LDAP_VENDOR_VERSION); }))) { 6089 mixin(enumMixinStr_LDAP_VENDOR_VERSION); 6090 } 6091 } 6092 6093 6094 6095 6096 static if(!is(typeof(LDAP_VENDOR_VERSION_MAJOR))) { 6097 private enum enumMixinStr_LDAP_VENDOR_VERSION_MAJOR = `enum LDAP_VENDOR_VERSION_MAJOR = 2;`; 6098 static if(is(typeof({ mixin(enumMixinStr_LDAP_VENDOR_VERSION_MAJOR); }))) { 6099 mixin(enumMixinStr_LDAP_VENDOR_VERSION_MAJOR); 6100 } 6101 } 6102 6103 6104 6105 6106 static if(!is(typeof(LDAP_VENDOR_VERSION_MINOR))) { 6107 private enum enumMixinStr_LDAP_VENDOR_VERSION_MINOR = `enum LDAP_VENDOR_VERSION_MINOR = 4;`; 6108 static if(is(typeof({ mixin(enumMixinStr_LDAP_VENDOR_VERSION_MINOR); }))) { 6109 mixin(enumMixinStr_LDAP_VENDOR_VERSION_MINOR); 6110 } 6111 } 6112 6113 6114 6115 6116 static if(!is(typeof(LDAP_VENDOR_VERSION_PATCH))) { 6117 private enum enumMixinStr_LDAP_VENDOR_VERSION_PATCH = `enum LDAP_VENDOR_VERSION_PATCH = 48;`; 6118 static if(is(typeof({ mixin(enumMixinStr_LDAP_VENDOR_VERSION_PATCH); }))) { 6119 mixin(enumMixinStr_LDAP_VENDOR_VERSION_PATCH); 6120 } 6121 } 6122 6123 6124 6125 6126 static if(!is(typeof(LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE))) { 6127 private enum enumMixinStr_LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE = `enum LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE = 1;`; 6128 static if(is(typeof({ mixin(enumMixinStr_LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE); }))) { 6129 mixin(enumMixinStr_LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE); 6130 } 6131 } 6132 6133 6134 6135 6136 static if(!is(typeof(_STDC_PREDEF_H))) { 6137 private enum enumMixinStr__STDC_PREDEF_H = `enum _STDC_PREDEF_H = 1;`; 6138 static if(is(typeof({ mixin(enumMixinStr__STDC_PREDEF_H); }))) { 6139 mixin(enumMixinStr__STDC_PREDEF_H); 6140 } 6141 } 6142 6143 6144 6145 6146 static if(!is(typeof(_STRING_H))) { 6147 private enum enumMixinStr__STRING_H = `enum _STRING_H = 1;`; 6148 static if(is(typeof({ mixin(enumMixinStr__STRING_H); }))) { 6149 mixin(enumMixinStr__STRING_H); 6150 } 6151 } 6152 static if(!is(typeof(_STRINGS_H))) { 6153 private enum enumMixinStr__STRINGS_H = `enum _STRINGS_H = 1;`; 6154 static if(is(typeof({ mixin(enumMixinStr__STRINGS_H); }))) { 6155 mixin(enumMixinStr__STRINGS_H); 6156 } 6157 } 6158 6159 6160 6161 6162 static if(!is(typeof(_SYS_CDEFS_H))) { 6163 private enum enumMixinStr__SYS_CDEFS_H = `enum _SYS_CDEFS_H = 1;`; 6164 static if(is(typeof({ mixin(enumMixinStr__SYS_CDEFS_H); }))) { 6165 mixin(enumMixinStr__SYS_CDEFS_H); 6166 } 6167 } 6168 static if(!is(typeof(__THROW))) { 6169 private enum enumMixinStr___THROW = `enum __THROW = __attribute__ ( ( __nothrow__ ) );`; 6170 static if(is(typeof({ mixin(enumMixinStr___THROW); }))) { 6171 mixin(enumMixinStr___THROW); 6172 } 6173 } 6174 6175 6176 6177 6178 static if(!is(typeof(__THROWNL))) { 6179 private enum enumMixinStr___THROWNL = `enum __THROWNL = __attribute__ ( ( __nothrow__ ) );`; 6180 static if(is(typeof({ mixin(enumMixinStr___THROWNL); }))) { 6181 mixin(enumMixinStr___THROWNL); 6182 } 6183 } 6184 static if(!is(typeof(__ptr_t))) { 6185 private enum enumMixinStr___ptr_t = `enum __ptr_t = void *;`; 6186 static if(is(typeof({ mixin(enumMixinStr___ptr_t); }))) { 6187 mixin(enumMixinStr___ptr_t); 6188 } 6189 } 6190 static if(!is(typeof(__flexarr))) { 6191 private enum enumMixinStr___flexarr = `enum __flexarr = [ ];`; 6192 static if(is(typeof({ mixin(enumMixinStr___flexarr); }))) { 6193 mixin(enumMixinStr___flexarr); 6194 } 6195 } 6196 6197 6198 6199 6200 static if(!is(typeof(__glibc_c99_flexarr_available))) { 6201 private enum enumMixinStr___glibc_c99_flexarr_available = `enum __glibc_c99_flexarr_available = 1;`; 6202 static if(is(typeof({ mixin(enumMixinStr___glibc_c99_flexarr_available); }))) { 6203 mixin(enumMixinStr___glibc_c99_flexarr_available); 6204 } 6205 } 6206 static if(!is(typeof(__attribute_malloc__))) { 6207 private enum enumMixinStr___attribute_malloc__ = `enum __attribute_malloc__ = __attribute__ ( ( __malloc__ ) );`; 6208 static if(is(typeof({ mixin(enumMixinStr___attribute_malloc__); }))) { 6209 mixin(enumMixinStr___attribute_malloc__); 6210 } 6211 } 6212 6213 6214 6215 6216 6217 6218 static if(!is(typeof(__attribute_pure__))) { 6219 private enum enumMixinStr___attribute_pure__ = `enum __attribute_pure__ = __attribute__ ( ( __pure__ ) );`; 6220 static if(is(typeof({ mixin(enumMixinStr___attribute_pure__); }))) { 6221 mixin(enumMixinStr___attribute_pure__); 6222 } 6223 } 6224 6225 6226 6227 6228 static if(!is(typeof(__attribute_const__))) { 6229 private enum enumMixinStr___attribute_const__ = `enum __attribute_const__ = __attribute__ ( cast( __const__ ) );`; 6230 static if(is(typeof({ mixin(enumMixinStr___attribute_const__); }))) { 6231 mixin(enumMixinStr___attribute_const__); 6232 } 6233 } 6234 6235 6236 6237 6238 static if(!is(typeof(__attribute_used__))) { 6239 private enum enumMixinStr___attribute_used__ = `enum __attribute_used__ = __attribute__ ( ( __used__ ) );`; 6240 static if(is(typeof({ mixin(enumMixinStr___attribute_used__); }))) { 6241 mixin(enumMixinStr___attribute_used__); 6242 } 6243 } 6244 6245 6246 6247 6248 static if(!is(typeof(__attribute_noinline__))) { 6249 private enum enumMixinStr___attribute_noinline__ = `enum __attribute_noinline__ = __attribute__ ( ( __noinline__ ) );`; 6250 static if(is(typeof({ mixin(enumMixinStr___attribute_noinline__); }))) { 6251 mixin(enumMixinStr___attribute_noinline__); 6252 } 6253 } 6254 6255 6256 6257 6258 static if(!is(typeof(__attribute_deprecated__))) { 6259 private enum enumMixinStr___attribute_deprecated__ = `enum __attribute_deprecated__ = __attribute__ ( ( __deprecated__ ) );`; 6260 static if(is(typeof({ mixin(enumMixinStr___attribute_deprecated__); }))) { 6261 mixin(enumMixinStr___attribute_deprecated__); 6262 } 6263 } 6264 static if(!is(typeof(__attribute_warn_unused_result__))) { 6265 private enum enumMixinStr___attribute_warn_unused_result__ = `enum __attribute_warn_unused_result__ = __attribute__ ( ( __warn_unused_result__ ) );`; 6266 static if(is(typeof({ mixin(enumMixinStr___attribute_warn_unused_result__); }))) { 6267 mixin(enumMixinStr___attribute_warn_unused_result__); 6268 } 6269 } 6270 6271 6272 6273 6274 6275 6276 static if(!is(typeof(__always_inline))) { 6277 private enum enumMixinStr___always_inline = `enum __always_inline = __inline __attribute__ ( ( __always_inline__ ) );`; 6278 static if(is(typeof({ mixin(enumMixinStr___always_inline); }))) { 6279 mixin(enumMixinStr___always_inline); 6280 } 6281 } 6282 6283 6284 6285 6286 6287 6288 static if(!is(typeof(__extern_inline))) { 6289 private enum enumMixinStr___extern_inline = `enum __extern_inline = extern __inline __attribute__ ( ( __gnu_inline__ ) );`; 6290 static if(is(typeof({ mixin(enumMixinStr___extern_inline); }))) { 6291 mixin(enumMixinStr___extern_inline); 6292 } 6293 } 6294 6295 6296 6297 6298 static if(!is(typeof(__extern_always_inline))) { 6299 private enum enumMixinStr___extern_always_inline = `enum __extern_always_inline = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) );`; 6300 static if(is(typeof({ mixin(enumMixinStr___extern_always_inline); }))) { 6301 mixin(enumMixinStr___extern_always_inline); 6302 } 6303 } 6304 6305 6306 6307 6308 static if(!is(typeof(__fortify_function))) { 6309 private enum enumMixinStr___fortify_function = `enum __fortify_function = extern __inline __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( __gnu_inline__ ) ) ;`; 6310 static if(is(typeof({ mixin(enumMixinStr___fortify_function); }))) { 6311 mixin(enumMixinStr___fortify_function); 6312 } 6313 } 6314 6315 6316 6317 6318 static if(!is(typeof(__restrict_arr))) { 6319 private enum enumMixinStr___restrict_arr = `enum __restrict_arr = __restrict;`; 6320 static if(is(typeof({ mixin(enumMixinStr___restrict_arr); }))) { 6321 mixin(enumMixinStr___restrict_arr); 6322 } 6323 } 6324 static if(!is(typeof(__glibc_has_include))) { 6325 private enum enumMixinStr___glibc_has_include = `enum __glibc_has_include = __has_include;`; 6326 static if(is(typeof({ mixin(enumMixinStr___glibc_has_include); }))) { 6327 mixin(enumMixinStr___glibc_has_include); 6328 } 6329 } 6330 static if(!is(typeof(__HAVE_GENERIC_SELECTION))) { 6331 private enum enumMixinStr___HAVE_GENERIC_SELECTION = `enum __HAVE_GENERIC_SELECTION = 1;`; 6332 static if(is(typeof({ mixin(enumMixinStr___HAVE_GENERIC_SELECTION); }))) { 6333 mixin(enumMixinStr___HAVE_GENERIC_SELECTION); 6334 } 6335 } 6336 6337 6338 6339 6340 6341 6342 static if(!is(typeof(NULL))) { 6343 private enum enumMixinStr_NULL = `enum NULL = ( cast( void * ) 0 );`; 6344 static if(is(typeof({ mixin(enumMixinStr_NULL); }))) { 6345 mixin(enumMixinStr_NULL); 6346 } 6347 } 6348 6349 }