This file is indexed.

/usr/lib/python3/dist-packages/gpg/gpgme.py is in python3-gpg 1.10.0-1ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_gpgme')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_gpgme')
    _gpgme = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_gpgme', [dirname(__file__)])
        except ImportError:
            import _gpgme
            return _gpgme
        try:
            _mod = imp.load_module('_gpgme', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _gpgme = swig_import_helper()
    del swig_import_helper
else:
    import _gpgme
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0


def gpgme_op_keylist_start(*args) -> "gpgme_error_t":
    """gpgme_op_keylist_start(ctx, pattern, secret_only=0) -> gpgme_error_t"""
    return _gpgme.gpgme_op_keylist_start(*args)

def gpgme_data_seek(*args) -> "off_t":
    """gpgme_data_seek(dh, offset, whence) -> off_t"""
    return _gpgme.gpgme_data_seek(*args)
class _gpgme_sig_notation(_object):
    """Proxy of C _gpgme_sig_notation struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_sig_notation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_sig_notation, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _gpgme._gpgme_sig_notation_name_set
    __swig_getmethods__["name"] = _gpgme._gpgme_sig_notation_name_get
    if _newclass:
        name = _swig_property(_gpgme._gpgme_sig_notation_name_get, _gpgme._gpgme_sig_notation_name_set)
    __swig_setmethods__["value"] = _gpgme._gpgme_sig_notation_value_set
    __swig_getmethods__["value"] = _gpgme._gpgme_sig_notation_value_get
    if _newclass:
        value = _swig_property(_gpgme._gpgme_sig_notation_value_get, _gpgme._gpgme_sig_notation_value_set)
    __swig_setmethods__["flags"] = _gpgme._gpgme_sig_notation_flags_set
    __swig_getmethods__["flags"] = _gpgme._gpgme_sig_notation_flags_get
    if _newclass:
        flags = _swig_property(_gpgme._gpgme_sig_notation_flags_get, _gpgme._gpgme_sig_notation_flags_set)
    __swig_setmethods__["human_readable"] = _gpgme._gpgme_sig_notation_human_readable_set
    __swig_getmethods__["human_readable"] = _gpgme._gpgme_sig_notation_human_readable_get
    if _newclass:
        human_readable = _swig_property(_gpgme._gpgme_sig_notation_human_readable_get, _gpgme._gpgme_sig_notation_human_readable_set)
    __swig_setmethods__["critical"] = _gpgme._gpgme_sig_notation_critical_set
    __swig_getmethods__["critical"] = _gpgme._gpgme_sig_notation_critical_get
    if _newclass:
        critical = _swig_property(_gpgme._gpgme_sig_notation_critical_get, _gpgme._gpgme_sig_notation_critical_set)

    def __init__(self):
        """__init__(self) -> _gpgme_sig_notation"""
        this = _gpgme.new__gpgme_sig_notation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_sig_notation
    __del__ = lambda self: None
_gpgme_sig_notation_swigregister = _gpgme._gpgme_sig_notation_swigregister
_gpgme_sig_notation_swigregister(_gpgme_sig_notation)

BUILD_REVISION = _gpgme.BUILD_REVISION
BUILD_TIMESTAMP = _gpgme.BUILD_TIMESTAMP
ENABLE_UISERVER = _gpgme.ENABLE_UISERVER
GPGME_LIBASSUAN_VERSION = _gpgme.GPGME_LIBASSUAN_VERSION
HAVE_ARGP_H = _gpgme.HAVE_ARGP_H
HAVE_CXX11 = _gpgme.HAVE_CXX11
HAVE_DECL_TTYNAME_R = _gpgme.HAVE_DECL_TTYNAME_R
HAVE_DLFCN_H = _gpgme.HAVE_DLFCN_H
HAVE_ERROR_T = _gpgme.HAVE_ERROR_T
HAVE_FSEEKO = _gpgme.HAVE_FSEEKO
HAVE_GETEGID = _gpgme.HAVE_GETEGID
HAVE_GETGID = _gpgme.HAVE_GETGID
HAVE_INTTYPES_H = _gpgme.HAVE_INTTYPES_H
HAVE_LOCALE_H = _gpgme.HAVE_LOCALE_H
HAVE_MEMORY_H = _gpgme.HAVE_MEMORY_H
HAVE_POSIXDECL_TTYNAME_R = _gpgme.HAVE_POSIXDECL_TTYNAME_R
HAVE_SETENV = _gpgme.HAVE_SETENV
HAVE_SETLOCALE = _gpgme.HAVE_SETLOCALE
HAVE_STDINT_H = _gpgme.HAVE_STDINT_H
HAVE_STDLIB_H = _gpgme.HAVE_STDLIB_H
HAVE_STPCPY = _gpgme.HAVE_STPCPY
HAVE_STRINGS_H = _gpgme.HAVE_STRINGS_H
HAVE_STRING_H = _gpgme.HAVE_STRING_H
HAVE_SYS_SELECT_H = _gpgme.HAVE_SYS_SELECT_H
HAVE_SYS_STAT_H = _gpgme.HAVE_SYS_STAT_H
HAVE_SYS_TIME_H = _gpgme.HAVE_SYS_TIME_H
HAVE_SYS_TYPES_H = _gpgme.HAVE_SYS_TYPES_H
HAVE_SYS_UIO_H = _gpgme.HAVE_SYS_UIO_H
HAVE_THREAD_SAFE_GETENV = _gpgme.HAVE_THREAD_SAFE_GETENV
HAVE_TIMEGM = _gpgme.HAVE_TIMEGM
HAVE_TLS = _gpgme.HAVE_TLS
HAVE_TTYNAME_R = _gpgme.HAVE_TTYNAME_R
HAVE_UINTPTR_T = _gpgme.HAVE_UINTPTR_T
HAVE_UNISTD_H = _gpgme.HAVE_UNISTD_H
LT_OBJDIR = _gpgme.LT_OBJDIR
PACKAGE = _gpgme.PACKAGE
PACKAGE_BUGREPORT = _gpgme.PACKAGE_BUGREPORT
PACKAGE_NAME = _gpgme.PACKAGE_NAME
PACKAGE_STRING = _gpgme.PACKAGE_STRING
PACKAGE_TARNAME = _gpgme.PACKAGE_TARNAME
PACKAGE_URL = _gpgme.PACKAGE_URL
PACKAGE_VERSION = _gpgme.PACKAGE_VERSION
PATHSEP_C = _gpgme.PATHSEP_C
DIRSEP_C = _gpgme.DIRSEP_C
DIRSEP_S = _gpgme.DIRSEP_S
SIZEOF_UNSIGNED_INT = _gpgme.SIZEOF_UNSIGNED_INT
STDC_HEADERS = _gpgme.STDC_HEADERS
USE_DESCRIPTOR_PASSING = _gpgme.USE_DESCRIPTOR_PASSING
USE_LINUX_GETDENTS = _gpgme.USE_LINUX_GETDENTS
_ALL_SOURCE = _gpgme._ALL_SOURCE
_GNU_SOURCE = _gpgme._GNU_SOURCE
_POSIX_PTHREAD_SEMANTICS = _gpgme._POSIX_PTHREAD_SEMANTICS
_TANDEM_SOURCE = _gpgme._TANDEM_SOURCE
__EXTENSIONS__ = _gpgme.__EXTENSIONS__
VERSION = _gpgme.VERSION
_DARWIN_USE_64_BIT_INODE = _gpgme._DARWIN_USE_64_BIT_INODE
_REENTRANT = _gpgme._REENTRANT
GPG_ERR_ENABLE_ERRNO_MACROS = _gpgme.GPG_ERR_ENABLE_ERRNO_MACROS
CRIGHTBLURB = _gpgme.CRIGHTBLURB
GPGME_VERSION = _gpgme.GPGME_VERSION
GPGME_VERSION_NUMBER = _gpgme.GPGME_VERSION_NUMBER

def gpgme_err_make(source: 'gpgme_err_source_t', code: 'gpgme_err_code_t') -> "gpgme_error_t":
    """gpgme_err_make(source, code) -> gpgme_error_t"""
    return _gpgme.gpgme_err_make(source, code)

def gpgme_error(code: 'gpgme_err_code_t') -> "gpgme_error_t":
    """gpgme_error(code) -> gpgme_error_t"""
    return _gpgme.gpgme_error(code)

def gpgme_err_code(err: 'gpgme_error_t') -> "gpgme_err_code_t":
    """gpgme_err_code(err) -> gpgme_err_code_t"""
    return _gpgme.gpgme_err_code(err)

def gpgme_err_source(err: 'gpgme_error_t') -> "gpgme_err_source_t":
    """gpgme_err_source(err) -> gpgme_err_source_t"""
    return _gpgme.gpgme_err_source(err)

def gpgme_strerror(err: 'gpgme_error_t') -> "char const *":
    """gpgme_strerror(err) -> char const *"""
    return _gpgme.gpgme_strerror(err)

def gpgme_strerror_r(err: 'gpg_error_t', buf: 'char *') -> "size_t":
    """gpgme_strerror_r(err, buf) -> int"""
    return _gpgme.gpgme_strerror_r(err, buf)

def gpgme_strsource(err: 'gpgme_error_t') -> "char const *":
    """gpgme_strsource(err) -> char const *"""
    return _gpgme.gpgme_strsource(err)

def gpgme_err_code_from_errno(err: 'int') -> "gpgme_err_code_t":
    """gpgme_err_code_from_errno(err) -> gpgme_err_code_t"""
    return _gpgme.gpgme_err_code_from_errno(err)

def gpgme_err_code_to_errno(code: 'gpgme_err_code_t') -> "int":
    """gpgme_err_code_to_errno(code) -> int"""
    return _gpgme.gpgme_err_code_to_errno(code)

def gpgme_err_code_from_syserror() -> "gpgme_err_code_t":
    """gpgme_err_code_from_syserror() -> gpgme_err_code_t"""
    return _gpgme.gpgme_err_code_from_syserror()

def gpgme_err_set_errno(err: 'int') -> "void":
    """gpgme_err_set_errno(err)"""
    return _gpgme.gpgme_err_set_errno(err)

def gpgme_err_make_from_errno(source: 'gpgme_err_source_t', err: 'int') -> "gpgme_error_t":
    """gpgme_err_make_from_errno(source, err) -> gpgme_error_t"""
    return _gpgme.gpgme_err_make_from_errno(source, err)

def gpgme_error_from_errno(err: 'int') -> "gpgme_error_t":
    """gpgme_error_from_errno(err) -> gpgme_error_t"""
    return _gpgme.gpgme_error_from_errno(err)

def gpgme_error_from_syserror() -> "gpgme_error_t":
    """gpgme_error_from_syserror() -> gpgme_error_t"""
    return _gpgme.gpgme_error_from_syserror()
GPGME_DATA_ENCODING_NONE = _gpgme.GPGME_DATA_ENCODING_NONE
GPGME_DATA_ENCODING_BINARY = _gpgme.GPGME_DATA_ENCODING_BINARY
GPGME_DATA_ENCODING_BASE64 = _gpgme.GPGME_DATA_ENCODING_BASE64
GPGME_DATA_ENCODING_ARMOR = _gpgme.GPGME_DATA_ENCODING_ARMOR
GPGME_DATA_ENCODING_URL = _gpgme.GPGME_DATA_ENCODING_URL
GPGME_DATA_ENCODING_URLESC = _gpgme.GPGME_DATA_ENCODING_URLESC
GPGME_DATA_ENCODING_URL0 = _gpgme.GPGME_DATA_ENCODING_URL0
GPGME_DATA_ENCODING_MIME = _gpgme.GPGME_DATA_ENCODING_MIME
GPGME_DATA_TYPE_INVALID = _gpgme.GPGME_DATA_TYPE_INVALID
GPGME_DATA_TYPE_UNKNOWN = _gpgme.GPGME_DATA_TYPE_UNKNOWN
GPGME_DATA_TYPE_PGP_SIGNED = _gpgme.GPGME_DATA_TYPE_PGP_SIGNED
GPGME_DATA_TYPE_PGP_ENCRYPTED = _gpgme.GPGME_DATA_TYPE_PGP_ENCRYPTED
GPGME_DATA_TYPE_PGP_OTHER = _gpgme.GPGME_DATA_TYPE_PGP_OTHER
GPGME_DATA_TYPE_PGP_KEY = _gpgme.GPGME_DATA_TYPE_PGP_KEY
GPGME_DATA_TYPE_PGP_SIGNATURE = _gpgme.GPGME_DATA_TYPE_PGP_SIGNATURE
GPGME_DATA_TYPE_CMS_SIGNED = _gpgme.GPGME_DATA_TYPE_CMS_SIGNED
GPGME_DATA_TYPE_CMS_ENCRYPTED = _gpgme.GPGME_DATA_TYPE_CMS_ENCRYPTED
GPGME_DATA_TYPE_CMS_OTHER = _gpgme.GPGME_DATA_TYPE_CMS_OTHER
GPGME_DATA_TYPE_X509_CERT = _gpgme.GPGME_DATA_TYPE_X509_CERT
GPGME_DATA_TYPE_PKCS12 = _gpgme.GPGME_DATA_TYPE_PKCS12
GPGME_PK_RSA = _gpgme.GPGME_PK_RSA
GPGME_PK_RSA_E = _gpgme.GPGME_PK_RSA_E
GPGME_PK_RSA_S = _gpgme.GPGME_PK_RSA_S
GPGME_PK_ELG_E = _gpgme.GPGME_PK_ELG_E
GPGME_PK_DSA = _gpgme.GPGME_PK_DSA
GPGME_PK_ECC = _gpgme.GPGME_PK_ECC
GPGME_PK_ELG = _gpgme.GPGME_PK_ELG
GPGME_PK_ECDSA = _gpgme.GPGME_PK_ECDSA
GPGME_PK_ECDH = _gpgme.GPGME_PK_ECDH
GPGME_PK_EDDSA = _gpgme.GPGME_PK_EDDSA
GPGME_MD_NONE = _gpgme.GPGME_MD_NONE
GPGME_MD_MD5 = _gpgme.GPGME_MD_MD5
GPGME_MD_SHA1 = _gpgme.GPGME_MD_SHA1
GPGME_MD_RMD160 = _gpgme.GPGME_MD_RMD160
GPGME_MD_MD2 = _gpgme.GPGME_MD_MD2
GPGME_MD_TIGER = _gpgme.GPGME_MD_TIGER
GPGME_MD_HAVAL = _gpgme.GPGME_MD_HAVAL
GPGME_MD_SHA256 = _gpgme.GPGME_MD_SHA256
GPGME_MD_SHA384 = _gpgme.GPGME_MD_SHA384
GPGME_MD_SHA512 = _gpgme.GPGME_MD_SHA512
GPGME_MD_SHA224 = _gpgme.GPGME_MD_SHA224
GPGME_MD_MD4 = _gpgme.GPGME_MD_MD4
GPGME_MD_CRC32 = _gpgme.GPGME_MD_CRC32
GPGME_MD_CRC32_RFC1510 = _gpgme.GPGME_MD_CRC32_RFC1510
GPGME_MD_CRC24_RFC2440 = _gpgme.GPGME_MD_CRC24_RFC2440
GPGME_SIG_MODE_NORMAL = _gpgme.GPGME_SIG_MODE_NORMAL
GPGME_SIG_MODE_DETACH = _gpgme.GPGME_SIG_MODE_DETACH
GPGME_SIG_MODE_CLEAR = _gpgme.GPGME_SIG_MODE_CLEAR
GPGME_VALIDITY_UNKNOWN = _gpgme.GPGME_VALIDITY_UNKNOWN
GPGME_VALIDITY_UNDEFINED = _gpgme.GPGME_VALIDITY_UNDEFINED
GPGME_VALIDITY_NEVER = _gpgme.GPGME_VALIDITY_NEVER
GPGME_VALIDITY_MARGINAL = _gpgme.GPGME_VALIDITY_MARGINAL
GPGME_VALIDITY_FULL = _gpgme.GPGME_VALIDITY_FULL
GPGME_VALIDITY_ULTIMATE = _gpgme.GPGME_VALIDITY_ULTIMATE
GPGME_TOFU_POLICY_NONE = _gpgme.GPGME_TOFU_POLICY_NONE
GPGME_TOFU_POLICY_AUTO = _gpgme.GPGME_TOFU_POLICY_AUTO
GPGME_TOFU_POLICY_GOOD = _gpgme.GPGME_TOFU_POLICY_GOOD
GPGME_TOFU_POLICY_UNKNOWN = _gpgme.GPGME_TOFU_POLICY_UNKNOWN
GPGME_TOFU_POLICY_BAD = _gpgme.GPGME_TOFU_POLICY_BAD
GPGME_TOFU_POLICY_ASK = _gpgme.GPGME_TOFU_POLICY_ASK
GPGME_KEYORG_UNKNOWN = _gpgme.GPGME_KEYORG_UNKNOWN
GPGME_KEYORG_KS = _gpgme.GPGME_KEYORG_KS
GPGME_KEYORG_DANE = _gpgme.GPGME_KEYORG_DANE
GPGME_KEYORG_WKD = _gpgme.GPGME_KEYORG_WKD
GPGME_KEYORG_URL = _gpgme.GPGME_KEYORG_URL
GPGME_KEYORG_FILE = _gpgme.GPGME_KEYORG_FILE
GPGME_KEYORG_SELF = _gpgme.GPGME_KEYORG_SELF
GPGME_KEYORG_OTHER = _gpgme.GPGME_KEYORG_OTHER
GPGME_PROTOCOL_OpenPGP = _gpgme.GPGME_PROTOCOL_OpenPGP
GPGME_PROTOCOL_CMS = _gpgme.GPGME_PROTOCOL_CMS
GPGME_PROTOCOL_GPGCONF = _gpgme.GPGME_PROTOCOL_GPGCONF
GPGME_PROTOCOL_ASSUAN = _gpgme.GPGME_PROTOCOL_ASSUAN
GPGME_PROTOCOL_G13 = _gpgme.GPGME_PROTOCOL_G13
GPGME_PROTOCOL_UISERVER = _gpgme.GPGME_PROTOCOL_UISERVER
GPGME_PROTOCOL_SPAWN = _gpgme.GPGME_PROTOCOL_SPAWN
GPGME_PROTOCOL_DEFAULT = _gpgme.GPGME_PROTOCOL_DEFAULT
GPGME_PROTOCOL_UNKNOWN = _gpgme.GPGME_PROTOCOL_UNKNOWN
GPGME_KEYLIST_MODE_LOCAL = _gpgme.GPGME_KEYLIST_MODE_LOCAL
GPGME_KEYLIST_MODE_EXTERN = _gpgme.GPGME_KEYLIST_MODE_EXTERN
GPGME_KEYLIST_MODE_SIGS = _gpgme.GPGME_KEYLIST_MODE_SIGS
GPGME_KEYLIST_MODE_SIG_NOTATIONS = _gpgme.GPGME_KEYLIST_MODE_SIG_NOTATIONS
GPGME_KEYLIST_MODE_WITH_SECRET = _gpgme.GPGME_KEYLIST_MODE_WITH_SECRET
GPGME_KEYLIST_MODE_WITH_TOFU = _gpgme.GPGME_KEYLIST_MODE_WITH_TOFU
GPGME_KEYLIST_MODE_EPHEMERAL = _gpgme.GPGME_KEYLIST_MODE_EPHEMERAL
GPGME_KEYLIST_MODE_VALIDATE = _gpgme.GPGME_KEYLIST_MODE_VALIDATE
GPGME_PINENTRY_MODE_DEFAULT = _gpgme.GPGME_PINENTRY_MODE_DEFAULT
GPGME_PINENTRY_MODE_ASK = _gpgme.GPGME_PINENTRY_MODE_ASK
GPGME_PINENTRY_MODE_CANCEL = _gpgme.GPGME_PINENTRY_MODE_CANCEL
GPGME_PINENTRY_MODE_ERROR = _gpgme.GPGME_PINENTRY_MODE_ERROR
GPGME_PINENTRY_MODE_LOOPBACK = _gpgme.GPGME_PINENTRY_MODE_LOOPBACK
GPGME_EXPORT_MODE_EXTERN = _gpgme.GPGME_EXPORT_MODE_EXTERN
GPGME_EXPORT_MODE_MINIMAL = _gpgme.GPGME_EXPORT_MODE_MINIMAL
GPGME_EXPORT_MODE_SECRET = _gpgme.GPGME_EXPORT_MODE_SECRET
GPGME_EXPORT_MODE_RAW = _gpgme.GPGME_EXPORT_MODE_RAW
GPGME_EXPORT_MODE_PKCS12 = _gpgme.GPGME_EXPORT_MODE_PKCS12
GPGME_AUDITLOG_HTML = _gpgme.GPGME_AUDITLOG_HTML
GPGME_AUDITLOG_WITH_HELP = _gpgme.GPGME_AUDITLOG_WITH_HELP
GPGME_SIG_NOTATION_HUMAN_READABLE = _gpgme.GPGME_SIG_NOTATION_HUMAN_READABLE
GPGME_SIG_NOTATION_CRITICAL = _gpgme.GPGME_SIG_NOTATION_CRITICAL
class _gpgme_engine_info(_object):
    """Proxy of C _gpgme_engine_info struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_engine_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_engine_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["protocol"] = _gpgme._gpgme_engine_info_protocol_set
    __swig_getmethods__["protocol"] = _gpgme._gpgme_engine_info_protocol_get
    if _newclass:
        protocol = _swig_property(_gpgme._gpgme_engine_info_protocol_get, _gpgme._gpgme_engine_info_protocol_set)
    __swig_setmethods__["file_name"] = _gpgme._gpgme_engine_info_file_name_set
    __swig_getmethods__["file_name"] = _gpgme._gpgme_engine_info_file_name_get
    if _newclass:
        file_name = _swig_property(_gpgme._gpgme_engine_info_file_name_get, _gpgme._gpgme_engine_info_file_name_set)
    __swig_setmethods__["version"] = _gpgme._gpgme_engine_info_version_set
    __swig_getmethods__["version"] = _gpgme._gpgme_engine_info_version_get
    if _newclass:
        version = _swig_property(_gpgme._gpgme_engine_info_version_get, _gpgme._gpgme_engine_info_version_set)
    __swig_setmethods__["req_version"] = _gpgme._gpgme_engine_info_req_version_set
    __swig_getmethods__["req_version"] = _gpgme._gpgme_engine_info_req_version_get
    if _newclass:
        req_version = _swig_property(_gpgme._gpgme_engine_info_req_version_get, _gpgme._gpgme_engine_info_req_version_set)
    __swig_setmethods__["home_dir"] = _gpgme._gpgme_engine_info_home_dir_set
    __swig_getmethods__["home_dir"] = _gpgme._gpgme_engine_info_home_dir_get
    if _newclass:
        home_dir = _swig_property(_gpgme._gpgme_engine_info_home_dir_get, _gpgme._gpgme_engine_info_home_dir_set)

    def __init__(self):
        """__init__(self) -> _gpgme_engine_info"""
        this = _gpgme.new__gpgme_engine_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_engine_info
    __del__ = lambda self: None
_gpgme_engine_info_swigregister = _gpgme._gpgme_engine_info_swigregister
_gpgme_engine_info_swigregister(_gpgme_engine_info)

class _gpgme_tofu_info(_object):
    """Proxy of C _gpgme_tofu_info struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_tofu_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_tofu_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["validity"] = _gpgme._gpgme_tofu_info_validity_set
    __swig_getmethods__["validity"] = _gpgme._gpgme_tofu_info_validity_get
    if _newclass:
        validity = _swig_property(_gpgme._gpgme_tofu_info_validity_get, _gpgme._gpgme_tofu_info_validity_set)
    __swig_setmethods__["policy"] = _gpgme._gpgme_tofu_info_policy_set
    __swig_getmethods__["policy"] = _gpgme._gpgme_tofu_info_policy_get
    if _newclass:
        policy = _swig_property(_gpgme._gpgme_tofu_info_policy_get, _gpgme._gpgme_tofu_info_policy_set)
    __swig_setmethods__["_rfu"] = _gpgme._gpgme_tofu_info__rfu_set
    __swig_getmethods__["_rfu"] = _gpgme._gpgme_tofu_info__rfu_get
    if _newclass:
        _rfu = _swig_property(_gpgme._gpgme_tofu_info__rfu_get, _gpgme._gpgme_tofu_info__rfu_set)
    __swig_setmethods__["signcount"] = _gpgme._gpgme_tofu_info_signcount_set
    __swig_getmethods__["signcount"] = _gpgme._gpgme_tofu_info_signcount_get
    if _newclass:
        signcount = _swig_property(_gpgme._gpgme_tofu_info_signcount_get, _gpgme._gpgme_tofu_info_signcount_set)
    __swig_setmethods__["encrcount"] = _gpgme._gpgme_tofu_info_encrcount_set
    __swig_getmethods__["encrcount"] = _gpgme._gpgme_tofu_info_encrcount_get
    if _newclass:
        encrcount = _swig_property(_gpgme._gpgme_tofu_info_encrcount_get, _gpgme._gpgme_tofu_info_encrcount_set)
    __swig_setmethods__["signfirst"] = _gpgme._gpgme_tofu_info_signfirst_set
    __swig_getmethods__["signfirst"] = _gpgme._gpgme_tofu_info_signfirst_get
    if _newclass:
        signfirst = _swig_property(_gpgme._gpgme_tofu_info_signfirst_get, _gpgme._gpgme_tofu_info_signfirst_set)
    __swig_setmethods__["signlast"] = _gpgme._gpgme_tofu_info_signlast_set
    __swig_getmethods__["signlast"] = _gpgme._gpgme_tofu_info_signlast_get
    if _newclass:
        signlast = _swig_property(_gpgme._gpgme_tofu_info_signlast_get, _gpgme._gpgme_tofu_info_signlast_set)
    __swig_setmethods__["encrfirst"] = _gpgme._gpgme_tofu_info_encrfirst_set
    __swig_getmethods__["encrfirst"] = _gpgme._gpgme_tofu_info_encrfirst_get
    if _newclass:
        encrfirst = _swig_property(_gpgme._gpgme_tofu_info_encrfirst_get, _gpgme._gpgme_tofu_info_encrfirst_set)
    __swig_setmethods__["encrlast"] = _gpgme._gpgme_tofu_info_encrlast_set
    __swig_getmethods__["encrlast"] = _gpgme._gpgme_tofu_info_encrlast_get
    if _newclass:
        encrlast = _swig_property(_gpgme._gpgme_tofu_info_encrlast_get, _gpgme._gpgme_tofu_info_encrlast_set)
    __swig_setmethods__["description"] = _gpgme._gpgme_tofu_info_description_set
    __swig_getmethods__["description"] = _gpgme._gpgme_tofu_info_description_get
    if _newclass:
        description = _swig_property(_gpgme._gpgme_tofu_info_description_get, _gpgme._gpgme_tofu_info_description_set)

    def __repr__(self):
        names = [name for name in dir(self)
            if not name.startswith("_") and name != "this"]
        props = ", ".join(("{}={!r}".format(name, getattr(self, name))
            for name in names)
        )
        return "TofuInfo({})".format(props)


    def __init__(self):
        """__init__(self) -> _gpgme_tofu_info"""
        this = _gpgme.new__gpgme_tofu_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_tofu_info
    __del__ = lambda self: None
_gpgme_tofu_info_swigregister = _gpgme._gpgme_tofu_info_swigregister
_gpgme_tofu_info_swigregister(_gpgme_tofu_info)

class _gpgme_subkey(_object):
    """Proxy of C _gpgme_subkey struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_subkey, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_subkey, name)
    __repr__ = _swig_repr
    __swig_setmethods__["revoked"] = _gpgme._gpgme_subkey_revoked_set
    __swig_getmethods__["revoked"] = _gpgme._gpgme_subkey_revoked_get
    if _newclass:
        revoked = _swig_property(_gpgme._gpgme_subkey_revoked_get, _gpgme._gpgme_subkey_revoked_set)
    __swig_setmethods__["expired"] = _gpgme._gpgme_subkey_expired_set
    __swig_getmethods__["expired"] = _gpgme._gpgme_subkey_expired_get
    if _newclass:
        expired = _swig_property(_gpgme._gpgme_subkey_expired_get, _gpgme._gpgme_subkey_expired_set)
    __swig_setmethods__["disabled"] = _gpgme._gpgme_subkey_disabled_set
    __swig_getmethods__["disabled"] = _gpgme._gpgme_subkey_disabled_get
    if _newclass:
        disabled = _swig_property(_gpgme._gpgme_subkey_disabled_get, _gpgme._gpgme_subkey_disabled_set)
    __swig_setmethods__["invalid"] = _gpgme._gpgme_subkey_invalid_set
    __swig_getmethods__["invalid"] = _gpgme._gpgme_subkey_invalid_get
    if _newclass:
        invalid = _swig_property(_gpgme._gpgme_subkey_invalid_get, _gpgme._gpgme_subkey_invalid_set)
    __swig_setmethods__["can_encrypt"] = _gpgme._gpgme_subkey_can_encrypt_set
    __swig_getmethods__["can_encrypt"] = _gpgme._gpgme_subkey_can_encrypt_get
    if _newclass:
        can_encrypt = _swig_property(_gpgme._gpgme_subkey_can_encrypt_get, _gpgme._gpgme_subkey_can_encrypt_set)
    __swig_setmethods__["can_sign"] = _gpgme._gpgme_subkey_can_sign_set
    __swig_getmethods__["can_sign"] = _gpgme._gpgme_subkey_can_sign_get
    if _newclass:
        can_sign = _swig_property(_gpgme._gpgme_subkey_can_sign_get, _gpgme._gpgme_subkey_can_sign_set)
    __swig_setmethods__["can_certify"] = _gpgme._gpgme_subkey_can_certify_set
    __swig_getmethods__["can_certify"] = _gpgme._gpgme_subkey_can_certify_get
    if _newclass:
        can_certify = _swig_property(_gpgme._gpgme_subkey_can_certify_get, _gpgme._gpgme_subkey_can_certify_set)
    __swig_setmethods__["secret"] = _gpgme._gpgme_subkey_secret_set
    __swig_getmethods__["secret"] = _gpgme._gpgme_subkey_secret_get
    if _newclass:
        secret = _swig_property(_gpgme._gpgme_subkey_secret_get, _gpgme._gpgme_subkey_secret_set)
    __swig_setmethods__["can_authenticate"] = _gpgme._gpgme_subkey_can_authenticate_set
    __swig_getmethods__["can_authenticate"] = _gpgme._gpgme_subkey_can_authenticate_get
    if _newclass:
        can_authenticate = _swig_property(_gpgme._gpgme_subkey_can_authenticate_get, _gpgme._gpgme_subkey_can_authenticate_set)
    __swig_setmethods__["is_qualified"] = _gpgme._gpgme_subkey_is_qualified_set
    __swig_getmethods__["is_qualified"] = _gpgme._gpgme_subkey_is_qualified_get
    if _newclass:
        is_qualified = _swig_property(_gpgme._gpgme_subkey_is_qualified_get, _gpgme._gpgme_subkey_is_qualified_set)
    __swig_setmethods__["is_cardkey"] = _gpgme._gpgme_subkey_is_cardkey_set
    __swig_getmethods__["is_cardkey"] = _gpgme._gpgme_subkey_is_cardkey_get
    if _newclass:
        is_cardkey = _swig_property(_gpgme._gpgme_subkey_is_cardkey_get, _gpgme._gpgme_subkey_is_cardkey_set)
    __swig_setmethods__["is_de_vs"] = _gpgme._gpgme_subkey_is_de_vs_set
    __swig_getmethods__["is_de_vs"] = _gpgme._gpgme_subkey_is_de_vs_get
    if _newclass:
        is_de_vs = _swig_property(_gpgme._gpgme_subkey_is_de_vs_get, _gpgme._gpgme_subkey_is_de_vs_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_subkey__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_subkey__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_subkey__unused_get, _gpgme._gpgme_subkey__unused_set)
    __swig_setmethods__["pubkey_algo"] = _gpgme._gpgme_subkey_pubkey_algo_set
    __swig_getmethods__["pubkey_algo"] = _gpgme._gpgme_subkey_pubkey_algo_get
    if _newclass:
        pubkey_algo = _swig_property(_gpgme._gpgme_subkey_pubkey_algo_get, _gpgme._gpgme_subkey_pubkey_algo_set)
    __swig_setmethods__["length"] = _gpgme._gpgme_subkey_length_set
    __swig_getmethods__["length"] = _gpgme._gpgme_subkey_length_get
    if _newclass:
        length = _swig_property(_gpgme._gpgme_subkey_length_get, _gpgme._gpgme_subkey_length_set)
    __swig_setmethods__["keyid"] = _gpgme._gpgme_subkey_keyid_set
    __swig_getmethods__["keyid"] = _gpgme._gpgme_subkey_keyid_get
    if _newclass:
        keyid = _swig_property(_gpgme._gpgme_subkey_keyid_get, _gpgme._gpgme_subkey_keyid_set)
    __swig_setmethods__["_keyid"] = _gpgme._gpgme_subkey__keyid_set
    __swig_getmethods__["_keyid"] = _gpgme._gpgme_subkey__keyid_get
    if _newclass:
        _keyid = _swig_property(_gpgme._gpgme_subkey__keyid_get, _gpgme._gpgme_subkey__keyid_set)
    __swig_setmethods__["fpr"] = _gpgme._gpgme_subkey_fpr_set
    __swig_getmethods__["fpr"] = _gpgme._gpgme_subkey_fpr_get
    if _newclass:
        fpr = _swig_property(_gpgme._gpgme_subkey_fpr_get, _gpgme._gpgme_subkey_fpr_set)
    __swig_setmethods__["timestamp"] = _gpgme._gpgme_subkey_timestamp_set
    __swig_getmethods__["timestamp"] = _gpgme._gpgme_subkey_timestamp_get
    if _newclass:
        timestamp = _swig_property(_gpgme._gpgme_subkey_timestamp_get, _gpgme._gpgme_subkey_timestamp_set)
    __swig_setmethods__["expires"] = _gpgme._gpgme_subkey_expires_set
    __swig_getmethods__["expires"] = _gpgme._gpgme_subkey_expires_get
    if _newclass:
        expires = _swig_property(_gpgme._gpgme_subkey_expires_get, _gpgme._gpgme_subkey_expires_set)
    __swig_setmethods__["card_number"] = _gpgme._gpgme_subkey_card_number_set
    __swig_getmethods__["card_number"] = _gpgme._gpgme_subkey_card_number_get
    if _newclass:
        card_number = _swig_property(_gpgme._gpgme_subkey_card_number_get, _gpgme._gpgme_subkey_card_number_set)
    __swig_setmethods__["curve"] = _gpgme._gpgme_subkey_curve_set
    __swig_getmethods__["curve"] = _gpgme._gpgme_subkey_curve_get
    if _newclass:
        curve = _swig_property(_gpgme._gpgme_subkey_curve_get, _gpgme._gpgme_subkey_curve_set)
    __swig_setmethods__["keygrip"] = _gpgme._gpgme_subkey_keygrip_set
    __swig_getmethods__["keygrip"] = _gpgme._gpgme_subkey_keygrip_get
    if _newclass:
        keygrip = _swig_property(_gpgme._gpgme_subkey_keygrip_get, _gpgme._gpgme_subkey_keygrip_set)

    def __repr__(self):
        names = [name for name in dir(self)
            if not name.startswith("_") and name != "this"]
        props = ", ".join(("{}={!r}".format(name, getattr(self, name))
            for name in names)
        )
        return "SubKey({})".format(props)


    def __init__(self):
        """__init__(self) -> _gpgme_subkey"""
        this = _gpgme.new__gpgme_subkey()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_subkey
    __del__ = lambda self: None
_gpgme_subkey_swigregister = _gpgme._gpgme_subkey_swigregister
_gpgme_subkey_swigregister(_gpgme_subkey)

class _gpgme_key_sig(_object):
    """Proxy of C _gpgme_key_sig struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_key_sig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_key_sig, name)
    __repr__ = _swig_repr
    __swig_setmethods__["revoked"] = _gpgme._gpgme_key_sig_revoked_set
    __swig_getmethods__["revoked"] = _gpgme._gpgme_key_sig_revoked_get
    if _newclass:
        revoked = _swig_property(_gpgme._gpgme_key_sig_revoked_get, _gpgme._gpgme_key_sig_revoked_set)
    __swig_setmethods__["expired"] = _gpgme._gpgme_key_sig_expired_set
    __swig_getmethods__["expired"] = _gpgme._gpgme_key_sig_expired_get
    if _newclass:
        expired = _swig_property(_gpgme._gpgme_key_sig_expired_get, _gpgme._gpgme_key_sig_expired_set)
    __swig_setmethods__["invalid"] = _gpgme._gpgme_key_sig_invalid_set
    __swig_getmethods__["invalid"] = _gpgme._gpgme_key_sig_invalid_get
    if _newclass:
        invalid = _swig_property(_gpgme._gpgme_key_sig_invalid_get, _gpgme._gpgme_key_sig_invalid_set)
    __swig_setmethods__["exportable"] = _gpgme._gpgme_key_sig_exportable_set
    __swig_getmethods__["exportable"] = _gpgme._gpgme_key_sig_exportable_get
    if _newclass:
        exportable = _swig_property(_gpgme._gpgme_key_sig_exportable_get, _gpgme._gpgme_key_sig_exportable_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_key_sig__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_key_sig__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_key_sig__unused_get, _gpgme._gpgme_key_sig__unused_set)
    __swig_setmethods__["pubkey_algo"] = _gpgme._gpgme_key_sig_pubkey_algo_set
    __swig_getmethods__["pubkey_algo"] = _gpgme._gpgme_key_sig_pubkey_algo_get
    if _newclass:
        pubkey_algo = _swig_property(_gpgme._gpgme_key_sig_pubkey_algo_get, _gpgme._gpgme_key_sig_pubkey_algo_set)
    __swig_setmethods__["keyid"] = _gpgme._gpgme_key_sig_keyid_set
    __swig_getmethods__["keyid"] = _gpgme._gpgme_key_sig_keyid_get
    if _newclass:
        keyid = _swig_property(_gpgme._gpgme_key_sig_keyid_get, _gpgme._gpgme_key_sig_keyid_set)
    __swig_setmethods__["_keyid"] = _gpgme._gpgme_key_sig__keyid_set
    __swig_getmethods__["_keyid"] = _gpgme._gpgme_key_sig__keyid_get
    if _newclass:
        _keyid = _swig_property(_gpgme._gpgme_key_sig__keyid_get, _gpgme._gpgme_key_sig__keyid_set)
    __swig_setmethods__["timestamp"] = _gpgme._gpgme_key_sig_timestamp_set
    __swig_getmethods__["timestamp"] = _gpgme._gpgme_key_sig_timestamp_get
    if _newclass:
        timestamp = _swig_property(_gpgme._gpgme_key_sig_timestamp_get, _gpgme._gpgme_key_sig_timestamp_set)
    __swig_setmethods__["expires"] = _gpgme._gpgme_key_sig_expires_set
    __swig_getmethods__["expires"] = _gpgme._gpgme_key_sig_expires_get
    if _newclass:
        expires = _swig_property(_gpgme._gpgme_key_sig_expires_get, _gpgme._gpgme_key_sig_expires_set)
    __swig_setmethods__["status"] = _gpgme._gpgme_key_sig_status_set
    __swig_getmethods__["status"] = _gpgme._gpgme_key_sig_status_get
    if _newclass:
        status = _swig_property(_gpgme._gpgme_key_sig_status_get, _gpgme._gpgme_key_sig_status_set)
    __swig_setmethods__["uid"] = _gpgme._gpgme_key_sig_uid_set
    __swig_getmethods__["uid"] = _gpgme._gpgme_key_sig_uid_get
    if _newclass:
        uid = _swig_property(_gpgme._gpgme_key_sig_uid_get, _gpgme._gpgme_key_sig_uid_set)
    __swig_setmethods__["name"] = _gpgme._gpgme_key_sig_name_set
    __swig_getmethods__["name"] = _gpgme._gpgme_key_sig_name_get
    if _newclass:
        name = _swig_property(_gpgme._gpgme_key_sig_name_get, _gpgme._gpgme_key_sig_name_set)
    __swig_setmethods__["email"] = _gpgme._gpgme_key_sig_email_set
    __swig_getmethods__["email"] = _gpgme._gpgme_key_sig_email_get
    if _newclass:
        email = _swig_property(_gpgme._gpgme_key_sig_email_get, _gpgme._gpgme_key_sig_email_set)
    __swig_setmethods__["comment"] = _gpgme._gpgme_key_sig_comment_set
    __swig_getmethods__["comment"] = _gpgme._gpgme_key_sig_comment_get
    if _newclass:
        comment = _swig_property(_gpgme._gpgme_key_sig_comment_get, _gpgme._gpgme_key_sig_comment_set)
    __swig_setmethods__["sig_class"] = _gpgme._gpgme_key_sig_sig_class_set
    __swig_getmethods__["sig_class"] = _gpgme._gpgme_key_sig_sig_class_get
    if _newclass:
        sig_class = _swig_property(_gpgme._gpgme_key_sig_sig_class_get, _gpgme._gpgme_key_sig_sig_class_set)
    __swig_setmethods__["notations"] = _gpgme._gpgme_key_sig_notations_set
    __swig_getmethods__["notations"] = _gpgme._gpgme_key_sig_notations_get
    if _newclass:
        notations = _swig_property(_gpgme._gpgme_key_sig_notations_get, _gpgme._gpgme_key_sig_notations_set)
    __swig_setmethods__["_last_notation"] = _gpgme._gpgme_key_sig__last_notation_set
    __swig_getmethods__["_last_notation"] = _gpgme._gpgme_key_sig__last_notation_get
    if _newclass:
        _last_notation = _swig_property(_gpgme._gpgme_key_sig__last_notation_get, _gpgme._gpgme_key_sig__last_notation_set)

    def __repr__(self):
        names = [name for name in dir(self)
            if not name.startswith("_") and name != "this"]
        props = ", ".join(("{}={!r}".format(name, getattr(self, name))
            for name in names)
        )
        return "KeySig({})".format(props)


    def __init__(self):
        """__init__(self) -> _gpgme_key_sig"""
        this = _gpgme.new__gpgme_key_sig()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_key_sig
    __del__ = lambda self: None
_gpgme_key_sig_swigregister = _gpgme._gpgme_key_sig_swigregister
_gpgme_key_sig_swigregister(_gpgme_key_sig)

class _gpgme_user_id(_object):
    """Proxy of C _gpgme_user_id struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_user_id, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_user_id, name)
    __repr__ = _swig_repr
    __swig_setmethods__["revoked"] = _gpgme._gpgme_user_id_revoked_set
    __swig_getmethods__["revoked"] = _gpgme._gpgme_user_id_revoked_get
    if _newclass:
        revoked = _swig_property(_gpgme._gpgme_user_id_revoked_get, _gpgme._gpgme_user_id_revoked_set)
    __swig_setmethods__["invalid"] = _gpgme._gpgme_user_id_invalid_set
    __swig_getmethods__["invalid"] = _gpgme._gpgme_user_id_invalid_get
    if _newclass:
        invalid = _swig_property(_gpgme._gpgme_user_id_invalid_get, _gpgme._gpgme_user_id_invalid_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_user_id__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_user_id__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_user_id__unused_get, _gpgme._gpgme_user_id__unused_set)
    __swig_setmethods__["origin"] = _gpgme._gpgme_user_id_origin_set
    __swig_getmethods__["origin"] = _gpgme._gpgme_user_id_origin_get
    if _newclass:
        origin = _swig_property(_gpgme._gpgme_user_id_origin_get, _gpgme._gpgme_user_id_origin_set)
    __swig_setmethods__["validity"] = _gpgme._gpgme_user_id_validity_set
    __swig_getmethods__["validity"] = _gpgme._gpgme_user_id_validity_get
    if _newclass:
        validity = _swig_property(_gpgme._gpgme_user_id_validity_get, _gpgme._gpgme_user_id_validity_set)
    __swig_setmethods__["uid"] = _gpgme._gpgme_user_id_uid_set
    __swig_getmethods__["uid"] = _gpgme._gpgme_user_id_uid_get
    if _newclass:
        uid = _swig_property(_gpgme._gpgme_user_id_uid_get, _gpgme._gpgme_user_id_uid_set)
    __swig_setmethods__["name"] = _gpgme._gpgme_user_id_name_set
    __swig_getmethods__["name"] = _gpgme._gpgme_user_id_name_get
    if _newclass:
        name = _swig_property(_gpgme._gpgme_user_id_name_get, _gpgme._gpgme_user_id_name_set)
    __swig_setmethods__["email"] = _gpgme._gpgme_user_id_email_set
    __swig_getmethods__["email"] = _gpgme._gpgme_user_id_email_get
    if _newclass:
        email = _swig_property(_gpgme._gpgme_user_id_email_get, _gpgme._gpgme_user_id_email_set)
    __swig_setmethods__["comment"] = _gpgme._gpgme_user_id_comment_set
    __swig_getmethods__["comment"] = _gpgme._gpgme_user_id_comment_get
    if _newclass:
        comment = _swig_property(_gpgme._gpgme_user_id_comment_get, _gpgme._gpgme_user_id_comment_set)
    __swig_setmethods__["signatures"] = _gpgme._gpgme_user_id_signatures_set
    __swig_getmethods__["signatures"] = _gpgme._gpgme_user_id_signatures_get
    if _newclass:
        signatures = _swig_property(_gpgme._gpgme_user_id_signatures_get, _gpgme._gpgme_user_id_signatures_set)
    __swig_setmethods__["_last_keysig"] = _gpgme._gpgme_user_id__last_keysig_set
    __swig_getmethods__["_last_keysig"] = _gpgme._gpgme_user_id__last_keysig_get
    if _newclass:
        _last_keysig = _swig_property(_gpgme._gpgme_user_id__last_keysig_get, _gpgme._gpgme_user_id__last_keysig_set)
    __swig_setmethods__["address"] = _gpgme._gpgme_user_id_address_set
    __swig_getmethods__["address"] = _gpgme._gpgme_user_id_address_get
    if _newclass:
        address = _swig_property(_gpgme._gpgme_user_id_address_get, _gpgme._gpgme_user_id_address_set)
    __swig_setmethods__["tofu"] = _gpgme._gpgme_user_id_tofu_set
    __swig_getmethods__["tofu"] = _gpgme._gpgme_user_id_tofu_get
    if _newclass:
        tofu = _swig_property(_gpgme._gpgme_user_id_tofu_get, _gpgme._gpgme_user_id_tofu_set)
    __swig_setmethods__["last_update"] = _gpgme._gpgme_user_id_last_update_set
    __swig_getmethods__["last_update"] = _gpgme._gpgme_user_id_last_update_get
    if _newclass:
        last_update = _swig_property(_gpgme._gpgme_user_id_last_update_get, _gpgme._gpgme_user_id_last_update_set)

    def __repr__(self):
        names = [name for name in dir(self)
            if not name.startswith("_") and name != "this"]
        props = ", ".join(("{}={!r}".format(name, getattr(self, name))
            for name in names)
        )
        return "UID({})".format(props)


    def __init__(self):
        """__init__(self) -> _gpgme_user_id"""
        this = _gpgme.new__gpgme_user_id()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_user_id
    __del__ = lambda self: None
_gpgme_user_id_swigregister = _gpgme._gpgme_user_id_swigregister
_gpgme_user_id_swigregister(_gpgme_user_id)

class _gpgme_key(_object):
    """Proxy of C _gpgme_key struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_key, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_key, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_refs"] = _gpgme._gpgme_key__refs_set
    __swig_getmethods__["_refs"] = _gpgme._gpgme_key__refs_get
    if _newclass:
        _refs = _swig_property(_gpgme._gpgme_key__refs_get, _gpgme._gpgme_key__refs_set)
    __swig_setmethods__["revoked"] = _gpgme._gpgme_key_revoked_set
    __swig_getmethods__["revoked"] = _gpgme._gpgme_key_revoked_get
    if _newclass:
        revoked = _swig_property(_gpgme._gpgme_key_revoked_get, _gpgme._gpgme_key_revoked_set)
    __swig_setmethods__["expired"] = _gpgme._gpgme_key_expired_set
    __swig_getmethods__["expired"] = _gpgme._gpgme_key_expired_get
    if _newclass:
        expired = _swig_property(_gpgme._gpgme_key_expired_get, _gpgme._gpgme_key_expired_set)
    __swig_setmethods__["disabled"] = _gpgme._gpgme_key_disabled_set
    __swig_getmethods__["disabled"] = _gpgme._gpgme_key_disabled_get
    if _newclass:
        disabled = _swig_property(_gpgme._gpgme_key_disabled_get, _gpgme._gpgme_key_disabled_set)
    __swig_setmethods__["invalid"] = _gpgme._gpgme_key_invalid_set
    __swig_getmethods__["invalid"] = _gpgme._gpgme_key_invalid_get
    if _newclass:
        invalid = _swig_property(_gpgme._gpgme_key_invalid_get, _gpgme._gpgme_key_invalid_set)
    __swig_setmethods__["can_encrypt"] = _gpgme._gpgme_key_can_encrypt_set
    __swig_getmethods__["can_encrypt"] = _gpgme._gpgme_key_can_encrypt_get
    if _newclass:
        can_encrypt = _swig_property(_gpgme._gpgme_key_can_encrypt_get, _gpgme._gpgme_key_can_encrypt_set)
    __swig_setmethods__["can_sign"] = _gpgme._gpgme_key_can_sign_set
    __swig_getmethods__["can_sign"] = _gpgme._gpgme_key_can_sign_get
    if _newclass:
        can_sign = _swig_property(_gpgme._gpgme_key_can_sign_get, _gpgme._gpgme_key_can_sign_set)
    __swig_setmethods__["can_certify"] = _gpgme._gpgme_key_can_certify_set
    __swig_getmethods__["can_certify"] = _gpgme._gpgme_key_can_certify_get
    if _newclass:
        can_certify = _swig_property(_gpgme._gpgme_key_can_certify_get, _gpgme._gpgme_key_can_certify_set)
    __swig_setmethods__["secret"] = _gpgme._gpgme_key_secret_set
    __swig_getmethods__["secret"] = _gpgme._gpgme_key_secret_get
    if _newclass:
        secret = _swig_property(_gpgme._gpgme_key_secret_get, _gpgme._gpgme_key_secret_set)
    __swig_setmethods__["can_authenticate"] = _gpgme._gpgme_key_can_authenticate_set
    __swig_getmethods__["can_authenticate"] = _gpgme._gpgme_key_can_authenticate_get
    if _newclass:
        can_authenticate = _swig_property(_gpgme._gpgme_key_can_authenticate_get, _gpgme._gpgme_key_can_authenticate_set)
    __swig_setmethods__["is_qualified"] = _gpgme._gpgme_key_is_qualified_set
    __swig_getmethods__["is_qualified"] = _gpgme._gpgme_key_is_qualified_get
    if _newclass:
        is_qualified = _swig_property(_gpgme._gpgme_key_is_qualified_get, _gpgme._gpgme_key_is_qualified_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_key__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_key__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_key__unused_get, _gpgme._gpgme_key__unused_set)
    __swig_setmethods__["origin"] = _gpgme._gpgme_key_origin_set
    __swig_getmethods__["origin"] = _gpgme._gpgme_key_origin_get
    if _newclass:
        origin = _swig_property(_gpgme._gpgme_key_origin_get, _gpgme._gpgme_key_origin_set)
    __swig_setmethods__["protocol"] = _gpgme._gpgme_key_protocol_set
    __swig_getmethods__["protocol"] = _gpgme._gpgme_key_protocol_get
    if _newclass:
        protocol = _swig_property(_gpgme._gpgme_key_protocol_get, _gpgme._gpgme_key_protocol_set)
    __swig_setmethods__["issuer_serial"] = _gpgme._gpgme_key_issuer_serial_set
    __swig_getmethods__["issuer_serial"] = _gpgme._gpgme_key_issuer_serial_get
    if _newclass:
        issuer_serial = _swig_property(_gpgme._gpgme_key_issuer_serial_get, _gpgme._gpgme_key_issuer_serial_set)
    __swig_setmethods__["issuer_name"] = _gpgme._gpgme_key_issuer_name_set
    __swig_getmethods__["issuer_name"] = _gpgme._gpgme_key_issuer_name_get
    if _newclass:
        issuer_name = _swig_property(_gpgme._gpgme_key_issuer_name_get, _gpgme._gpgme_key_issuer_name_set)
    __swig_setmethods__["chain_id"] = _gpgme._gpgme_key_chain_id_set
    __swig_getmethods__["chain_id"] = _gpgme._gpgme_key_chain_id_get
    if _newclass:
        chain_id = _swig_property(_gpgme._gpgme_key_chain_id_get, _gpgme._gpgme_key_chain_id_set)
    __swig_setmethods__["owner_trust"] = _gpgme._gpgme_key_owner_trust_set
    __swig_getmethods__["owner_trust"] = _gpgme._gpgme_key_owner_trust_get
    if _newclass:
        owner_trust = _swig_property(_gpgme._gpgme_key_owner_trust_get, _gpgme._gpgme_key_owner_trust_set)
    __swig_setmethods__["subkeys"] = _gpgme._gpgme_key_subkeys_set
    __swig_getmethods__["subkeys"] = _gpgme._gpgme_key_subkeys_get
    if _newclass:
        subkeys = _swig_property(_gpgme._gpgme_key_subkeys_get, _gpgme._gpgme_key_subkeys_set)
    __swig_setmethods__["uids"] = _gpgme._gpgme_key_uids_set
    __swig_getmethods__["uids"] = _gpgme._gpgme_key_uids_get
    if _newclass:
        uids = _swig_property(_gpgme._gpgme_key_uids_get, _gpgme._gpgme_key_uids_set)
    __swig_setmethods__["_last_subkey"] = _gpgme._gpgme_key__last_subkey_set
    __swig_getmethods__["_last_subkey"] = _gpgme._gpgme_key__last_subkey_get
    if _newclass:
        _last_subkey = _swig_property(_gpgme._gpgme_key__last_subkey_get, _gpgme._gpgme_key__last_subkey_set)
    __swig_setmethods__["_last_uid"] = _gpgme._gpgme_key__last_uid_set
    __swig_getmethods__["_last_uid"] = _gpgme._gpgme_key__last_uid_get
    if _newclass:
        _last_uid = _swig_property(_gpgme._gpgme_key__last_uid_get, _gpgme._gpgme_key__last_uid_set)
    __swig_setmethods__["keylist_mode"] = _gpgme._gpgme_key_keylist_mode_set
    __swig_getmethods__["keylist_mode"] = _gpgme._gpgme_key_keylist_mode_get
    if _newclass:
        keylist_mode = _swig_property(_gpgme._gpgme_key_keylist_mode_get, _gpgme._gpgme_key_keylist_mode_set)
    __swig_setmethods__["fpr"] = _gpgme._gpgme_key_fpr_set
    __swig_getmethods__["fpr"] = _gpgme._gpgme_key_fpr_get
    if _newclass:
        fpr = _swig_property(_gpgme._gpgme_key_fpr_get, _gpgme._gpgme_key_fpr_set)
    __swig_setmethods__["last_update"] = _gpgme._gpgme_key_last_update_set
    __swig_getmethods__["last_update"] = _gpgme._gpgme_key_last_update_get
    if _newclass:
        last_update = _swig_property(_gpgme._gpgme_key_last_update_get, _gpgme._gpgme_key_last_update_set)

    def __repr__(self):
        names = [name for name in dir(self)
            if not name.startswith("_") and name != "this"]
        props = ", ".join(("{}={!r}".format(name, getattr(self, name))
            for name in names)
        )
        return "Key({})".format(props)


    def __init__(self):
        """__init__(self) -> _gpgme_key"""
        this = _gpgme.new__gpgme_key()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_key
    __del__ = lambda self: None
_gpgme_key_swigregister = _gpgme._gpgme_key_swigregister
_gpgme_key_swigregister(_gpgme_key)

class _gpgme_invalid_key(_object):
    """Proxy of C _gpgme_invalid_key struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_invalid_key, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_invalid_key, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fpr"] = _gpgme._gpgme_invalid_key_fpr_set
    __swig_getmethods__["fpr"] = _gpgme._gpgme_invalid_key_fpr_get
    if _newclass:
        fpr = _swig_property(_gpgme._gpgme_invalid_key_fpr_get, _gpgme._gpgme_invalid_key_fpr_set)
    __swig_setmethods__["reason"] = _gpgme._gpgme_invalid_key_reason_set
    __swig_getmethods__["reason"] = _gpgme._gpgme_invalid_key_reason_get
    if _newclass:
        reason = _swig_property(_gpgme._gpgme_invalid_key_reason_get, _gpgme._gpgme_invalid_key_reason_set)

    def __init__(self):
        """__init__(self) -> _gpgme_invalid_key"""
        this = _gpgme.new__gpgme_invalid_key()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_invalid_key
    __del__ = lambda self: None
_gpgme_invalid_key_swigregister = _gpgme._gpgme_invalid_key_swigregister
_gpgme_invalid_key_swigregister(_gpgme_invalid_key)


def gpgme_new(ctx: 'gpgme_ctx_t *') -> "gpgme_error_t":
    """gpgme_new(ctx) -> gpgme_error_t"""
    return _gpgme.gpgme_new(ctx)

def gpgme_release(ctx: 'gpgme_ctx_t') -> "void":
    """gpgme_release(ctx)"""
    return _gpgme.gpgme_release(ctx)

def gpgme_set_ctx_flag(ctx: 'gpgme_ctx_t', name: 'char const *', value: 'char const *') -> "gpgme_error_t":
    """gpgme_set_ctx_flag(ctx, name, value) -> gpgme_error_t"""
    return _gpgme.gpgme_set_ctx_flag(ctx, name, value)

def gpgme_get_ctx_flag(ctx: 'gpgme_ctx_t', name: 'char const *') -> "char const *":
    """gpgme_get_ctx_flag(ctx, name) -> char const *"""
    return _gpgme.gpgme_get_ctx_flag(ctx, name)

def gpgme_set_protocol(ctx: 'gpgme_ctx_t', proto: 'gpgme_protocol_t') -> "gpgme_error_t":
    """gpgme_set_protocol(ctx, proto) -> gpgme_error_t"""
    return _gpgme.gpgme_set_protocol(ctx, proto)

def gpgme_get_protocol(ctx: 'gpgme_ctx_t') -> "gpgme_protocol_t":
    """gpgme_get_protocol(ctx) -> gpgme_protocol_t"""
    return _gpgme.gpgme_get_protocol(ctx)

def gpgme_set_sub_protocol(ctx: 'gpgme_ctx_t', proto: 'gpgme_protocol_t') -> "gpgme_error_t":
    """gpgme_set_sub_protocol(ctx, proto) -> gpgme_error_t"""
    return _gpgme.gpgme_set_sub_protocol(ctx, proto)

def gpgme_get_sub_protocol(ctx: 'gpgme_ctx_t') -> "gpgme_protocol_t":
    """gpgme_get_sub_protocol(ctx) -> gpgme_protocol_t"""
    return _gpgme.gpgme_get_sub_protocol(ctx)

def gpgme_get_protocol_name(proto: 'gpgme_protocol_t') -> "char const *":
    """gpgme_get_protocol_name(proto) -> char const *"""
    return _gpgme.gpgme_get_protocol_name(proto)

def gpgme_set_armor(ctx: 'gpgme_ctx_t', yes: 'int') -> "void":
    """gpgme_set_armor(ctx, yes)"""
    return _gpgme.gpgme_set_armor(ctx, yes)

def gpgme_get_armor(ctx: 'gpgme_ctx_t') -> "int":
    """gpgme_get_armor(ctx) -> int"""
    return _gpgme.gpgme_get_armor(ctx)

def gpgme_set_textmode(ctx: 'gpgme_ctx_t', yes: 'int') -> "void":
    """gpgme_set_textmode(ctx, yes)"""
    return _gpgme.gpgme_set_textmode(ctx, yes)

def gpgme_get_textmode(ctx: 'gpgme_ctx_t') -> "int":
    """gpgme_get_textmode(ctx) -> int"""
    return _gpgme.gpgme_get_textmode(ctx)

def gpgme_set_offline(ctx: 'gpgme_ctx_t', yes: 'int') -> "void":
    """gpgme_set_offline(ctx, yes)"""
    return _gpgme.gpgme_set_offline(ctx, yes)

def gpgme_get_offline(ctx: 'gpgme_ctx_t') -> "int":
    """gpgme_get_offline(ctx) -> int"""
    return _gpgme.gpgme_get_offline(ctx)
GPGME_INCLUDE_CERTS_DEFAULT = _gpgme.GPGME_INCLUDE_CERTS_DEFAULT

def gpgme_set_include_certs(ctx: 'gpgme_ctx_t', nr_of_certs: 'int') -> "void":
    """gpgme_set_include_certs(ctx, nr_of_certs)"""
    return _gpgme.gpgme_set_include_certs(ctx, nr_of_certs)

def gpgme_get_include_certs(ctx: 'gpgme_ctx_t') -> "int":
    """gpgme_get_include_certs(ctx) -> int"""
    return _gpgme.gpgme_get_include_certs(ctx)

def gpgme_set_keylist_mode(ctx: 'gpgme_ctx_t', mode: 'gpgme_keylist_mode_t') -> "gpgme_error_t":
    """gpgme_set_keylist_mode(ctx, mode) -> gpgme_error_t"""
    return _gpgme.gpgme_set_keylist_mode(ctx, mode)

def gpgme_get_keylist_mode(ctx: 'gpgme_ctx_t') -> "gpgme_keylist_mode_t":
    """gpgme_get_keylist_mode(ctx) -> gpgme_keylist_mode_t"""
    return _gpgme.gpgme_get_keylist_mode(ctx)

def gpgme_set_pinentry_mode(ctx: 'gpgme_ctx_t', mode: 'gpgme_pinentry_mode_t') -> "gpgme_error_t":
    """gpgme_set_pinentry_mode(ctx, mode) -> gpgme_error_t"""
    return _gpgme.gpgme_set_pinentry_mode(ctx, mode)

def gpgme_get_pinentry_mode(ctx: 'gpgme_ctx_t') -> "gpgme_pinentry_mode_t":
    """gpgme_get_pinentry_mode(ctx) -> gpgme_pinentry_mode_t"""
    return _gpgme.gpgme_get_pinentry_mode(ctx)

def gpgme_set_passphrase_cb(ctx: 'gpgme_ctx_t', cb: 'gpgme_passphrase_cb_t', hook_value: 'void *') -> "void":
    """gpgme_set_passphrase_cb(ctx, cb, hook_value)"""
    return _gpgme.gpgme_set_passphrase_cb(ctx, cb, hook_value)

def gpgme_get_passphrase_cb(ctx: 'gpgme_ctx_t', cb: 'gpgme_passphrase_cb_t *', hook_value: 'void **') -> "void":
    """gpgme_get_passphrase_cb(ctx, cb, hook_value)"""
    return _gpgme.gpgme_get_passphrase_cb(ctx, cb, hook_value)

def gpgme_set_progress_cb(c: 'gpgme_ctx_t', cb: 'gpgme_progress_cb_t', hook_value: 'void *') -> "void":
    """gpgme_set_progress_cb(c, cb, hook_value)"""
    return _gpgme.gpgme_set_progress_cb(c, cb, hook_value)

def gpgme_get_progress_cb(ctx: 'gpgme_ctx_t', cb: 'gpgme_progress_cb_t *', hook_value: 'void **') -> "void":
    """gpgme_get_progress_cb(ctx, cb, hook_value)"""
    return _gpgme.gpgme_get_progress_cb(ctx, cb, hook_value)

def gpgme_set_status_cb(c: 'gpgme_ctx_t', cb: 'gpgme_status_cb_t', hook_value: 'void *') -> "void":
    """gpgme_set_status_cb(c, cb, hook_value)"""
    return _gpgme.gpgme_set_status_cb(c, cb, hook_value)

def gpgme_get_status_cb(ctx: 'gpgme_ctx_t', cb: 'gpgme_status_cb_t *', hook_value: 'void **') -> "void":
    """gpgme_get_status_cb(ctx, cb, hook_value)"""
    return _gpgme.gpgme_get_status_cb(ctx, cb, hook_value)

def gpgme_set_locale(ctx: 'gpgme_ctx_t', category: 'int', value: 'char const *') -> "gpgme_error_t":
    """gpgme_set_locale(ctx, category, value) -> gpgme_error_t"""
    return _gpgme.gpgme_set_locale(ctx, category, value)

def gpgme_ctx_get_engine_info(ctx: 'gpgme_ctx_t') -> "gpgme_engine_info_t":
    """gpgme_ctx_get_engine_info(ctx) -> _gpgme_engine_info"""
    return _gpgme.gpgme_ctx_get_engine_info(ctx)

def gpgme_ctx_set_engine_info(ctx: 'gpgme_ctx_t', proto: 'gpgme_protocol_t', file_name: 'char const *', home_dir: 'char const *') -> "gpgme_error_t":
    """gpgme_ctx_set_engine_info(ctx, proto, file_name, home_dir) -> gpgme_error_t"""
    return _gpgme.gpgme_ctx_set_engine_info(ctx, proto, file_name, home_dir)

def gpgme_signers_clear(ctx: 'gpgme_ctx_t') -> "void":
    """gpgme_signers_clear(ctx)"""
    return _gpgme.gpgme_signers_clear(ctx)

def gpgme_signers_add(ctx: 'gpgme_ctx_t', key: '_gpgme_key') -> "gpgme_error_t":
    """gpgme_signers_add(ctx, key) -> gpgme_error_t"""
    return _gpgme.gpgme_signers_add(ctx, key)

def gpgme_signers_count(ctx: 'gpgme_ctx_t const') -> "unsigned int":
    """gpgme_signers_count(ctx) -> unsigned int"""
    return _gpgme.gpgme_signers_count(ctx)

def gpgme_signers_enum(ctx: 'gpgme_ctx_t const', seq: 'int') -> "gpgme_key_t":
    """gpgme_signers_enum(ctx, seq) -> _gpgme_key"""
    return _gpgme.gpgme_signers_enum(ctx, seq)

def gpgme_sig_notation_clear(ctx: 'gpgme_ctx_t') -> "void":
    """gpgme_sig_notation_clear(ctx)"""
    return _gpgme.gpgme_sig_notation_clear(ctx)

def gpgme_sig_notation_add(ctx: 'gpgme_ctx_t', name: 'char const *', value: 'char const *', flags: 'gpgme_sig_notation_flags_t') -> "gpgme_error_t":
    """gpgme_sig_notation_add(ctx, name, value, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_sig_notation_add(ctx, name, value, flags)

def gpgme_sig_notation_get(ctx: 'gpgme_ctx_t') -> "gpgme_sig_notation_t":
    """gpgme_sig_notation_get(ctx) -> _gpgme_sig_notation"""
    return _gpgme.gpgme_sig_notation_get(ctx)

def gpgme_set_sender(ctx: 'gpgme_ctx_t', address: 'char const *') -> "gpgme_error_t":
    """gpgme_set_sender(ctx, address) -> gpgme_error_t"""
    return _gpgme.gpgme_set_sender(ctx, address)

def gpgme_get_sender(ctx: 'gpgme_ctx_t') -> "char const *":
    """gpgme_get_sender(ctx) -> char const *"""
    return _gpgme.gpgme_get_sender(ctx)
GPGME_EVENT_START = _gpgme.GPGME_EVENT_START
GPGME_EVENT_DONE = _gpgme.GPGME_EVENT_DONE
GPGME_EVENT_NEXT_KEY = _gpgme.GPGME_EVENT_NEXT_KEY
GPGME_EVENT_NEXT_TRUSTITEM = _gpgme.GPGME_EVENT_NEXT_TRUSTITEM
class gpgme_io_event_done_data(_object):
    """Proxy of C gpgme_io_event_done_data struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gpgme_io_event_done_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gpgme_io_event_done_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["err"] = _gpgme.gpgme_io_event_done_data_err_set
    __swig_getmethods__["err"] = _gpgme.gpgme_io_event_done_data_err_get
    if _newclass:
        err = _swig_property(_gpgme.gpgme_io_event_done_data_err_get, _gpgme.gpgme_io_event_done_data_err_set)
    __swig_setmethods__["op_err"] = _gpgme.gpgme_io_event_done_data_op_err_set
    __swig_getmethods__["op_err"] = _gpgme.gpgme_io_event_done_data_op_err_get
    if _newclass:
        op_err = _swig_property(_gpgme.gpgme_io_event_done_data_op_err_get, _gpgme.gpgme_io_event_done_data_op_err_set)

    def __init__(self):
        """__init__(self) -> gpgme_io_event_done_data"""
        this = _gpgme.new_gpgme_io_event_done_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete_gpgme_io_event_done_data
    __del__ = lambda self: None
gpgme_io_event_done_data_swigregister = _gpgme.gpgme_io_event_done_data_swigregister
gpgme_io_event_done_data_swigregister(gpgme_io_event_done_data)

class gpgme_io_cbs(_object):
    """Proxy of C gpgme_io_cbs struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gpgme_io_cbs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gpgme_io_cbs, name)
    __repr__ = _swig_repr
    __swig_setmethods__["add"] = _gpgme.gpgme_io_cbs_add_set
    __swig_getmethods__["add"] = _gpgme.gpgme_io_cbs_add_get
    if _newclass:
        add = _swig_property(_gpgme.gpgme_io_cbs_add_get, _gpgme.gpgme_io_cbs_add_set)
    __swig_setmethods__["add_priv"] = _gpgme.gpgme_io_cbs_add_priv_set
    __swig_getmethods__["add_priv"] = _gpgme.gpgme_io_cbs_add_priv_get
    if _newclass:
        add_priv = _swig_property(_gpgme.gpgme_io_cbs_add_priv_get, _gpgme.gpgme_io_cbs_add_priv_set)
    __swig_setmethods__["remove"] = _gpgme.gpgme_io_cbs_remove_set
    __swig_getmethods__["remove"] = _gpgme.gpgme_io_cbs_remove_get
    if _newclass:
        remove = _swig_property(_gpgme.gpgme_io_cbs_remove_get, _gpgme.gpgme_io_cbs_remove_set)
    __swig_setmethods__["event"] = _gpgme.gpgme_io_cbs_event_set
    __swig_getmethods__["event"] = _gpgme.gpgme_io_cbs_event_get
    if _newclass:
        event = _swig_property(_gpgme.gpgme_io_cbs_event_get, _gpgme.gpgme_io_cbs_event_set)
    __swig_setmethods__["event_priv"] = _gpgme.gpgme_io_cbs_event_priv_set
    __swig_getmethods__["event_priv"] = _gpgme.gpgme_io_cbs_event_priv_get
    if _newclass:
        event_priv = _swig_property(_gpgme.gpgme_io_cbs_event_priv_get, _gpgme.gpgme_io_cbs_event_priv_set)

    def __init__(self):
        """__init__(self) -> gpgme_io_cbs"""
        this = _gpgme.new_gpgme_io_cbs()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete_gpgme_io_cbs
    __del__ = lambda self: None
gpgme_io_cbs_swigregister = _gpgme.gpgme_io_cbs_swigregister
gpgme_io_cbs_swigregister(gpgme_io_cbs)


def gpgme_set_io_cbs(ctx: 'gpgme_ctx_t', io_cbs: 'gpgme_io_cbs') -> "void":
    """gpgme_set_io_cbs(ctx, io_cbs)"""
    return _gpgme.gpgme_set_io_cbs(ctx, io_cbs)

def gpgme_get_io_cbs(ctx: 'gpgme_ctx_t', io_cbs: 'gpgme_io_cbs') -> "void":
    """gpgme_get_io_cbs(ctx, io_cbs)"""
    return _gpgme.gpgme_get_io_cbs(ctx, io_cbs)

def gpgme_io_read(fd: 'int', buffer: 'void *', count: 'size_t') -> "ssize_t":
    """gpgme_io_read(fd, buffer, count) -> ssize_t"""
    return _gpgme.gpgme_io_read(fd, buffer, count)

def gpgme_io_write(fd: 'int', buffer: 'void const *', count: 'size_t') -> "ssize_t":
    """gpgme_io_write(fd, buffer, count) -> ssize_t"""
    return _gpgme.gpgme_io_write(fd, buffer, count)

def gpgme_io_writen(fd: 'int', buffer: 'void const *', count: 'size_t') -> "int":
    """gpgme_io_writen(fd, buffer, count) -> int"""
    return _gpgme.gpgme_io_writen(fd, buffer, count)

def gpgme_wait(ctx: 'gpgme_ctx_t', status: 'gpgme_error_t *', hang: 'int') -> "gpgme_ctx_t":
    """gpgme_wait(ctx, status, hang) -> gpgme_ctx_t"""
    return _gpgme.gpgme_wait(ctx, status, hang)

def gpgme_wait_ext(ctx: 'gpgme_ctx_t', status: 'gpgme_error_t *', op_err: 'gpgme_error_t *', hang: 'int') -> "gpgme_ctx_t":
    """gpgme_wait_ext(ctx, status, op_err, hang) -> gpgme_ctx_t"""
    return _gpgme.gpgme_wait_ext(ctx, status, op_err, hang)

def gpgme_cancel(ctx: 'gpgme_ctx_t') -> "gpgme_error_t":
    """gpgme_cancel(ctx) -> gpgme_error_t"""
    return _gpgme.gpgme_cancel(ctx)

def gpgme_cancel_async(ctx: 'gpgme_ctx_t') -> "gpgme_error_t":
    """gpgme_cancel_async(ctx) -> gpgme_error_t"""
    return _gpgme.gpgme_cancel_async(ctx)
class gpgme_data_cbs(_object):
    """Proxy of C gpgme_data_cbs struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gpgme_data_cbs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gpgme_data_cbs, name)
    __repr__ = _swig_repr
    __swig_setmethods__["read"] = _gpgme.gpgme_data_cbs_read_set
    __swig_getmethods__["read"] = _gpgme.gpgme_data_cbs_read_get
    if _newclass:
        read = _swig_property(_gpgme.gpgme_data_cbs_read_get, _gpgme.gpgme_data_cbs_read_set)
    __swig_setmethods__["write"] = _gpgme.gpgme_data_cbs_write_set
    __swig_getmethods__["write"] = _gpgme.gpgme_data_cbs_write_get
    if _newclass:
        write = _swig_property(_gpgme.gpgme_data_cbs_write_get, _gpgme.gpgme_data_cbs_write_set)
    __swig_setmethods__["seek"] = _gpgme.gpgme_data_cbs_seek_set
    __swig_getmethods__["seek"] = _gpgme.gpgme_data_cbs_seek_get
    if _newclass:
        seek = _swig_property(_gpgme.gpgme_data_cbs_seek_get, _gpgme.gpgme_data_cbs_seek_set)
    __swig_setmethods__["release"] = _gpgme.gpgme_data_cbs_release_set
    __swig_getmethods__["release"] = _gpgme.gpgme_data_cbs_release_get
    if _newclass:
        release = _swig_property(_gpgme.gpgme_data_cbs_release_get, _gpgme.gpgme_data_cbs_release_set)

    def __init__(self):
        """__init__(self) -> gpgme_data_cbs"""
        this = _gpgme.new_gpgme_data_cbs()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete_gpgme_data_cbs
    __del__ = lambda self: None
gpgme_data_cbs_swigregister = _gpgme.gpgme_data_cbs_swigregister
gpgme_data_cbs_swigregister(gpgme_data_cbs)


def gpgme_data_read(dh: 'gpgme_data_t', buffer: 'void *') -> "size_t":
    """gpgme_data_read(dh, buffer) -> ssize_t"""
    return _gpgme.gpgme_data_read(dh, buffer)

def gpgme_data_write(dh: 'gpgme_data_t', buffer: 'void const *') -> "ssize_t":
    """gpgme_data_write(dh, buffer) -> ssize_t"""
    return _gpgme.gpgme_data_write(dh, buffer)

def gpgme_data_new(r_dh: 'gpgme_data_t *') -> "gpgme_error_t":
    """gpgme_data_new(r_dh) -> gpgme_error_t"""
    return _gpgme.gpgme_data_new(r_dh)

def gpgme_data_release(dh: 'gpgme_data_t') -> "void":
    """gpgme_data_release(dh)"""
    return _gpgme.gpgme_data_release(dh)

def gpgme_data_new_from_mem(r_dh: 'gpgme_data_t *', buffer: 'char const *', size: 'size_t', copy: 'int') -> "gpgme_error_t":
    """gpgme_data_new_from_mem(r_dh, buffer, size, copy) -> gpgme_error_t"""
    return _gpgme.gpgme_data_new_from_mem(r_dh, buffer, size, copy)

def gpgme_data_release_and_get_mem(dh: 'gpgme_data_t', r_len: 'size_t *') -> "char *":
    """gpgme_data_release_and_get_mem(dh, r_len) -> char *"""
    return _gpgme.gpgme_data_release_and_get_mem(dh, r_len)

def gpgme_free(buffer: 'void *') -> "void":
    """gpgme_free(buffer)"""
    return _gpgme.gpgme_free(buffer)

def gpgme_data_new_from_cbs(dh: 'gpgme_data_t *', cbs: 'gpgme_data_cbs', handle: 'void *') -> "gpgme_error_t":
    """gpgme_data_new_from_cbs(dh, cbs, handle) -> gpgme_error_t"""
    return _gpgme.gpgme_data_new_from_cbs(dh, cbs, handle)

def gpgme_data_new_from_fd(dh: 'gpgme_data_t *', fd: 'int') -> "gpgme_error_t":
    """gpgme_data_new_from_fd(dh, fd) -> gpgme_error_t"""
    return _gpgme.gpgme_data_new_from_fd(dh, fd)

def gpgme_data_new_from_stream(dh: 'gpgme_data_t *', stream: 'FILE *') -> "gpgme_error_t":
    """gpgme_data_new_from_stream(dh, stream) -> gpgme_error_t"""
    return _gpgme.gpgme_data_new_from_stream(dh, stream)

def gpgme_data_get_encoding(dh: 'gpgme_data_t') -> "gpgme_data_encoding_t":
    """gpgme_data_get_encoding(dh) -> gpgme_data_encoding_t"""
    return _gpgme.gpgme_data_get_encoding(dh)

def gpgme_data_set_encoding(dh: 'gpgme_data_t', enc: 'gpgme_data_encoding_t') -> "gpgme_error_t":
    """gpgme_data_set_encoding(dh, enc) -> gpgme_error_t"""
    return _gpgme.gpgme_data_set_encoding(dh, enc)

def gpgme_data_get_file_name(dh: 'gpgme_data_t') -> "char *":
    """gpgme_data_get_file_name(dh) -> char *"""
    return _gpgme.gpgme_data_get_file_name(dh)

def gpgme_data_set_file_name(dh: 'gpgme_data_t', file_name: 'char const *') -> "gpgme_error_t":
    """gpgme_data_set_file_name(dh, file_name) -> gpgme_error_t"""
    return _gpgme.gpgme_data_set_file_name(dh, file_name)

def gpgme_data_set_flag(dh: 'gpgme_data_t', name: 'char const *', value: 'char const *') -> "gpg_error_t":
    """gpgme_data_set_flag(dh, name, value) -> gpg_error_t"""
    return _gpgme.gpgme_data_set_flag(dh, name, value)

def gpgme_data_identify(dh: 'gpgme_data_t', reserved: 'int') -> "gpgme_data_type_t":
    """gpgme_data_identify(dh, reserved) -> gpgme_data_type_t"""
    return _gpgme.gpgme_data_identify(dh, reserved)

def gpgme_data_new_from_file(r_dh: 'gpgme_data_t *', fname: 'char const *', copy: 'int') -> "gpgme_error_t":
    """gpgme_data_new_from_file(r_dh, fname, copy) -> gpgme_error_t"""
    return _gpgme.gpgme_data_new_from_file(r_dh, fname, copy)

def gpgme_data_new_from_filepart(r_dh: 'gpgme_data_t *', fname: 'char const *', fp: 'FILE *', offset: 'off_t', length: 'size_t') -> "gpgme_error_t":
    """gpgme_data_new_from_filepart(r_dh, fname, fp, offset, length) -> gpgme_error_t"""
    return _gpgme.gpgme_data_new_from_filepart(r_dh, fname, fp, offset, length)

def gpgme_data_rewind(dh: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_data_rewind(dh) -> gpgme_error_t"""
    return _gpgme.gpgme_data_rewind(dh)

def gpgme_get_key(ctx: 'gpgme_ctx_t', fpr: 'char const *', r_key: 'gpgme_key_t *', secret: 'int') -> "gpgme_error_t":
    """gpgme_get_key(ctx, fpr, r_key, secret) -> gpgme_error_t"""
    return _gpgme.gpgme_get_key(ctx, fpr, r_key, secret)

def gpgme_key_from_uid(key: 'gpgme_key_t *', name: 'char const *') -> "gpgme_error_t":
    """gpgme_key_from_uid(key, name) -> gpgme_error_t"""
    return _gpgme.gpgme_key_from_uid(key, name)

def gpgme_key_ref(key: '_gpgme_key') -> "void":
    """gpgme_key_ref(key)"""
    return _gpgme.gpgme_key_ref(key)

def gpgme_key_unref(key: '_gpgme_key') -> "void":
    """gpgme_key_unref(key)"""
    return _gpgme.gpgme_key_unref(key)

def gpgme_key_release(key: '_gpgme_key') -> "void":
    """gpgme_key_release(key)"""
    return _gpgme.gpgme_key_release(key)
class _gpgme_op_encrypt_result(_object):
    """Proxy of C _gpgme_op_encrypt_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_encrypt_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_encrypt_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["invalid_recipients"] = _gpgme._gpgme_op_encrypt_result_invalid_recipients_set
    __swig_getmethods__["invalid_recipients"] = _gpgme._gpgme_op_encrypt_result_invalid_recipients_get
    if _newclass:
        invalid_recipients = _swig_property(_gpgme._gpgme_op_encrypt_result_invalid_recipients_get, _gpgme._gpgme_op_encrypt_result_invalid_recipients_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_encrypt_result"""
        this = _gpgme.new__gpgme_op_encrypt_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_encrypt_result
    __del__ = lambda self: None
_gpgme_op_encrypt_result_swigregister = _gpgme._gpgme_op_encrypt_result_swigregister
_gpgme_op_encrypt_result_swigregister(_gpgme_op_encrypt_result)


def gpgme_op_encrypt_result(ctx: 'gpgme_ctx_t') -> "gpgme_encrypt_result_t":
    """gpgme_op_encrypt_result(ctx) -> _gpgme_op_encrypt_result"""
    return _gpgme.gpgme_op_encrypt_result(ctx)
GPGME_ENCRYPT_ALWAYS_TRUST = _gpgme.GPGME_ENCRYPT_ALWAYS_TRUST
GPGME_ENCRYPT_NO_ENCRYPT_TO = _gpgme.GPGME_ENCRYPT_NO_ENCRYPT_TO
GPGME_ENCRYPT_PREPARE = _gpgme.GPGME_ENCRYPT_PREPARE
GPGME_ENCRYPT_EXPECT_SIGN = _gpgme.GPGME_ENCRYPT_EXPECT_SIGN
GPGME_ENCRYPT_NO_COMPRESS = _gpgme.GPGME_ENCRYPT_NO_COMPRESS
GPGME_ENCRYPT_SYMMETRIC = _gpgme.GPGME_ENCRYPT_SYMMETRIC
GPGME_ENCRYPT_THROW_KEYIDS = _gpgme.GPGME_ENCRYPT_THROW_KEYIDS
GPGME_ENCRYPT_WRAP = _gpgme.GPGME_ENCRYPT_WRAP

def gpgme_op_encrypt_start(ctx: 'gpgme_ctx_t', recp: 'gpgme_key_t []', flags: 'gpgme_encrypt_flags_t', plain: 'gpgme_data_t', cipher: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_encrypt_start(ctx, recp, flags, plain, cipher) -> gpgme_error_t"""
    return _gpgme.gpgme_op_encrypt_start(ctx, recp, flags, plain, cipher)

def gpgme_op_encrypt(ctx: 'gpgme_ctx_t', recp: 'gpgme_key_t []', flags: 'gpgme_encrypt_flags_t', plain: 'gpgme_data_t', cipher: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_encrypt(ctx, recp, flags, plain, cipher) -> gpgme_error_t"""
    return _gpgme.gpgme_op_encrypt(ctx, recp, flags, plain, cipher)

def gpgme_op_encrypt_sign_start(ctx: 'gpgme_ctx_t', recp: 'gpgme_key_t []', flags: 'gpgme_encrypt_flags_t', plain: 'gpgme_data_t', cipher: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_encrypt_sign_start(ctx, recp, flags, plain, cipher) -> gpgme_error_t"""
    return _gpgme.gpgme_op_encrypt_sign_start(ctx, recp, flags, plain, cipher)

def gpgme_op_encrypt_sign(ctx: 'gpgme_ctx_t', recp: 'gpgme_key_t []', flags: 'gpgme_encrypt_flags_t', plain: 'gpgme_data_t', cipher: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_encrypt_sign(ctx, recp, flags, plain, cipher) -> gpgme_error_t"""
    return _gpgme.gpgme_op_encrypt_sign(ctx, recp, flags, plain, cipher)
class _gpgme_recipient(_object):
    """Proxy of C _gpgme_recipient struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_recipient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_recipient, name)
    __repr__ = _swig_repr
    __swig_setmethods__["keyid"] = _gpgme._gpgme_recipient_keyid_set
    __swig_getmethods__["keyid"] = _gpgme._gpgme_recipient_keyid_get
    if _newclass:
        keyid = _swig_property(_gpgme._gpgme_recipient_keyid_get, _gpgme._gpgme_recipient_keyid_set)
    __swig_setmethods__["_keyid"] = _gpgme._gpgme_recipient__keyid_set
    __swig_getmethods__["_keyid"] = _gpgme._gpgme_recipient__keyid_get
    if _newclass:
        _keyid = _swig_property(_gpgme._gpgme_recipient__keyid_get, _gpgme._gpgme_recipient__keyid_set)
    __swig_setmethods__["pubkey_algo"] = _gpgme._gpgme_recipient_pubkey_algo_set
    __swig_getmethods__["pubkey_algo"] = _gpgme._gpgme_recipient_pubkey_algo_get
    if _newclass:
        pubkey_algo = _swig_property(_gpgme._gpgme_recipient_pubkey_algo_get, _gpgme._gpgme_recipient_pubkey_algo_set)
    __swig_setmethods__["status"] = _gpgme._gpgme_recipient_status_set
    __swig_getmethods__["status"] = _gpgme._gpgme_recipient_status_get
    if _newclass:
        status = _swig_property(_gpgme._gpgme_recipient_status_get, _gpgme._gpgme_recipient_status_set)

    def __init__(self):
        """__init__(self) -> _gpgme_recipient"""
        this = _gpgme.new__gpgme_recipient()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_recipient
    __del__ = lambda self: None
_gpgme_recipient_swigregister = _gpgme._gpgme_recipient_swigregister
_gpgme_recipient_swigregister(_gpgme_recipient)

class _gpgme_op_decrypt_result(_object):
    """Proxy of C _gpgme_op_decrypt_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_decrypt_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_decrypt_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["unsupported_algorithm"] = _gpgme._gpgme_op_decrypt_result_unsupported_algorithm_set
    __swig_getmethods__["unsupported_algorithm"] = _gpgme._gpgme_op_decrypt_result_unsupported_algorithm_get
    if _newclass:
        unsupported_algorithm = _swig_property(_gpgme._gpgme_op_decrypt_result_unsupported_algorithm_get, _gpgme._gpgme_op_decrypt_result_unsupported_algorithm_set)
    __swig_setmethods__["wrong_key_usage"] = _gpgme._gpgme_op_decrypt_result_wrong_key_usage_set
    __swig_getmethods__["wrong_key_usage"] = _gpgme._gpgme_op_decrypt_result_wrong_key_usage_get
    if _newclass:
        wrong_key_usage = _swig_property(_gpgme._gpgme_op_decrypt_result_wrong_key_usage_get, _gpgme._gpgme_op_decrypt_result_wrong_key_usage_set)
    __swig_setmethods__["is_de_vs"] = _gpgme._gpgme_op_decrypt_result_is_de_vs_set
    __swig_getmethods__["is_de_vs"] = _gpgme._gpgme_op_decrypt_result_is_de_vs_get
    if _newclass:
        is_de_vs = _swig_property(_gpgme._gpgme_op_decrypt_result_is_de_vs_get, _gpgme._gpgme_op_decrypt_result_is_de_vs_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_op_decrypt_result__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_op_decrypt_result__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_op_decrypt_result__unused_get, _gpgme._gpgme_op_decrypt_result__unused_set)
    __swig_setmethods__["recipients"] = _gpgme._gpgme_op_decrypt_result_recipients_set
    __swig_getmethods__["recipients"] = _gpgme._gpgme_op_decrypt_result_recipients_get
    if _newclass:
        recipients = _swig_property(_gpgme._gpgme_op_decrypt_result_recipients_get, _gpgme._gpgme_op_decrypt_result_recipients_set)
    __swig_setmethods__["file_name"] = _gpgme._gpgme_op_decrypt_result_file_name_set
    __swig_getmethods__["file_name"] = _gpgme._gpgme_op_decrypt_result_file_name_get
    if _newclass:
        file_name = _swig_property(_gpgme._gpgme_op_decrypt_result_file_name_get, _gpgme._gpgme_op_decrypt_result_file_name_set)
    __swig_setmethods__["session_key"] = _gpgme._gpgme_op_decrypt_result_session_key_set
    __swig_getmethods__["session_key"] = _gpgme._gpgme_op_decrypt_result_session_key_get
    if _newclass:
        session_key = _swig_property(_gpgme._gpgme_op_decrypt_result_session_key_get, _gpgme._gpgme_op_decrypt_result_session_key_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_decrypt_result"""
        this = _gpgme.new__gpgme_op_decrypt_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_decrypt_result
    __del__ = lambda self: None
_gpgme_op_decrypt_result_swigregister = _gpgme._gpgme_op_decrypt_result_swigregister
_gpgme_op_decrypt_result_swigregister(_gpgme_op_decrypt_result)


def gpgme_op_decrypt_result(ctx: 'gpgme_ctx_t') -> "gpgme_decrypt_result_t":
    """gpgme_op_decrypt_result(ctx) -> _gpgme_op_decrypt_result"""
    return _gpgme.gpgme_op_decrypt_result(ctx)
GPGME_DECRYPT_VERIFY = _gpgme.GPGME_DECRYPT_VERIFY
GPGME_DECRYPT_UNWRAP = _gpgme.GPGME_DECRYPT_UNWRAP

def gpgme_op_decrypt_start(ctx: 'gpgme_ctx_t', cipher: 'gpgme_data_t', plain: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_decrypt_start(ctx, cipher, plain) -> gpgme_error_t"""
    return _gpgme.gpgme_op_decrypt_start(ctx, cipher, plain)

def gpgme_op_decrypt(ctx: 'gpgme_ctx_t', cipher: 'gpgme_data_t', plain: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_decrypt(ctx, cipher, plain) -> gpgme_error_t"""
    return _gpgme.gpgme_op_decrypt(ctx, cipher, plain)

def gpgme_op_decrypt_verify_start(ctx: 'gpgme_ctx_t', cipher: 'gpgme_data_t', plain: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_decrypt_verify_start(ctx, cipher, plain) -> gpgme_error_t"""
    return _gpgme.gpgme_op_decrypt_verify_start(ctx, cipher, plain)

def gpgme_op_decrypt_verify(ctx: 'gpgme_ctx_t', cipher: 'gpgme_data_t', plain: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_decrypt_verify(ctx, cipher, plain) -> gpgme_error_t"""
    return _gpgme.gpgme_op_decrypt_verify(ctx, cipher, plain)

def gpgme_op_decrypt_ext_start(ctx: 'gpgme_ctx_t', flags: 'gpgme_decrypt_flags_t', cipher: 'gpgme_data_t', plain: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_decrypt_ext_start(ctx, flags, cipher, plain) -> gpgme_error_t"""
    return _gpgme.gpgme_op_decrypt_ext_start(ctx, flags, cipher, plain)

def gpgme_op_decrypt_ext(ctx: 'gpgme_ctx_t', flags: 'gpgme_decrypt_flags_t', cipher: 'gpgme_data_t', plain: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_decrypt_ext(ctx, flags, cipher, plain) -> gpgme_error_t"""
    return _gpgme.gpgme_op_decrypt_ext(ctx, flags, cipher, plain)
class _gpgme_new_signature(_object):
    """Proxy of C _gpgme_new_signature struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_new_signature, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_new_signature, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _gpgme._gpgme_new_signature_type_set
    __swig_getmethods__["type"] = _gpgme._gpgme_new_signature_type_get
    if _newclass:
        type = _swig_property(_gpgme._gpgme_new_signature_type_get, _gpgme._gpgme_new_signature_type_set)
    __swig_setmethods__["pubkey_algo"] = _gpgme._gpgme_new_signature_pubkey_algo_set
    __swig_getmethods__["pubkey_algo"] = _gpgme._gpgme_new_signature_pubkey_algo_get
    if _newclass:
        pubkey_algo = _swig_property(_gpgme._gpgme_new_signature_pubkey_algo_get, _gpgme._gpgme_new_signature_pubkey_algo_set)
    __swig_setmethods__["hash_algo"] = _gpgme._gpgme_new_signature_hash_algo_set
    __swig_getmethods__["hash_algo"] = _gpgme._gpgme_new_signature_hash_algo_get
    if _newclass:
        hash_algo = _swig_property(_gpgme._gpgme_new_signature_hash_algo_get, _gpgme._gpgme_new_signature_hash_algo_set)
    __swig_setmethods__["_obsolete_class"] = _gpgme._gpgme_new_signature__obsolete_class_set
    __swig_getmethods__["_obsolete_class"] = _gpgme._gpgme_new_signature__obsolete_class_get
    if _newclass:
        _obsolete_class = _swig_property(_gpgme._gpgme_new_signature__obsolete_class_get, _gpgme._gpgme_new_signature__obsolete_class_set)
    __swig_setmethods__["timestamp"] = _gpgme._gpgme_new_signature_timestamp_set
    __swig_getmethods__["timestamp"] = _gpgme._gpgme_new_signature_timestamp_get
    if _newclass:
        timestamp = _swig_property(_gpgme._gpgme_new_signature_timestamp_get, _gpgme._gpgme_new_signature_timestamp_set)
    __swig_setmethods__["fpr"] = _gpgme._gpgme_new_signature_fpr_set
    __swig_getmethods__["fpr"] = _gpgme._gpgme_new_signature_fpr_get
    if _newclass:
        fpr = _swig_property(_gpgme._gpgme_new_signature_fpr_get, _gpgme._gpgme_new_signature_fpr_set)
    __swig_setmethods__["sig_class"] = _gpgme._gpgme_new_signature_sig_class_set
    __swig_getmethods__["sig_class"] = _gpgme._gpgme_new_signature_sig_class_get
    if _newclass:
        sig_class = _swig_property(_gpgme._gpgme_new_signature_sig_class_get, _gpgme._gpgme_new_signature_sig_class_set)

    def __init__(self):
        """__init__(self) -> _gpgme_new_signature"""
        this = _gpgme.new__gpgme_new_signature()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_new_signature
    __del__ = lambda self: None
_gpgme_new_signature_swigregister = _gpgme._gpgme_new_signature_swigregister
_gpgme_new_signature_swigregister(_gpgme_new_signature)

class _gpgme_op_sign_result(_object):
    """Proxy of C _gpgme_op_sign_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_sign_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_sign_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["invalid_signers"] = _gpgme._gpgme_op_sign_result_invalid_signers_set
    __swig_getmethods__["invalid_signers"] = _gpgme._gpgme_op_sign_result_invalid_signers_get
    if _newclass:
        invalid_signers = _swig_property(_gpgme._gpgme_op_sign_result_invalid_signers_get, _gpgme._gpgme_op_sign_result_invalid_signers_set)
    __swig_setmethods__["signatures"] = _gpgme._gpgme_op_sign_result_signatures_set
    __swig_getmethods__["signatures"] = _gpgme._gpgme_op_sign_result_signatures_get
    if _newclass:
        signatures = _swig_property(_gpgme._gpgme_op_sign_result_signatures_get, _gpgme._gpgme_op_sign_result_signatures_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_sign_result"""
        this = _gpgme.new__gpgme_op_sign_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_sign_result
    __del__ = lambda self: None
_gpgme_op_sign_result_swigregister = _gpgme._gpgme_op_sign_result_swigregister
_gpgme_op_sign_result_swigregister(_gpgme_op_sign_result)


def gpgme_op_sign_result(ctx: 'gpgme_ctx_t') -> "gpgme_sign_result_t":
    """gpgme_op_sign_result(ctx) -> _gpgme_op_sign_result"""
    return _gpgme.gpgme_op_sign_result(ctx)

def gpgme_op_sign_start(ctx: 'gpgme_ctx_t', plain: 'gpgme_data_t', sig: 'gpgme_data_t', mode: 'gpgme_sig_mode_t') -> "gpgme_error_t":
    """gpgme_op_sign_start(ctx, plain, sig, mode) -> gpgme_error_t"""
    return _gpgme.gpgme_op_sign_start(ctx, plain, sig, mode)

def gpgme_op_sign(ctx: 'gpgme_ctx_t', plain: 'gpgme_data_t', sig: 'gpgme_data_t', mode: 'gpgme_sig_mode_t') -> "gpgme_error_t":
    """gpgme_op_sign(ctx, plain, sig, mode) -> gpgme_error_t"""
    return _gpgme.gpgme_op_sign(ctx, plain, sig, mode)
GPGME_SIGSUM_VALID = _gpgme.GPGME_SIGSUM_VALID
GPGME_SIGSUM_GREEN = _gpgme.GPGME_SIGSUM_GREEN
GPGME_SIGSUM_RED = _gpgme.GPGME_SIGSUM_RED
GPGME_SIGSUM_KEY_REVOKED = _gpgme.GPGME_SIGSUM_KEY_REVOKED
GPGME_SIGSUM_KEY_EXPIRED = _gpgme.GPGME_SIGSUM_KEY_EXPIRED
GPGME_SIGSUM_SIG_EXPIRED = _gpgme.GPGME_SIGSUM_SIG_EXPIRED
GPGME_SIGSUM_KEY_MISSING = _gpgme.GPGME_SIGSUM_KEY_MISSING
GPGME_SIGSUM_CRL_MISSING = _gpgme.GPGME_SIGSUM_CRL_MISSING
GPGME_SIGSUM_CRL_TOO_OLD = _gpgme.GPGME_SIGSUM_CRL_TOO_OLD
GPGME_SIGSUM_BAD_POLICY = _gpgme.GPGME_SIGSUM_BAD_POLICY
GPGME_SIGSUM_SYS_ERROR = _gpgme.GPGME_SIGSUM_SYS_ERROR
GPGME_SIGSUM_TOFU_CONFLICT = _gpgme.GPGME_SIGSUM_TOFU_CONFLICT
class _gpgme_signature(_object):
    """Proxy of C _gpgme_signature struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_signature, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_signature, name)
    __repr__ = _swig_repr
    __swig_setmethods__["summary"] = _gpgme._gpgme_signature_summary_set
    __swig_getmethods__["summary"] = _gpgme._gpgme_signature_summary_get
    if _newclass:
        summary = _swig_property(_gpgme._gpgme_signature_summary_get, _gpgme._gpgme_signature_summary_set)
    __swig_setmethods__["fpr"] = _gpgme._gpgme_signature_fpr_set
    __swig_getmethods__["fpr"] = _gpgme._gpgme_signature_fpr_get
    if _newclass:
        fpr = _swig_property(_gpgme._gpgme_signature_fpr_get, _gpgme._gpgme_signature_fpr_set)
    __swig_setmethods__["status"] = _gpgme._gpgme_signature_status_set
    __swig_getmethods__["status"] = _gpgme._gpgme_signature_status_get
    if _newclass:
        status = _swig_property(_gpgme._gpgme_signature_status_get, _gpgme._gpgme_signature_status_set)
    __swig_setmethods__["notations"] = _gpgme._gpgme_signature_notations_set
    __swig_getmethods__["notations"] = _gpgme._gpgme_signature_notations_get
    if _newclass:
        notations = _swig_property(_gpgme._gpgme_signature_notations_get, _gpgme._gpgme_signature_notations_set)
    __swig_setmethods__["timestamp"] = _gpgme._gpgme_signature_timestamp_set
    __swig_getmethods__["timestamp"] = _gpgme._gpgme_signature_timestamp_get
    if _newclass:
        timestamp = _swig_property(_gpgme._gpgme_signature_timestamp_get, _gpgme._gpgme_signature_timestamp_set)
    __swig_setmethods__["exp_timestamp"] = _gpgme._gpgme_signature_exp_timestamp_set
    __swig_getmethods__["exp_timestamp"] = _gpgme._gpgme_signature_exp_timestamp_get
    if _newclass:
        exp_timestamp = _swig_property(_gpgme._gpgme_signature_exp_timestamp_get, _gpgme._gpgme_signature_exp_timestamp_set)
    __swig_setmethods__["wrong_key_usage"] = _gpgme._gpgme_signature_wrong_key_usage_set
    __swig_getmethods__["wrong_key_usage"] = _gpgme._gpgme_signature_wrong_key_usage_get
    if _newclass:
        wrong_key_usage = _swig_property(_gpgme._gpgme_signature_wrong_key_usage_get, _gpgme._gpgme_signature_wrong_key_usage_set)
    __swig_setmethods__["pka_trust"] = _gpgme._gpgme_signature_pka_trust_set
    __swig_getmethods__["pka_trust"] = _gpgme._gpgme_signature_pka_trust_get
    if _newclass:
        pka_trust = _swig_property(_gpgme._gpgme_signature_pka_trust_get, _gpgme._gpgme_signature_pka_trust_set)
    __swig_setmethods__["chain_model"] = _gpgme._gpgme_signature_chain_model_set
    __swig_getmethods__["chain_model"] = _gpgme._gpgme_signature_chain_model_get
    if _newclass:
        chain_model = _swig_property(_gpgme._gpgme_signature_chain_model_get, _gpgme._gpgme_signature_chain_model_set)
    __swig_setmethods__["is_de_vs"] = _gpgme._gpgme_signature_is_de_vs_set
    __swig_getmethods__["is_de_vs"] = _gpgme._gpgme_signature_is_de_vs_get
    if _newclass:
        is_de_vs = _swig_property(_gpgme._gpgme_signature_is_de_vs_get, _gpgme._gpgme_signature_is_de_vs_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_signature__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_signature__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_signature__unused_get, _gpgme._gpgme_signature__unused_set)
    __swig_setmethods__["validity"] = _gpgme._gpgme_signature_validity_set
    __swig_getmethods__["validity"] = _gpgme._gpgme_signature_validity_get
    if _newclass:
        validity = _swig_property(_gpgme._gpgme_signature_validity_get, _gpgme._gpgme_signature_validity_set)
    __swig_setmethods__["validity_reason"] = _gpgme._gpgme_signature_validity_reason_set
    __swig_getmethods__["validity_reason"] = _gpgme._gpgme_signature_validity_reason_get
    if _newclass:
        validity_reason = _swig_property(_gpgme._gpgme_signature_validity_reason_get, _gpgme._gpgme_signature_validity_reason_set)
    __swig_setmethods__["pubkey_algo"] = _gpgme._gpgme_signature_pubkey_algo_set
    __swig_getmethods__["pubkey_algo"] = _gpgme._gpgme_signature_pubkey_algo_get
    if _newclass:
        pubkey_algo = _swig_property(_gpgme._gpgme_signature_pubkey_algo_get, _gpgme._gpgme_signature_pubkey_algo_set)
    __swig_setmethods__["hash_algo"] = _gpgme._gpgme_signature_hash_algo_set
    __swig_getmethods__["hash_algo"] = _gpgme._gpgme_signature_hash_algo_get
    if _newclass:
        hash_algo = _swig_property(_gpgme._gpgme_signature_hash_algo_get, _gpgme._gpgme_signature_hash_algo_set)
    __swig_setmethods__["pka_address"] = _gpgme._gpgme_signature_pka_address_set
    __swig_getmethods__["pka_address"] = _gpgme._gpgme_signature_pka_address_get
    if _newclass:
        pka_address = _swig_property(_gpgme._gpgme_signature_pka_address_get, _gpgme._gpgme_signature_pka_address_set)
    __swig_setmethods__["key"] = _gpgme._gpgme_signature_key_set
    __swig_getmethods__["key"] = _gpgme._gpgme_signature_key_get
    if _newclass:
        key = _swig_property(_gpgme._gpgme_signature_key_get, _gpgme._gpgme_signature_key_set)

    def __init__(self):
        """__init__(self) -> _gpgme_signature"""
        this = _gpgme.new__gpgme_signature()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_signature
    __del__ = lambda self: None
_gpgme_signature_swigregister = _gpgme._gpgme_signature_swigregister
_gpgme_signature_swigregister(_gpgme_signature)

class _gpgme_op_verify_result(_object):
    """Proxy of C _gpgme_op_verify_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_verify_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_verify_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["signatures"] = _gpgme._gpgme_op_verify_result_signatures_set
    __swig_getmethods__["signatures"] = _gpgme._gpgme_op_verify_result_signatures_get
    if _newclass:
        signatures = _swig_property(_gpgme._gpgme_op_verify_result_signatures_get, _gpgme._gpgme_op_verify_result_signatures_set)
    __swig_setmethods__["file_name"] = _gpgme._gpgme_op_verify_result_file_name_set
    __swig_getmethods__["file_name"] = _gpgme._gpgme_op_verify_result_file_name_get
    if _newclass:
        file_name = _swig_property(_gpgme._gpgme_op_verify_result_file_name_get, _gpgme._gpgme_op_verify_result_file_name_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_verify_result"""
        this = _gpgme.new__gpgme_op_verify_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_verify_result
    __del__ = lambda self: None
_gpgme_op_verify_result_swigregister = _gpgme._gpgme_op_verify_result_swigregister
_gpgme_op_verify_result_swigregister(_gpgme_op_verify_result)


def gpgme_op_verify_result(ctx: 'gpgme_ctx_t') -> "gpgme_verify_result_t":
    """gpgme_op_verify_result(ctx) -> _gpgme_op_verify_result"""
    return _gpgme.gpgme_op_verify_result(ctx)

def gpgme_op_verify_start(ctx: 'gpgme_ctx_t', sig: 'gpgme_data_t', signed_text: 'gpgme_data_t', plaintext: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_verify_start(ctx, sig, signed_text, plaintext) -> gpgme_error_t"""
    return _gpgme.gpgme_op_verify_start(ctx, sig, signed_text, plaintext)

def gpgme_op_verify(ctx: 'gpgme_ctx_t', sig: 'gpgme_data_t', signed_text: 'gpgme_data_t', plaintext: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_verify(ctx, sig, signed_text, plaintext) -> gpgme_error_t"""
    return _gpgme.gpgme_op_verify(ctx, sig, signed_text, plaintext)
GPGME_IMPORT_NEW = _gpgme.GPGME_IMPORT_NEW
GPGME_IMPORT_UID = _gpgme.GPGME_IMPORT_UID
GPGME_IMPORT_SIG = _gpgme.GPGME_IMPORT_SIG
GPGME_IMPORT_SUBKEY = _gpgme.GPGME_IMPORT_SUBKEY
GPGME_IMPORT_SECRET = _gpgme.GPGME_IMPORT_SECRET
class _gpgme_import_status(_object):
    """Proxy of C _gpgme_import_status struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_import_status, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_import_status, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fpr"] = _gpgme._gpgme_import_status_fpr_set
    __swig_getmethods__["fpr"] = _gpgme._gpgme_import_status_fpr_get
    if _newclass:
        fpr = _swig_property(_gpgme._gpgme_import_status_fpr_get, _gpgme._gpgme_import_status_fpr_set)
    __swig_setmethods__["result"] = _gpgme._gpgme_import_status_result_set
    __swig_getmethods__["result"] = _gpgme._gpgme_import_status_result_get
    if _newclass:
        result = _swig_property(_gpgme._gpgme_import_status_result_get, _gpgme._gpgme_import_status_result_set)
    __swig_setmethods__["status"] = _gpgme._gpgme_import_status_status_set
    __swig_getmethods__["status"] = _gpgme._gpgme_import_status_status_get
    if _newclass:
        status = _swig_property(_gpgme._gpgme_import_status_status_get, _gpgme._gpgme_import_status_status_set)

    def __init__(self):
        """__init__(self) -> _gpgme_import_status"""
        this = _gpgme.new__gpgme_import_status()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_import_status
    __del__ = lambda self: None
_gpgme_import_status_swigregister = _gpgme._gpgme_import_status_swigregister
_gpgme_import_status_swigregister(_gpgme_import_status)

class _gpgme_op_import_result(_object):
    """Proxy of C _gpgme_op_import_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_import_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_import_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["considered"] = _gpgme._gpgme_op_import_result_considered_set
    __swig_getmethods__["considered"] = _gpgme._gpgme_op_import_result_considered_get
    if _newclass:
        considered = _swig_property(_gpgme._gpgme_op_import_result_considered_get, _gpgme._gpgme_op_import_result_considered_set)
    __swig_setmethods__["no_user_id"] = _gpgme._gpgme_op_import_result_no_user_id_set
    __swig_getmethods__["no_user_id"] = _gpgme._gpgme_op_import_result_no_user_id_get
    if _newclass:
        no_user_id = _swig_property(_gpgme._gpgme_op_import_result_no_user_id_get, _gpgme._gpgme_op_import_result_no_user_id_set)
    __swig_setmethods__["imported"] = _gpgme._gpgme_op_import_result_imported_set
    __swig_getmethods__["imported"] = _gpgme._gpgme_op_import_result_imported_get
    if _newclass:
        imported = _swig_property(_gpgme._gpgme_op_import_result_imported_get, _gpgme._gpgme_op_import_result_imported_set)
    __swig_setmethods__["imported_rsa"] = _gpgme._gpgme_op_import_result_imported_rsa_set
    __swig_getmethods__["imported_rsa"] = _gpgme._gpgme_op_import_result_imported_rsa_get
    if _newclass:
        imported_rsa = _swig_property(_gpgme._gpgme_op_import_result_imported_rsa_get, _gpgme._gpgme_op_import_result_imported_rsa_set)
    __swig_setmethods__["unchanged"] = _gpgme._gpgme_op_import_result_unchanged_set
    __swig_getmethods__["unchanged"] = _gpgme._gpgme_op_import_result_unchanged_get
    if _newclass:
        unchanged = _swig_property(_gpgme._gpgme_op_import_result_unchanged_get, _gpgme._gpgme_op_import_result_unchanged_set)
    __swig_setmethods__["new_user_ids"] = _gpgme._gpgme_op_import_result_new_user_ids_set
    __swig_getmethods__["new_user_ids"] = _gpgme._gpgme_op_import_result_new_user_ids_get
    if _newclass:
        new_user_ids = _swig_property(_gpgme._gpgme_op_import_result_new_user_ids_get, _gpgme._gpgme_op_import_result_new_user_ids_set)
    __swig_setmethods__["new_sub_keys"] = _gpgme._gpgme_op_import_result_new_sub_keys_set
    __swig_getmethods__["new_sub_keys"] = _gpgme._gpgme_op_import_result_new_sub_keys_get
    if _newclass:
        new_sub_keys = _swig_property(_gpgme._gpgme_op_import_result_new_sub_keys_get, _gpgme._gpgme_op_import_result_new_sub_keys_set)
    __swig_setmethods__["new_signatures"] = _gpgme._gpgme_op_import_result_new_signatures_set
    __swig_getmethods__["new_signatures"] = _gpgme._gpgme_op_import_result_new_signatures_get
    if _newclass:
        new_signatures = _swig_property(_gpgme._gpgme_op_import_result_new_signatures_get, _gpgme._gpgme_op_import_result_new_signatures_set)
    __swig_setmethods__["new_revocations"] = _gpgme._gpgme_op_import_result_new_revocations_set
    __swig_getmethods__["new_revocations"] = _gpgme._gpgme_op_import_result_new_revocations_get
    if _newclass:
        new_revocations = _swig_property(_gpgme._gpgme_op_import_result_new_revocations_get, _gpgme._gpgme_op_import_result_new_revocations_set)
    __swig_setmethods__["secret_read"] = _gpgme._gpgme_op_import_result_secret_read_set
    __swig_getmethods__["secret_read"] = _gpgme._gpgme_op_import_result_secret_read_get
    if _newclass:
        secret_read = _swig_property(_gpgme._gpgme_op_import_result_secret_read_get, _gpgme._gpgme_op_import_result_secret_read_set)
    __swig_setmethods__["secret_imported"] = _gpgme._gpgme_op_import_result_secret_imported_set
    __swig_getmethods__["secret_imported"] = _gpgme._gpgme_op_import_result_secret_imported_get
    if _newclass:
        secret_imported = _swig_property(_gpgme._gpgme_op_import_result_secret_imported_get, _gpgme._gpgme_op_import_result_secret_imported_set)
    __swig_setmethods__["secret_unchanged"] = _gpgme._gpgme_op_import_result_secret_unchanged_set
    __swig_getmethods__["secret_unchanged"] = _gpgme._gpgme_op_import_result_secret_unchanged_get
    if _newclass:
        secret_unchanged = _swig_property(_gpgme._gpgme_op_import_result_secret_unchanged_get, _gpgme._gpgme_op_import_result_secret_unchanged_set)
    __swig_setmethods__["skipped_new_keys"] = _gpgme._gpgme_op_import_result_skipped_new_keys_set
    __swig_getmethods__["skipped_new_keys"] = _gpgme._gpgme_op_import_result_skipped_new_keys_get
    if _newclass:
        skipped_new_keys = _swig_property(_gpgme._gpgme_op_import_result_skipped_new_keys_get, _gpgme._gpgme_op_import_result_skipped_new_keys_set)
    __swig_setmethods__["not_imported"] = _gpgme._gpgme_op_import_result_not_imported_set
    __swig_getmethods__["not_imported"] = _gpgme._gpgme_op_import_result_not_imported_get
    if _newclass:
        not_imported = _swig_property(_gpgme._gpgme_op_import_result_not_imported_get, _gpgme._gpgme_op_import_result_not_imported_set)
    __swig_setmethods__["imports"] = _gpgme._gpgme_op_import_result_imports_set
    __swig_getmethods__["imports"] = _gpgme._gpgme_op_import_result_imports_get
    if _newclass:
        imports = _swig_property(_gpgme._gpgme_op_import_result_imports_get, _gpgme._gpgme_op_import_result_imports_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_import_result"""
        this = _gpgme.new__gpgme_op_import_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_import_result
    __del__ = lambda self: None
_gpgme_op_import_result_swigregister = _gpgme._gpgme_op_import_result_swigregister
_gpgme_op_import_result_swigregister(_gpgme_op_import_result)


def gpgme_op_import_result(ctx: 'gpgme_ctx_t') -> "gpgme_import_result_t":
    """gpgme_op_import_result(ctx) -> _gpgme_op_import_result"""
    return _gpgme.gpgme_op_import_result(ctx)

def gpgme_op_import_start(ctx: 'gpgme_ctx_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_import_start(ctx, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_import_start(ctx, keydata)

def gpgme_op_import(ctx: 'gpgme_ctx_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_import(ctx, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_import(ctx, keydata)

def gpgme_op_import_keys_start(ctx: 'gpgme_ctx_t', keys: 'gpgme_key_t []') -> "gpgme_error_t":
    """gpgme_op_import_keys_start(ctx, keys) -> gpgme_error_t"""
    return _gpgme.gpgme_op_import_keys_start(ctx, keys)

def gpgme_op_import_keys(ctx: 'gpgme_ctx_t', keys: 'gpgme_key_t []') -> "gpgme_error_t":
    """gpgme_op_import_keys(ctx, keys) -> gpgme_error_t"""
    return _gpgme.gpgme_op_import_keys(ctx, keys)

def gpgme_op_export_start(ctx: 'gpgme_ctx_t', pattern: 'char const *', mode: 'gpgme_export_mode_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_export_start(ctx, pattern, mode, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_export_start(ctx, pattern, mode, keydata)

def gpgme_op_export(ctx: 'gpgme_ctx_t', pattern: 'char const *', mode: 'gpgme_export_mode_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_export(ctx, pattern, mode, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_export(ctx, pattern, mode, keydata)

def gpgme_op_export_ext_start(ctx: 'gpgme_ctx_t', pattern: 'char const *[]', mode: 'gpgme_export_mode_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_export_ext_start(ctx, pattern, mode, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_export_ext_start(ctx, pattern, mode, keydata)

def gpgme_op_export_ext(ctx: 'gpgme_ctx_t', pattern: 'char const *[]', mode: 'gpgme_export_mode_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_export_ext(ctx, pattern, mode, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_export_ext(ctx, pattern, mode, keydata)

def gpgme_op_export_keys_start(ctx: 'gpgme_ctx_t', keys: 'gpgme_key_t []', mode: 'gpgme_export_mode_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_export_keys_start(ctx, keys, mode, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_export_keys_start(ctx, keys, mode, keydata)

def gpgme_op_export_keys(ctx: 'gpgme_ctx_t', keys: 'gpgme_key_t []', mode: 'gpgme_export_mode_t', keydata: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_export_keys(ctx, keys, mode, keydata) -> gpgme_error_t"""
    return _gpgme.gpgme_op_export_keys(ctx, keys, mode, keydata)
GPGME_CREATE_SIGN = _gpgme.GPGME_CREATE_SIGN
GPGME_CREATE_ENCR = _gpgme.GPGME_CREATE_ENCR
GPGME_CREATE_CERT = _gpgme.GPGME_CREATE_CERT
GPGME_CREATE_AUTH = _gpgme.GPGME_CREATE_AUTH
GPGME_CREATE_NOPASSWD = _gpgme.GPGME_CREATE_NOPASSWD
GPGME_CREATE_SELFSIGNED = _gpgme.GPGME_CREATE_SELFSIGNED
GPGME_CREATE_NOSTORE = _gpgme.GPGME_CREATE_NOSTORE
GPGME_CREATE_WANTPUB = _gpgme.GPGME_CREATE_WANTPUB
GPGME_CREATE_WANTSEC = _gpgme.GPGME_CREATE_WANTSEC
GPGME_CREATE_FORCE = _gpgme.GPGME_CREATE_FORCE
GPGME_CREATE_NOEXPIRE = _gpgme.GPGME_CREATE_NOEXPIRE
class _gpgme_op_genkey_result(_object):
    """Proxy of C _gpgme_op_genkey_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_genkey_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_genkey_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["primary"] = _gpgme._gpgme_op_genkey_result_primary_set
    __swig_getmethods__["primary"] = _gpgme._gpgme_op_genkey_result_primary_get
    if _newclass:
        primary = _swig_property(_gpgme._gpgme_op_genkey_result_primary_get, _gpgme._gpgme_op_genkey_result_primary_set)
    __swig_setmethods__["sub"] = _gpgme._gpgme_op_genkey_result_sub_set
    __swig_getmethods__["sub"] = _gpgme._gpgme_op_genkey_result_sub_get
    if _newclass:
        sub = _swig_property(_gpgme._gpgme_op_genkey_result_sub_get, _gpgme._gpgme_op_genkey_result_sub_set)
    __swig_setmethods__["uid"] = _gpgme._gpgme_op_genkey_result_uid_set
    __swig_getmethods__["uid"] = _gpgme._gpgme_op_genkey_result_uid_get
    if _newclass:
        uid = _swig_property(_gpgme._gpgme_op_genkey_result_uid_get, _gpgme._gpgme_op_genkey_result_uid_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_op_genkey_result__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_op_genkey_result__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_op_genkey_result__unused_get, _gpgme._gpgme_op_genkey_result__unused_set)
    __swig_setmethods__["fpr"] = _gpgme._gpgme_op_genkey_result_fpr_set
    __swig_getmethods__["fpr"] = _gpgme._gpgme_op_genkey_result_fpr_get
    if _newclass:
        fpr = _swig_property(_gpgme._gpgme_op_genkey_result_fpr_get, _gpgme._gpgme_op_genkey_result_fpr_set)
    __swig_setmethods__["pubkey"] = _gpgme._gpgme_op_genkey_result_pubkey_set
    __swig_getmethods__["pubkey"] = _gpgme._gpgme_op_genkey_result_pubkey_get
    if _newclass:
        pubkey = _swig_property(_gpgme._gpgme_op_genkey_result_pubkey_get, _gpgme._gpgme_op_genkey_result_pubkey_set)
    __swig_setmethods__["seckey"] = _gpgme._gpgme_op_genkey_result_seckey_set
    __swig_getmethods__["seckey"] = _gpgme._gpgme_op_genkey_result_seckey_get
    if _newclass:
        seckey = _swig_property(_gpgme._gpgme_op_genkey_result_seckey_get, _gpgme._gpgme_op_genkey_result_seckey_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_genkey_result"""
        this = _gpgme.new__gpgme_op_genkey_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_genkey_result
    __del__ = lambda self: None
_gpgme_op_genkey_result_swigregister = _gpgme._gpgme_op_genkey_result_swigregister
_gpgme_op_genkey_result_swigregister(_gpgme_op_genkey_result)


def gpgme_op_genkey_start(ctx: 'gpgme_ctx_t', parms: 'char const *', pubkey: 'gpgme_data_t', seckey: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_genkey_start(ctx, parms, pubkey, seckey) -> gpgme_error_t"""
    return _gpgme.gpgme_op_genkey_start(ctx, parms, pubkey, seckey)

def gpgme_op_genkey(ctx: 'gpgme_ctx_t', parms: 'char const *', pubkey: 'gpgme_data_t', seckey: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_genkey(ctx, parms, pubkey, seckey) -> gpgme_error_t"""
    return _gpgme.gpgme_op_genkey(ctx, parms, pubkey, seckey)

def gpgme_op_createkey_start(ctx: 'gpgme_ctx_t', userid: 'char const *', algo: 'char const *', reserved: 'unsigned long', expires: 'unsigned long', certkey: '_gpgme_key', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_createkey_start(ctx, userid, algo, reserved, expires, certkey, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_createkey_start(ctx, userid, algo, reserved, expires, certkey, flags)

def gpgme_op_createkey(ctx: 'gpgme_ctx_t', userid: 'char const *', algo: 'char const *', reserved: 'unsigned long', expires: 'unsigned long', certkey: '_gpgme_key', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_createkey(ctx, userid, algo, reserved, expires, certkey, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_createkey(ctx, userid, algo, reserved, expires, certkey, flags)

def gpgme_op_createsubkey_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', algo: 'char const *', reserved: 'unsigned long', expires: 'unsigned long', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_createsubkey_start(ctx, key, algo, reserved, expires, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_createsubkey_start(ctx, key, algo, reserved, expires, flags)

def gpgme_op_createsubkey(ctx: 'gpgme_ctx_t', key: '_gpgme_key', algo: 'char const *', reserved: 'unsigned long', expires: 'unsigned long', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_createsubkey(ctx, key, algo, reserved, expires, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_createsubkey(ctx, key, algo, reserved, expires, flags)

def gpgme_op_adduid_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', reserved: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_adduid_start(ctx, key, userid, reserved) -> gpgme_error_t"""
    return _gpgme.gpgme_op_adduid_start(ctx, key, userid, reserved)

def gpgme_op_adduid(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', reserved: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_adduid(ctx, key, userid, reserved) -> gpgme_error_t"""
    return _gpgme.gpgme_op_adduid(ctx, key, userid, reserved)

def gpgme_op_revuid_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', reserved: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_revuid_start(ctx, key, userid, reserved) -> gpgme_error_t"""
    return _gpgme.gpgme_op_revuid_start(ctx, key, userid, reserved)

def gpgme_op_revuid(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', reserved: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_revuid(ctx, key, userid, reserved) -> gpgme_error_t"""
    return _gpgme.gpgme_op_revuid(ctx, key, userid, reserved)

def gpgme_op_set_uid_flag_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', name: 'char const *', value: 'char const *') -> "gpgme_error_t":
    """gpgme_op_set_uid_flag_start(ctx, key, userid, name, value) -> gpgme_error_t"""
    return _gpgme.gpgme_op_set_uid_flag_start(ctx, key, userid, name, value)

def gpgme_op_set_uid_flag(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', name: 'char const *', value: 'char const *') -> "gpgme_error_t":
    """gpgme_op_set_uid_flag(ctx, key, userid, name, value) -> gpgme_error_t"""
    return _gpgme.gpgme_op_set_uid_flag(ctx, key, userid, name, value)

def gpgme_op_genkey_result(ctx: 'gpgme_ctx_t') -> "gpgme_genkey_result_t":
    """gpgme_op_genkey_result(ctx) -> _gpgme_op_genkey_result"""
    return _gpgme.gpgme_op_genkey_result(ctx)

def gpgme_op_delete_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', allow_secret: 'int') -> "gpgme_error_t":
    """gpgme_op_delete_start(ctx, key, allow_secret) -> gpgme_error_t"""
    return _gpgme.gpgme_op_delete_start(ctx, key, allow_secret)

def gpgme_op_delete(ctx: 'gpgme_ctx_t', key: '_gpgme_key', allow_secret: 'int') -> "gpgme_error_t":
    """gpgme_op_delete(ctx, key, allow_secret) -> gpgme_error_t"""
    return _gpgme.gpgme_op_delete(ctx, key, allow_secret)
GPGME_DELETE_ALLOW_SECRET = _gpgme.GPGME_DELETE_ALLOW_SECRET
GPGME_DELETE_FORCE = _gpgme.GPGME_DELETE_FORCE

def gpgme_op_delete_ext_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_delete_ext_start(ctx, key, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_delete_ext_start(ctx, key, flags)

def gpgme_op_delete_ext(ctx: 'gpgme_ctx_t', key: '_gpgme_key', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_delete_ext(ctx, key, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_delete_ext(ctx, key, flags)
GPGME_KEYSIGN_LOCAL = _gpgme.GPGME_KEYSIGN_LOCAL
GPGME_KEYSIGN_LFSEP = _gpgme.GPGME_KEYSIGN_LFSEP
GPGME_KEYSIGN_NOEXPIRE = _gpgme.GPGME_KEYSIGN_NOEXPIRE

def gpgme_op_keysign_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', expires: 'unsigned long', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_keysign_start(ctx, key, userid, expires, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_keysign_start(ctx, key, userid, expires, flags)

def gpgme_op_keysign(ctx: 'gpgme_ctx_t', key: '_gpgme_key', userid: 'char const *', expires: 'unsigned long', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_keysign(ctx, key, userid, expires, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_keysign(ctx, key, userid, expires, flags)
GPGME_INTERACT_CARD = _gpgme.GPGME_INTERACT_CARD

def gpgme_op_interact_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', flags: 'unsigned int', fnc: 'gpgme_interact_cb_t', out: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_interact_start(ctx, key, flags, fnc, out) -> gpgme_error_t"""
    return _gpgme.gpgme_op_interact_start(ctx, key, flags, fnc, out)

def gpgme_op_interact(ctx: 'gpgme_ctx_t', key: '_gpgme_key', flags: 'unsigned int', fnc: 'gpgme_interact_cb_t', out: 'gpgme_data_t') -> "gpgme_error_t":
    """gpgme_op_interact(ctx, key, flags, fnc, out) -> gpgme_error_t"""
    return _gpgme.gpgme_op_interact(ctx, key, flags, fnc, out)

def gpgme_op_tofu_policy_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', policy: 'gpgme_tofu_policy_t') -> "gpgme_error_t":
    """gpgme_op_tofu_policy_start(ctx, key, policy) -> gpgme_error_t"""
    return _gpgme.gpgme_op_tofu_policy_start(ctx, key, policy)

def gpgme_op_tofu_policy(ctx: 'gpgme_ctx_t', key: '_gpgme_key', policy: 'gpgme_tofu_policy_t') -> "gpgme_error_t":
    """gpgme_op_tofu_policy(ctx, key, policy) -> gpgme_error_t"""
    return _gpgme.gpgme_op_tofu_policy(ctx, key, policy)
class _gpgme_op_keylist_result(_object):
    """Proxy of C _gpgme_op_keylist_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_keylist_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_keylist_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["truncated"] = _gpgme._gpgme_op_keylist_result_truncated_set
    __swig_getmethods__["truncated"] = _gpgme._gpgme_op_keylist_result_truncated_get
    if _newclass:
        truncated = _swig_property(_gpgme._gpgme_op_keylist_result_truncated_get, _gpgme._gpgme_op_keylist_result_truncated_set)
    __swig_setmethods__["_unused"] = _gpgme._gpgme_op_keylist_result__unused_set
    __swig_getmethods__["_unused"] = _gpgme._gpgme_op_keylist_result__unused_get
    if _newclass:
        _unused = _swig_property(_gpgme._gpgme_op_keylist_result__unused_get, _gpgme._gpgme_op_keylist_result__unused_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_keylist_result"""
        this = _gpgme.new__gpgme_op_keylist_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_keylist_result
    __del__ = lambda self: None
_gpgme_op_keylist_result_swigregister = _gpgme._gpgme_op_keylist_result_swigregister
_gpgme_op_keylist_result_swigregister(_gpgme_op_keylist_result)


def gpgme_op_keylist_result(ctx: 'gpgme_ctx_t') -> "gpgme_keylist_result_t":
    """gpgme_op_keylist_result(ctx) -> _gpgme_op_keylist_result"""
    return _gpgme.gpgme_op_keylist_result(ctx)

def gpgme_op_keylist_ext_start(ctx: 'gpgme_ctx_t', pattern: 'char const *[]', secret_only: 'int', reserved: 'int') -> "gpgme_error_t":
    """gpgme_op_keylist_ext_start(ctx, pattern, secret_only, reserved) -> gpgme_error_t"""
    return _gpgme.gpgme_op_keylist_ext_start(ctx, pattern, secret_only, reserved)

def gpgme_op_keylist_from_data_start(ctx: 'gpgme_ctx_t', data: 'gpgme_data_t', reserved: 'int') -> "gpgme_error_t":
    """gpgme_op_keylist_from_data_start(ctx, data, reserved) -> gpgme_error_t"""
    return _gpgme.gpgme_op_keylist_from_data_start(ctx, data, reserved)

def gpgme_op_keylist_next(ctx: 'gpgme_ctx_t', r_key: 'gpgme_key_t *') -> "gpgme_error_t":
    """gpgme_op_keylist_next(ctx, r_key) -> gpgme_error_t"""
    return _gpgme.gpgme_op_keylist_next(ctx, r_key)

def gpgme_op_keylist_end(ctx: 'gpgme_ctx_t') -> "gpgme_error_t":
    """gpgme_op_keylist_end(ctx) -> gpgme_error_t"""
    return _gpgme.gpgme_op_keylist_end(ctx)

def gpgme_op_passwd_start(ctx: 'gpgme_ctx_t', key: '_gpgme_key', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_passwd_start(ctx, key, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_passwd_start(ctx, key, flags)

def gpgme_op_passwd(ctx: 'gpgme_ctx_t', key: '_gpgme_key', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_passwd(ctx, key, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_passwd(ctx, key, flags)
class _gpgme_trust_item(_object):
    """Proxy of C _gpgme_trust_item struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_trust_item, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_trust_item, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_refs"] = _gpgme._gpgme_trust_item__refs_set
    __swig_getmethods__["_refs"] = _gpgme._gpgme_trust_item__refs_get
    if _newclass:
        _refs = _swig_property(_gpgme._gpgme_trust_item__refs_get, _gpgme._gpgme_trust_item__refs_set)
    __swig_setmethods__["keyid"] = _gpgme._gpgme_trust_item_keyid_set
    __swig_getmethods__["keyid"] = _gpgme._gpgme_trust_item_keyid_get
    if _newclass:
        keyid = _swig_property(_gpgme._gpgme_trust_item_keyid_get, _gpgme._gpgme_trust_item_keyid_set)
    __swig_setmethods__["_keyid"] = _gpgme._gpgme_trust_item__keyid_set
    __swig_getmethods__["_keyid"] = _gpgme._gpgme_trust_item__keyid_get
    if _newclass:
        _keyid = _swig_property(_gpgme._gpgme_trust_item__keyid_get, _gpgme._gpgme_trust_item__keyid_set)
    __swig_setmethods__["type"] = _gpgme._gpgme_trust_item_type_set
    __swig_getmethods__["type"] = _gpgme._gpgme_trust_item_type_get
    if _newclass:
        type = _swig_property(_gpgme._gpgme_trust_item_type_get, _gpgme._gpgme_trust_item_type_set)
    __swig_setmethods__["level"] = _gpgme._gpgme_trust_item_level_set
    __swig_getmethods__["level"] = _gpgme._gpgme_trust_item_level_get
    if _newclass:
        level = _swig_property(_gpgme._gpgme_trust_item_level_get, _gpgme._gpgme_trust_item_level_set)
    __swig_setmethods__["owner_trust"] = _gpgme._gpgme_trust_item_owner_trust_set
    __swig_getmethods__["owner_trust"] = _gpgme._gpgme_trust_item_owner_trust_get
    if _newclass:
        owner_trust = _swig_property(_gpgme._gpgme_trust_item_owner_trust_get, _gpgme._gpgme_trust_item_owner_trust_set)
    __swig_setmethods__["_owner_trust"] = _gpgme._gpgme_trust_item__owner_trust_set
    __swig_getmethods__["_owner_trust"] = _gpgme._gpgme_trust_item__owner_trust_get
    if _newclass:
        _owner_trust = _swig_property(_gpgme._gpgme_trust_item__owner_trust_get, _gpgme._gpgme_trust_item__owner_trust_set)
    __swig_setmethods__["validity"] = _gpgme._gpgme_trust_item_validity_set
    __swig_getmethods__["validity"] = _gpgme._gpgme_trust_item_validity_get
    if _newclass:
        validity = _swig_property(_gpgme._gpgme_trust_item_validity_get, _gpgme._gpgme_trust_item_validity_set)
    __swig_setmethods__["_validity"] = _gpgme._gpgme_trust_item__validity_set
    __swig_getmethods__["_validity"] = _gpgme._gpgme_trust_item__validity_get
    if _newclass:
        _validity = _swig_property(_gpgme._gpgme_trust_item__validity_get, _gpgme._gpgme_trust_item__validity_set)
    __swig_setmethods__["name"] = _gpgme._gpgme_trust_item_name_set
    __swig_getmethods__["name"] = _gpgme._gpgme_trust_item_name_get
    if _newclass:
        name = _swig_property(_gpgme._gpgme_trust_item_name_get, _gpgme._gpgme_trust_item_name_set)

    def __init__(self):
        """__init__(self) -> _gpgme_trust_item"""
        this = _gpgme.new__gpgme_trust_item()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_trust_item
    __del__ = lambda self: None
_gpgme_trust_item_swigregister = _gpgme._gpgme_trust_item_swigregister
_gpgme_trust_item_swigregister(_gpgme_trust_item)


def gpgme_op_trustlist_start(ctx: 'gpgme_ctx_t', pattern: 'char const *', max_level: 'int') -> "gpgme_error_t":
    """gpgme_op_trustlist_start(ctx, pattern, max_level) -> gpgme_error_t"""
    return _gpgme.gpgme_op_trustlist_start(ctx, pattern, max_level)

def gpgme_op_trustlist_next(ctx: 'gpgme_ctx_t', r_item: 'gpgme_trust_item_t *') -> "gpgme_error_t":
    """gpgme_op_trustlist_next(ctx, r_item) -> gpgme_error_t"""
    return _gpgme.gpgme_op_trustlist_next(ctx, r_item)

def gpgme_op_trustlist_end(ctx: 'gpgme_ctx_t') -> "gpgme_error_t":
    """gpgme_op_trustlist_end(ctx) -> gpgme_error_t"""
    return _gpgme.gpgme_op_trustlist_end(ctx)

def gpgme_trust_item_ref(item: '_gpgme_trust_item') -> "void":
    """gpgme_trust_item_ref(item)"""
    return _gpgme.gpgme_trust_item_ref(item)

def gpgme_trust_item_unref(item: '_gpgme_trust_item') -> "void":
    """gpgme_trust_item_unref(item)"""
    return _gpgme.gpgme_trust_item_unref(item)

def gpgme_op_getauditlog_start(ctx: 'gpgme_ctx_t', output: 'gpgme_data_t', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_getauditlog_start(ctx, output, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_getauditlog_start(ctx, output, flags)

def gpgme_op_getauditlog(ctx: 'gpgme_ctx_t', output: 'gpgme_data_t', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_getauditlog(ctx, output, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_getauditlog(ctx, output, flags)
GPGME_SPAWN_DETACHED = _gpgme.GPGME_SPAWN_DETACHED
GPGME_SPAWN_ALLOW_SET_FG = _gpgme.GPGME_SPAWN_ALLOW_SET_FG

def gpgme_op_spawn_start(ctx: 'gpgme_ctx_t', file: 'char const *', argv: 'char const *[]', datain: 'gpgme_data_t', dataout: 'gpgme_data_t', dataerr: 'gpgme_data_t', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_spawn_start(ctx, file, argv, datain, dataout, dataerr, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_spawn_start(ctx, file, argv, datain, dataout, dataerr, flags)

def gpgme_op_spawn(ctx: 'gpgme_ctx_t', file: 'char const *', argv: 'char const *[]', datain: 'gpgme_data_t', dataout: 'gpgme_data_t', dataerr: 'gpgme_data_t', flags: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_spawn(ctx, file, argv, datain, dataout, dataerr, flags) -> gpgme_error_t"""
    return _gpgme.gpgme_op_spawn(ctx, file, argv, datain, dataout, dataerr, flags)

def gpgme_op_assuan_transact_start(ctx: 'gpgme_ctx_t', command: 'char const *', data_cb: 'gpgme_assuan_data_cb_t', inq_cb: 'gpgme_assuan_inquire_cb_t', stat_cb: 'gpgme_assuan_status_cb_t') -> "gpgme_error_t":
    """gpgme_op_assuan_transact_start(ctx, command, data_cb, inq_cb, stat_cb) -> gpgme_error_t"""
    return _gpgme.gpgme_op_assuan_transact_start(ctx, command, data_cb, inq_cb, stat_cb)

def gpgme_op_assuan_transact_ext(ctx: 'gpgme_ctx_t', command: 'char const *', data_cb: 'gpgme_assuan_data_cb_t', inq_cb: 'gpgme_assuan_inquire_cb_t', stat_cb: 'gpgme_assuan_status_cb_t', op_err: 'gpgme_error_t *') -> "gpgme_error_t":
    """gpgme_op_assuan_transact_ext(ctx, command, data_cb, inq_cb, stat_cb, op_err) -> gpgme_error_t"""
    return _gpgme.gpgme_op_assuan_transact_ext(ctx, command, data_cb, inq_cb, stat_cb, op_err)
class _gpgme_op_vfs_mount_result(_object):
    """Proxy of C _gpgme_op_vfs_mount_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_vfs_mount_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_vfs_mount_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mount_dir"] = _gpgme._gpgme_op_vfs_mount_result_mount_dir_set
    __swig_getmethods__["mount_dir"] = _gpgme._gpgme_op_vfs_mount_result_mount_dir_get
    if _newclass:
        mount_dir = _swig_property(_gpgme._gpgme_op_vfs_mount_result_mount_dir_get, _gpgme._gpgme_op_vfs_mount_result_mount_dir_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_vfs_mount_result"""
        this = _gpgme.new__gpgme_op_vfs_mount_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_vfs_mount_result
    __del__ = lambda self: None
_gpgme_op_vfs_mount_result_swigregister = _gpgme._gpgme_op_vfs_mount_result_swigregister
_gpgme_op_vfs_mount_result_swigregister(_gpgme_op_vfs_mount_result)


def gpgme_op_vfs_mount_result(ctx: 'gpgme_ctx_t') -> "gpgme_vfs_mount_result_t":
    """gpgme_op_vfs_mount_result(ctx) -> _gpgme_op_vfs_mount_result"""
    return _gpgme.gpgme_op_vfs_mount_result(ctx)

def gpgme_op_vfs_mount(ctx: 'gpgme_ctx_t', container_file: 'char const *', mount_dir: 'char const *', flags: 'unsigned int', op_err: 'gpgme_error_t *') -> "gpgme_error_t":
    """gpgme_op_vfs_mount(ctx, container_file, mount_dir, flags, op_err) -> gpgme_error_t"""
    return _gpgme.gpgme_op_vfs_mount(ctx, container_file, mount_dir, flags, op_err)

def gpgme_op_vfs_create(ctx: 'gpgme_ctx_t', recp: 'gpgme_key_t []', container_file: 'char const *', flags: 'unsigned int', op_err: 'gpgme_error_t *') -> "gpgme_error_t":
    """gpgme_op_vfs_create(ctx, recp, container_file, flags, op_err) -> gpgme_error_t"""
    return _gpgme.gpgme_op_vfs_create(ctx, recp, container_file, flags, op_err)
GPGME_CONF_BASIC = _gpgme.GPGME_CONF_BASIC
GPGME_CONF_ADVANCED = _gpgme.GPGME_CONF_ADVANCED
GPGME_CONF_EXPERT = _gpgme.GPGME_CONF_EXPERT
GPGME_CONF_INVISIBLE = _gpgme.GPGME_CONF_INVISIBLE
GPGME_CONF_INTERNAL = _gpgme.GPGME_CONF_INTERNAL
GPGME_CONF_NONE = _gpgme.GPGME_CONF_NONE
GPGME_CONF_STRING = _gpgme.GPGME_CONF_STRING
GPGME_CONF_INT32 = _gpgme.GPGME_CONF_INT32
GPGME_CONF_UINT32 = _gpgme.GPGME_CONF_UINT32
GPGME_CONF_FILENAME = _gpgme.GPGME_CONF_FILENAME
GPGME_CONF_LDAP_SERVER = _gpgme.GPGME_CONF_LDAP_SERVER
GPGME_CONF_KEY_FPR = _gpgme.GPGME_CONF_KEY_FPR
GPGME_CONF_PUB_KEY = _gpgme.GPGME_CONF_PUB_KEY
GPGME_CONF_SEC_KEY = _gpgme.GPGME_CONF_SEC_KEY
GPGME_CONF_ALIAS_LIST = _gpgme.GPGME_CONF_ALIAS_LIST
class gpgme_conf_arg(_object):
    """Proxy of C gpgme_conf_arg struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gpgme_conf_arg, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gpgme_conf_arg, name)
    __repr__ = _swig_repr
    __swig_setmethods__["no_arg"] = _gpgme.gpgme_conf_arg_no_arg_set
    __swig_getmethods__["no_arg"] = _gpgme.gpgme_conf_arg_no_arg_get
    if _newclass:
        no_arg = _swig_property(_gpgme.gpgme_conf_arg_no_arg_get, _gpgme.gpgme_conf_arg_no_arg_set)
    __swig_getmethods__["value"] = _gpgme.gpgme_conf_arg_value_get
    if _newclass:
        value = _swig_property(_gpgme.gpgme_conf_arg_value_get)

    def __init__(self):
        """__init__(self) -> gpgme_conf_arg"""
        this = _gpgme.new_gpgme_conf_arg()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete_gpgme_conf_arg
    __del__ = lambda self: None
gpgme_conf_arg_swigregister = _gpgme.gpgme_conf_arg_swigregister
gpgme_conf_arg_swigregister(gpgme_conf_arg)

class gpgme_conf_arg_value(_object):
    """Proxy of C gpgme_conf_arg_value struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gpgme_conf_arg_value, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gpgme_conf_arg_value, name)
    __repr__ = _swig_repr
    __swig_setmethods__["count"] = _gpgme.gpgme_conf_arg_value_count_set
    __swig_getmethods__["count"] = _gpgme.gpgme_conf_arg_value_count_get
    if _newclass:
        count = _swig_property(_gpgme.gpgme_conf_arg_value_count_get, _gpgme.gpgme_conf_arg_value_count_set)
    __swig_setmethods__["uint32"] = _gpgme.gpgme_conf_arg_value_uint32_set
    __swig_getmethods__["uint32"] = _gpgme.gpgme_conf_arg_value_uint32_get
    if _newclass:
        uint32 = _swig_property(_gpgme.gpgme_conf_arg_value_uint32_get, _gpgme.gpgme_conf_arg_value_uint32_set)
    __swig_setmethods__["int32"] = _gpgme.gpgme_conf_arg_value_int32_set
    __swig_getmethods__["int32"] = _gpgme.gpgme_conf_arg_value_int32_get
    if _newclass:
        int32 = _swig_property(_gpgme.gpgme_conf_arg_value_int32_get, _gpgme.gpgme_conf_arg_value_int32_set)
    __swig_setmethods__["string"] = _gpgme.gpgme_conf_arg_value_string_set
    __swig_getmethods__["string"] = _gpgme.gpgme_conf_arg_value_string_get
    if _newclass:
        string = _swig_property(_gpgme.gpgme_conf_arg_value_string_get, _gpgme.gpgme_conf_arg_value_string_set)

    def __init__(self):
        """__init__(self) -> gpgme_conf_arg_value"""
        this = _gpgme.new_gpgme_conf_arg_value()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete_gpgme_conf_arg_value
    __del__ = lambda self: None
gpgme_conf_arg_value_swigregister = _gpgme.gpgme_conf_arg_value_swigregister
gpgme_conf_arg_value_swigregister(gpgme_conf_arg_value)

GPGME_CONF_GROUP = _gpgme.GPGME_CONF_GROUP
GPGME_CONF_OPTIONAL = _gpgme.GPGME_CONF_OPTIONAL
GPGME_CONF_LIST = _gpgme.GPGME_CONF_LIST
GPGME_CONF_RUNTIME = _gpgme.GPGME_CONF_RUNTIME
GPGME_CONF_DEFAULT = _gpgme.GPGME_CONF_DEFAULT
GPGME_CONF_DEFAULT_DESC = _gpgme.GPGME_CONF_DEFAULT_DESC
GPGME_CONF_NO_ARG_DESC = _gpgme.GPGME_CONF_NO_ARG_DESC
GPGME_CONF_NO_CHANGE = _gpgme.GPGME_CONF_NO_CHANGE
class gpgme_conf_opt(_object):
    """Proxy of C gpgme_conf_opt struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gpgme_conf_opt, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gpgme_conf_opt, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _gpgme.gpgme_conf_opt_name_set
    __swig_getmethods__["name"] = _gpgme.gpgme_conf_opt_name_get
    if _newclass:
        name = _swig_property(_gpgme.gpgme_conf_opt_name_get, _gpgme.gpgme_conf_opt_name_set)
    __swig_setmethods__["flags"] = _gpgme.gpgme_conf_opt_flags_set
    __swig_getmethods__["flags"] = _gpgme.gpgme_conf_opt_flags_get
    if _newclass:
        flags = _swig_property(_gpgme.gpgme_conf_opt_flags_get, _gpgme.gpgme_conf_opt_flags_set)
    __swig_setmethods__["level"] = _gpgme.gpgme_conf_opt_level_set
    __swig_getmethods__["level"] = _gpgme.gpgme_conf_opt_level_get
    if _newclass:
        level = _swig_property(_gpgme.gpgme_conf_opt_level_get, _gpgme.gpgme_conf_opt_level_set)
    __swig_setmethods__["description"] = _gpgme.gpgme_conf_opt_description_set
    __swig_getmethods__["description"] = _gpgme.gpgme_conf_opt_description_get
    if _newclass:
        description = _swig_property(_gpgme.gpgme_conf_opt_description_get, _gpgme.gpgme_conf_opt_description_set)
    __swig_setmethods__["type"] = _gpgme.gpgme_conf_opt_type_set
    __swig_getmethods__["type"] = _gpgme.gpgme_conf_opt_type_get
    if _newclass:
        type = _swig_property(_gpgme.gpgme_conf_opt_type_get, _gpgme.gpgme_conf_opt_type_set)
    __swig_setmethods__["alt_type"] = _gpgme.gpgme_conf_opt_alt_type_set
    __swig_getmethods__["alt_type"] = _gpgme.gpgme_conf_opt_alt_type_get
    if _newclass:
        alt_type = _swig_property(_gpgme.gpgme_conf_opt_alt_type_get, _gpgme.gpgme_conf_opt_alt_type_set)
    __swig_setmethods__["argname"] = _gpgme.gpgme_conf_opt_argname_set
    __swig_getmethods__["argname"] = _gpgme.gpgme_conf_opt_argname_get
    if _newclass:
        argname = _swig_property(_gpgme.gpgme_conf_opt_argname_get, _gpgme.gpgme_conf_opt_argname_set)
    __swig_setmethods__["default_value"] = _gpgme.gpgme_conf_opt_default_value_set
    __swig_getmethods__["default_value"] = _gpgme.gpgme_conf_opt_default_value_get
    if _newclass:
        default_value = _swig_property(_gpgme.gpgme_conf_opt_default_value_get, _gpgme.gpgme_conf_opt_default_value_set)
    __swig_setmethods__["default_description"] = _gpgme.gpgme_conf_opt_default_description_set
    __swig_getmethods__["default_description"] = _gpgme.gpgme_conf_opt_default_description_get
    if _newclass:
        default_description = _swig_property(_gpgme.gpgme_conf_opt_default_description_get, _gpgme.gpgme_conf_opt_default_description_set)
    __swig_setmethods__["no_arg_value"] = _gpgme.gpgme_conf_opt_no_arg_value_set
    __swig_getmethods__["no_arg_value"] = _gpgme.gpgme_conf_opt_no_arg_value_get
    if _newclass:
        no_arg_value = _swig_property(_gpgme.gpgme_conf_opt_no_arg_value_get, _gpgme.gpgme_conf_opt_no_arg_value_set)
    __swig_setmethods__["no_arg_description"] = _gpgme.gpgme_conf_opt_no_arg_description_set
    __swig_getmethods__["no_arg_description"] = _gpgme.gpgme_conf_opt_no_arg_description_get
    if _newclass:
        no_arg_description = _swig_property(_gpgme.gpgme_conf_opt_no_arg_description_get, _gpgme.gpgme_conf_opt_no_arg_description_set)
    __swig_setmethods__["value"] = _gpgme.gpgme_conf_opt_value_set
    __swig_getmethods__["value"] = _gpgme.gpgme_conf_opt_value_get
    if _newclass:
        value = _swig_property(_gpgme.gpgme_conf_opt_value_get, _gpgme.gpgme_conf_opt_value_set)
    __swig_setmethods__["change_value"] = _gpgme.gpgme_conf_opt_change_value_set
    __swig_getmethods__["change_value"] = _gpgme.gpgme_conf_opt_change_value_get
    if _newclass:
        change_value = _swig_property(_gpgme.gpgme_conf_opt_change_value_get, _gpgme.gpgme_conf_opt_change_value_set)
    __swig_setmethods__["new_value"] = _gpgme.gpgme_conf_opt_new_value_set
    __swig_getmethods__["new_value"] = _gpgme.gpgme_conf_opt_new_value_get
    if _newclass:
        new_value = _swig_property(_gpgme.gpgme_conf_opt_new_value_get, _gpgme.gpgme_conf_opt_new_value_set)
    __swig_setmethods__["user_data"] = _gpgme.gpgme_conf_opt_user_data_set
    __swig_getmethods__["user_data"] = _gpgme.gpgme_conf_opt_user_data_get
    if _newclass:
        user_data = _swig_property(_gpgme.gpgme_conf_opt_user_data_get, _gpgme.gpgme_conf_opt_user_data_set)

    def __init__(self):
        """__init__(self) -> gpgme_conf_opt"""
        this = _gpgme.new_gpgme_conf_opt()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete_gpgme_conf_opt
    __del__ = lambda self: None
gpgme_conf_opt_swigregister = _gpgme.gpgme_conf_opt_swigregister
gpgme_conf_opt_swigregister(gpgme_conf_opt)

class gpgme_conf_comp(_object):
    """Proxy of C gpgme_conf_comp struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gpgme_conf_comp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gpgme_conf_comp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_last_opt_p"] = _gpgme.gpgme_conf_comp__last_opt_p_set
    __swig_getmethods__["_last_opt_p"] = _gpgme.gpgme_conf_comp__last_opt_p_get
    if _newclass:
        _last_opt_p = _swig_property(_gpgme.gpgme_conf_comp__last_opt_p_get, _gpgme.gpgme_conf_comp__last_opt_p_set)
    __swig_setmethods__["name"] = _gpgme.gpgme_conf_comp_name_set
    __swig_getmethods__["name"] = _gpgme.gpgme_conf_comp_name_get
    if _newclass:
        name = _swig_property(_gpgme.gpgme_conf_comp_name_get, _gpgme.gpgme_conf_comp_name_set)
    __swig_setmethods__["description"] = _gpgme.gpgme_conf_comp_description_set
    __swig_getmethods__["description"] = _gpgme.gpgme_conf_comp_description_get
    if _newclass:
        description = _swig_property(_gpgme.gpgme_conf_comp_description_get, _gpgme.gpgme_conf_comp_description_set)
    __swig_setmethods__["program_name"] = _gpgme.gpgme_conf_comp_program_name_set
    __swig_getmethods__["program_name"] = _gpgme.gpgme_conf_comp_program_name_get
    if _newclass:
        program_name = _swig_property(_gpgme.gpgme_conf_comp_program_name_get, _gpgme.gpgme_conf_comp_program_name_set)
    __swig_setmethods__["options"] = _gpgme.gpgme_conf_comp_options_set
    __swig_getmethods__["options"] = _gpgme.gpgme_conf_comp_options_get
    if _newclass:
        options = _swig_property(_gpgme.gpgme_conf_comp_options_get, _gpgme.gpgme_conf_comp_options_set)

    def __init__(self):
        """__init__(self) -> gpgme_conf_comp"""
        this = _gpgme.new_gpgme_conf_comp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete_gpgme_conf_comp
    __del__ = lambda self: None
gpgme_conf_comp_swigregister = _gpgme.gpgme_conf_comp_swigregister
gpgme_conf_comp_swigregister(gpgme_conf_comp)


def gpgme_conf_arg_new(arg_p: 'gpgme_conf_arg_t *', type: 'gpgme_conf_type_t', value: 'void const *') -> "gpgme_error_t":
    """gpgme_conf_arg_new(arg_p, type, value) -> gpgme_error_t"""
    return _gpgme.gpgme_conf_arg_new(arg_p, type, value)

def gpgme_conf_arg_release(arg: 'gpgme_conf_arg', type: 'gpgme_conf_type_t') -> "void":
    """gpgme_conf_arg_release(arg, type)"""
    return _gpgme.gpgme_conf_arg_release(arg, type)

def gpgme_conf_opt_change(opt: 'gpgme_conf_opt', reset: 'int', arg: 'gpgme_conf_arg') -> "gpgme_error_t":
    """gpgme_conf_opt_change(opt, reset, arg) -> gpgme_error_t"""
    return _gpgme.gpgme_conf_opt_change(opt, reset, arg)

def gpgme_conf_release(conf: 'gpgme_conf_comp') -> "void":
    """gpgme_conf_release(conf)"""
    return _gpgme.gpgme_conf_release(conf)

def gpgme_op_conf_load(ctx: 'gpgme_ctx_t', conf_p: 'gpgme_conf_comp_t *') -> "gpgme_error_t":
    """gpgme_op_conf_load(ctx, conf_p) -> gpgme_error_t"""
    return _gpgme.gpgme_op_conf_load(ctx, conf_p)

def gpgme_op_conf_save(ctx: 'gpgme_ctx_t', comp: 'gpgme_conf_comp') -> "gpgme_error_t":
    """gpgme_op_conf_save(ctx, comp) -> gpgme_error_t"""
    return _gpgme.gpgme_op_conf_save(ctx, comp)

def gpgme_op_conf_dir(ctx: 'gpgme_ctx_t', what: 'char const *', result: 'char **') -> "gpgme_error_t":
    """gpgme_op_conf_dir(ctx, what, result) -> gpgme_error_t"""
    return _gpgme.gpgme_op_conf_dir(ctx, what, result)
class _gpgme_op_query_swdb_result(_object):
    """Proxy of C _gpgme_op_query_swdb_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_query_swdb_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_query_swdb_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _gpgme._gpgme_op_query_swdb_result_name_set
    __swig_getmethods__["name"] = _gpgme._gpgme_op_query_swdb_result_name_get
    if _newclass:
        name = _swig_property(_gpgme._gpgme_op_query_swdb_result_name_get, _gpgme._gpgme_op_query_swdb_result_name_set)
    __swig_setmethods__["iversion"] = _gpgme._gpgme_op_query_swdb_result_iversion_set
    __swig_getmethods__["iversion"] = _gpgme._gpgme_op_query_swdb_result_iversion_get
    if _newclass:
        iversion = _swig_property(_gpgme._gpgme_op_query_swdb_result_iversion_get, _gpgme._gpgme_op_query_swdb_result_iversion_set)
    __swig_setmethods__["created"] = _gpgme._gpgme_op_query_swdb_result_created_set
    __swig_getmethods__["created"] = _gpgme._gpgme_op_query_swdb_result_created_get
    if _newclass:
        created = _swig_property(_gpgme._gpgme_op_query_swdb_result_created_get, _gpgme._gpgme_op_query_swdb_result_created_set)
    __swig_setmethods__["retrieved"] = _gpgme._gpgme_op_query_swdb_result_retrieved_set
    __swig_getmethods__["retrieved"] = _gpgme._gpgme_op_query_swdb_result_retrieved_get
    if _newclass:
        retrieved = _swig_property(_gpgme._gpgme_op_query_swdb_result_retrieved_get, _gpgme._gpgme_op_query_swdb_result_retrieved_set)
    __swig_setmethods__["warning"] = _gpgme._gpgme_op_query_swdb_result_warning_set
    __swig_getmethods__["warning"] = _gpgme._gpgme_op_query_swdb_result_warning_get
    if _newclass:
        warning = _swig_property(_gpgme._gpgme_op_query_swdb_result_warning_get, _gpgme._gpgme_op_query_swdb_result_warning_set)
    __swig_setmethods__["update"] = _gpgme._gpgme_op_query_swdb_result_update_set
    __swig_getmethods__["update"] = _gpgme._gpgme_op_query_swdb_result_update_get
    if _newclass:
        update = _swig_property(_gpgme._gpgme_op_query_swdb_result_update_get, _gpgme._gpgme_op_query_swdb_result_update_set)
    __swig_setmethods__["urgent"] = _gpgme._gpgme_op_query_swdb_result_urgent_set
    __swig_getmethods__["urgent"] = _gpgme._gpgme_op_query_swdb_result_urgent_get
    if _newclass:
        urgent = _swig_property(_gpgme._gpgme_op_query_swdb_result_urgent_get, _gpgme._gpgme_op_query_swdb_result_urgent_set)
    __swig_setmethods__["noinfo"] = _gpgme._gpgme_op_query_swdb_result_noinfo_set
    __swig_getmethods__["noinfo"] = _gpgme._gpgme_op_query_swdb_result_noinfo_get
    if _newclass:
        noinfo = _swig_property(_gpgme._gpgme_op_query_swdb_result_noinfo_get, _gpgme._gpgme_op_query_swdb_result_noinfo_set)
    __swig_setmethods__["unknown"] = _gpgme._gpgme_op_query_swdb_result_unknown_set
    __swig_getmethods__["unknown"] = _gpgme._gpgme_op_query_swdb_result_unknown_get
    if _newclass:
        unknown = _swig_property(_gpgme._gpgme_op_query_swdb_result_unknown_get, _gpgme._gpgme_op_query_swdb_result_unknown_set)
    __swig_setmethods__["tooold"] = _gpgme._gpgme_op_query_swdb_result_tooold_set
    __swig_getmethods__["tooold"] = _gpgme._gpgme_op_query_swdb_result_tooold_get
    if _newclass:
        tooold = _swig_property(_gpgme._gpgme_op_query_swdb_result_tooold_get, _gpgme._gpgme_op_query_swdb_result_tooold_set)
    __swig_setmethods__["error"] = _gpgme._gpgme_op_query_swdb_result_error_set
    __swig_getmethods__["error"] = _gpgme._gpgme_op_query_swdb_result_error_get
    if _newclass:
        error = _swig_property(_gpgme._gpgme_op_query_swdb_result_error_get, _gpgme._gpgme_op_query_swdb_result_error_set)
    __swig_setmethods__["_reserved"] = _gpgme._gpgme_op_query_swdb_result__reserved_set
    __swig_getmethods__["_reserved"] = _gpgme._gpgme_op_query_swdb_result__reserved_get
    if _newclass:
        _reserved = _swig_property(_gpgme._gpgme_op_query_swdb_result__reserved_get, _gpgme._gpgme_op_query_swdb_result__reserved_set)
    __swig_setmethods__["version"] = _gpgme._gpgme_op_query_swdb_result_version_set
    __swig_getmethods__["version"] = _gpgme._gpgme_op_query_swdb_result_version_get
    if _newclass:
        version = _swig_property(_gpgme._gpgme_op_query_swdb_result_version_get, _gpgme._gpgme_op_query_swdb_result_version_set)
    __swig_setmethods__["reldate"] = _gpgme._gpgme_op_query_swdb_result_reldate_set
    __swig_getmethods__["reldate"] = _gpgme._gpgme_op_query_swdb_result_reldate_get
    if _newclass:
        reldate = _swig_property(_gpgme._gpgme_op_query_swdb_result_reldate_get, _gpgme._gpgme_op_query_swdb_result_reldate_set)

    def __init__(self):
        """__init__(self) -> _gpgme_op_query_swdb_result"""
        this = _gpgme.new__gpgme_op_query_swdb_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_query_swdb_result
    __del__ = lambda self: None
_gpgme_op_query_swdb_result_swigregister = _gpgme._gpgme_op_query_swdb_result_swigregister
_gpgme_op_query_swdb_result_swigregister(_gpgme_op_query_swdb_result)


def gpgme_op_query_swdb(ctx: 'gpgme_ctx_t', name: 'char const *', iversion: 'char const *', reserved: 'unsigned int') -> "gpgme_error_t":
    """gpgme_op_query_swdb(ctx, name, iversion, reserved) -> gpgme_error_t"""
    return _gpgme.gpgme_op_query_swdb(ctx, name, iversion, reserved)

def gpgme_op_query_swdb_result(ctx: 'gpgme_ctx_t') -> "gpgme_query_swdb_result_t":
    """gpgme_op_query_swdb_result(ctx) -> _gpgme_op_query_swdb_result"""
    return _gpgme.gpgme_op_query_swdb_result(ctx)

def gpgme_set_global_flag(name: 'char const *', value: 'char const *') -> "int":
    """gpgme_set_global_flag(name, value) -> int"""
    return _gpgme.gpgme_set_global_flag(name, value)

def gpgme_check_version(req_version: 'char const *') -> "char const *":
    """gpgme_check_version(req_version) -> char const *"""
    return _gpgme.gpgme_check_version(req_version)

def gpgme_check_version_internal(req_version: 'char const *', offset_sig_validity: 'size_t') -> "char const *":
    """gpgme_check_version_internal(req_version, offset_sig_validity) -> char const *"""
    return _gpgme.gpgme_check_version_internal(req_version, offset_sig_validity)

def gpgme_get_dirinfo(what: 'char const *') -> "char const *":
    """gpgme_get_dirinfo(what) -> char const *"""
    return _gpgme.gpgme_get_dirinfo(what)

def gpgme_get_engine_info(engine_info: 'gpgme_engine_info_t *') -> "gpgme_error_t":
    """gpgme_get_engine_info(engine_info) -> gpgme_error_t"""
    return _gpgme.gpgme_get_engine_info(engine_info)

def gpgme_set_engine_info(proto: 'gpgme_protocol_t', file_name: 'char const *', home_dir: 'char const *') -> "gpgme_error_t":
    """gpgme_set_engine_info(proto, file_name, home_dir) -> gpgme_error_t"""
    return _gpgme.gpgme_set_engine_info(proto, file_name, home_dir)

def gpgme_engine_check_version(proto: 'gpgme_protocol_t') -> "gpgme_error_t":
    """gpgme_engine_check_version(proto) -> gpgme_error_t"""
    return _gpgme.gpgme_engine_check_version(proto)

def gpgme_result_ref(result: 'void *') -> "void":
    """gpgme_result_ref(result)"""
    return _gpgme.gpgme_result_ref(result)

def gpgme_result_unref(result: 'void *') -> "void":
    """gpgme_result_unref(result)"""
    return _gpgme.gpgme_result_unref(result)

def gpgme_pubkey_algo_string(subkey: '_gpgme_subkey') -> "char *":
    """gpgme_pubkey_algo_string(subkey) -> char *"""
    return _gpgme.gpgme_pubkey_algo_string(subkey)

def gpgme_pubkey_algo_name(algo: 'gpgme_pubkey_algo_t') -> "char const *":
    """gpgme_pubkey_algo_name(algo) -> char const *"""
    return _gpgme.gpgme_pubkey_algo_name(algo)

def gpgme_hash_algo_name(algo: 'gpgme_hash_algo_t') -> "char const *":
    """gpgme_hash_algo_name(algo) -> char const *"""
    return _gpgme.gpgme_hash_algo_name(algo)

def gpgme_addrspec_from_uid(uid: 'char const *') -> "char *":
    """gpgme_addrspec_from_uid(uid) -> char *"""
    return _gpgme.gpgme_addrspec_from_uid(uid)
GPGME_STATUS_EOF = _gpgme.GPGME_STATUS_EOF
GPGME_STATUS_ENTER = _gpgme.GPGME_STATUS_ENTER
GPGME_STATUS_LEAVE = _gpgme.GPGME_STATUS_LEAVE
GPGME_STATUS_ABORT = _gpgme.GPGME_STATUS_ABORT
GPGME_STATUS_GOODSIG = _gpgme.GPGME_STATUS_GOODSIG
GPGME_STATUS_BADSIG = _gpgme.GPGME_STATUS_BADSIG
GPGME_STATUS_ERRSIG = _gpgme.GPGME_STATUS_ERRSIG
GPGME_STATUS_BADARMOR = _gpgme.GPGME_STATUS_BADARMOR
GPGME_STATUS_RSA_OR_IDEA = _gpgme.GPGME_STATUS_RSA_OR_IDEA
GPGME_STATUS_KEYEXPIRED = _gpgme.GPGME_STATUS_KEYEXPIRED
GPGME_STATUS_KEYREVOKED = _gpgme.GPGME_STATUS_KEYREVOKED
GPGME_STATUS_TRUST_UNDEFINED = _gpgme.GPGME_STATUS_TRUST_UNDEFINED
GPGME_STATUS_TRUST_NEVER = _gpgme.GPGME_STATUS_TRUST_NEVER
GPGME_STATUS_TRUST_MARGINAL = _gpgme.GPGME_STATUS_TRUST_MARGINAL
GPGME_STATUS_TRUST_FULLY = _gpgme.GPGME_STATUS_TRUST_FULLY
GPGME_STATUS_TRUST_ULTIMATE = _gpgme.GPGME_STATUS_TRUST_ULTIMATE
GPGME_STATUS_SHM_INFO = _gpgme.GPGME_STATUS_SHM_INFO
GPGME_STATUS_SHM_GET = _gpgme.GPGME_STATUS_SHM_GET
GPGME_STATUS_SHM_GET_BOOL = _gpgme.GPGME_STATUS_SHM_GET_BOOL
GPGME_STATUS_SHM_GET_HIDDEN = _gpgme.GPGME_STATUS_SHM_GET_HIDDEN
GPGME_STATUS_NEED_PASSPHRASE = _gpgme.GPGME_STATUS_NEED_PASSPHRASE
GPGME_STATUS_VALIDSIG = _gpgme.GPGME_STATUS_VALIDSIG
GPGME_STATUS_SIG_ID = _gpgme.GPGME_STATUS_SIG_ID
GPGME_STATUS_ENC_TO = _gpgme.GPGME_STATUS_ENC_TO
GPGME_STATUS_NODATA = _gpgme.GPGME_STATUS_NODATA
GPGME_STATUS_BAD_PASSPHRASE = _gpgme.GPGME_STATUS_BAD_PASSPHRASE
GPGME_STATUS_NO_PUBKEY = _gpgme.GPGME_STATUS_NO_PUBKEY
GPGME_STATUS_NO_SECKEY = _gpgme.GPGME_STATUS_NO_SECKEY
GPGME_STATUS_NEED_PASSPHRASE_SYM = _gpgme.GPGME_STATUS_NEED_PASSPHRASE_SYM
GPGME_STATUS_DECRYPTION_FAILED = _gpgme.GPGME_STATUS_DECRYPTION_FAILED
GPGME_STATUS_DECRYPTION_OKAY = _gpgme.GPGME_STATUS_DECRYPTION_OKAY
GPGME_STATUS_MISSING_PASSPHRASE = _gpgme.GPGME_STATUS_MISSING_PASSPHRASE
GPGME_STATUS_GOOD_PASSPHRASE = _gpgme.GPGME_STATUS_GOOD_PASSPHRASE
GPGME_STATUS_GOODMDC = _gpgme.GPGME_STATUS_GOODMDC
GPGME_STATUS_BADMDC = _gpgme.GPGME_STATUS_BADMDC
GPGME_STATUS_ERRMDC = _gpgme.GPGME_STATUS_ERRMDC
GPGME_STATUS_IMPORTED = _gpgme.GPGME_STATUS_IMPORTED
GPGME_STATUS_IMPORT_OK = _gpgme.GPGME_STATUS_IMPORT_OK
GPGME_STATUS_IMPORT_PROBLEM = _gpgme.GPGME_STATUS_IMPORT_PROBLEM
GPGME_STATUS_IMPORT_RES = _gpgme.GPGME_STATUS_IMPORT_RES
GPGME_STATUS_FILE_START = _gpgme.GPGME_STATUS_FILE_START
GPGME_STATUS_FILE_DONE = _gpgme.GPGME_STATUS_FILE_DONE
GPGME_STATUS_FILE_ERROR = _gpgme.GPGME_STATUS_FILE_ERROR
GPGME_STATUS_BEGIN_DECRYPTION = _gpgme.GPGME_STATUS_BEGIN_DECRYPTION
GPGME_STATUS_END_DECRYPTION = _gpgme.GPGME_STATUS_END_DECRYPTION
GPGME_STATUS_BEGIN_ENCRYPTION = _gpgme.GPGME_STATUS_BEGIN_ENCRYPTION
GPGME_STATUS_END_ENCRYPTION = _gpgme.GPGME_STATUS_END_ENCRYPTION
GPGME_STATUS_DELETE_PROBLEM = _gpgme.GPGME_STATUS_DELETE_PROBLEM
GPGME_STATUS_GET_BOOL = _gpgme.GPGME_STATUS_GET_BOOL
GPGME_STATUS_GET_LINE = _gpgme.GPGME_STATUS_GET_LINE
GPGME_STATUS_GET_HIDDEN = _gpgme.GPGME_STATUS_GET_HIDDEN
GPGME_STATUS_GOT_IT = _gpgme.GPGME_STATUS_GOT_IT
GPGME_STATUS_PROGRESS = _gpgme.GPGME_STATUS_PROGRESS
GPGME_STATUS_SIG_CREATED = _gpgme.GPGME_STATUS_SIG_CREATED
GPGME_STATUS_SESSION_KEY = _gpgme.GPGME_STATUS_SESSION_KEY
GPGME_STATUS_NOTATION_NAME = _gpgme.GPGME_STATUS_NOTATION_NAME
GPGME_STATUS_NOTATION_DATA = _gpgme.GPGME_STATUS_NOTATION_DATA
GPGME_STATUS_POLICY_URL = _gpgme.GPGME_STATUS_POLICY_URL
GPGME_STATUS_BEGIN_STREAM = _gpgme.GPGME_STATUS_BEGIN_STREAM
GPGME_STATUS_END_STREAM = _gpgme.GPGME_STATUS_END_STREAM
GPGME_STATUS_KEY_CREATED = _gpgme.GPGME_STATUS_KEY_CREATED
GPGME_STATUS_USERID_HINT = _gpgme.GPGME_STATUS_USERID_HINT
GPGME_STATUS_UNEXPECTED = _gpgme.GPGME_STATUS_UNEXPECTED
GPGME_STATUS_INV_RECP = _gpgme.GPGME_STATUS_INV_RECP
GPGME_STATUS_NO_RECP = _gpgme.GPGME_STATUS_NO_RECP
GPGME_STATUS_ALREADY_SIGNED = _gpgme.GPGME_STATUS_ALREADY_SIGNED
GPGME_STATUS_SIGEXPIRED = _gpgme.GPGME_STATUS_SIGEXPIRED
GPGME_STATUS_EXPSIG = _gpgme.GPGME_STATUS_EXPSIG
GPGME_STATUS_EXPKEYSIG = _gpgme.GPGME_STATUS_EXPKEYSIG
GPGME_STATUS_TRUNCATED = _gpgme.GPGME_STATUS_TRUNCATED
GPGME_STATUS_ERROR = _gpgme.GPGME_STATUS_ERROR
GPGME_STATUS_NEWSIG = _gpgme.GPGME_STATUS_NEWSIG
GPGME_STATUS_REVKEYSIG = _gpgme.GPGME_STATUS_REVKEYSIG
GPGME_STATUS_SIG_SUBPACKET = _gpgme.GPGME_STATUS_SIG_SUBPACKET
GPGME_STATUS_NEED_PASSPHRASE_PIN = _gpgme.GPGME_STATUS_NEED_PASSPHRASE_PIN
GPGME_STATUS_SC_OP_FAILURE = _gpgme.GPGME_STATUS_SC_OP_FAILURE
GPGME_STATUS_SC_OP_SUCCESS = _gpgme.GPGME_STATUS_SC_OP_SUCCESS
GPGME_STATUS_CARDCTRL = _gpgme.GPGME_STATUS_CARDCTRL
GPGME_STATUS_BACKUP_KEY_CREATED = _gpgme.GPGME_STATUS_BACKUP_KEY_CREATED
GPGME_STATUS_PKA_TRUST_BAD = _gpgme.GPGME_STATUS_PKA_TRUST_BAD
GPGME_STATUS_PKA_TRUST_GOOD = _gpgme.GPGME_STATUS_PKA_TRUST_GOOD
GPGME_STATUS_PLAINTEXT = _gpgme.GPGME_STATUS_PLAINTEXT
GPGME_STATUS_INV_SGNR = _gpgme.GPGME_STATUS_INV_SGNR
GPGME_STATUS_NO_SGNR = _gpgme.GPGME_STATUS_NO_SGNR
GPGME_STATUS_SUCCESS = _gpgme.GPGME_STATUS_SUCCESS
GPGME_STATUS_DECRYPTION_INFO = _gpgme.GPGME_STATUS_DECRYPTION_INFO
GPGME_STATUS_PLAINTEXT_LENGTH = _gpgme.GPGME_STATUS_PLAINTEXT_LENGTH
GPGME_STATUS_MOUNTPOINT = _gpgme.GPGME_STATUS_MOUNTPOINT
GPGME_STATUS_PINENTRY_LAUNCHED = _gpgme.GPGME_STATUS_PINENTRY_LAUNCHED
GPGME_STATUS_ATTRIBUTE = _gpgme.GPGME_STATUS_ATTRIBUTE
GPGME_STATUS_BEGIN_SIGNING = _gpgme.GPGME_STATUS_BEGIN_SIGNING
GPGME_STATUS_KEY_NOT_CREATED = _gpgme.GPGME_STATUS_KEY_NOT_CREATED
GPGME_STATUS_INQUIRE_MAXLEN = _gpgme.GPGME_STATUS_INQUIRE_MAXLEN
GPGME_STATUS_FAILURE = _gpgme.GPGME_STATUS_FAILURE
GPGME_STATUS_KEY_CONSIDERED = _gpgme.GPGME_STATUS_KEY_CONSIDERED
GPGME_STATUS_TOFU_USER = _gpgme.GPGME_STATUS_TOFU_USER
GPGME_STATUS_TOFU_STATS = _gpgme.GPGME_STATUS_TOFU_STATS
GPGME_STATUS_TOFU_STATS_LONG = _gpgme.GPGME_STATUS_TOFU_STATS_LONG
GPGME_STATUS_NOTATION_FLAGS = _gpgme.GPGME_STATUS_NOTATION_FLAGS
GPGME_STATUS_DECRYPTION_COMPLIANCE_MODE = _gpgme.GPGME_STATUS_DECRYPTION_COMPLIANCE_MODE
GPGME_STATUS_VERIFICATION_COMPLIANCE_MODE = _gpgme.GPGME_STATUS_VERIFICATION_COMPLIANCE_MODE
GPGME_SIG_STAT_NONE = _gpgme.GPGME_SIG_STAT_NONE
GPGME_SIG_STAT_GOOD = _gpgme.GPGME_SIG_STAT_GOOD
GPGME_SIG_STAT_BAD = _gpgme.GPGME_SIG_STAT_BAD
GPGME_SIG_STAT_NOKEY = _gpgme.GPGME_SIG_STAT_NOKEY
GPGME_SIG_STAT_NOSIG = _gpgme.GPGME_SIG_STAT_NOSIG
GPGME_SIG_STAT_ERROR = _gpgme.GPGME_SIG_STAT_ERROR
GPGME_SIG_STAT_DIFF = _gpgme.GPGME_SIG_STAT_DIFF
GPGME_SIG_STAT_GOOD_EXP = _gpgme.GPGME_SIG_STAT_GOOD_EXP
GPGME_SIG_STAT_GOOD_EXPKEY = _gpgme.GPGME_SIG_STAT_GOOD_EXPKEY
GPGME_ATTR_KEYID = _gpgme.GPGME_ATTR_KEYID
GPGME_ATTR_FPR = _gpgme.GPGME_ATTR_FPR
GPGME_ATTR_ALGO = _gpgme.GPGME_ATTR_ALGO
GPGME_ATTR_LEN = _gpgme.GPGME_ATTR_LEN
GPGME_ATTR_CREATED = _gpgme.GPGME_ATTR_CREATED
GPGME_ATTR_EXPIRE = _gpgme.GPGME_ATTR_EXPIRE
GPGME_ATTR_OTRUST = _gpgme.GPGME_ATTR_OTRUST
GPGME_ATTR_USERID = _gpgme.GPGME_ATTR_USERID
GPGME_ATTR_NAME = _gpgme.GPGME_ATTR_NAME
GPGME_ATTR_EMAIL = _gpgme.GPGME_ATTR_EMAIL
GPGME_ATTR_COMMENT = _gpgme.GPGME_ATTR_COMMENT
GPGME_ATTR_VALIDITY = _gpgme.GPGME_ATTR_VALIDITY
GPGME_ATTR_LEVEL = _gpgme.GPGME_ATTR_LEVEL
GPGME_ATTR_TYPE = _gpgme.GPGME_ATTR_TYPE
GPGME_ATTR_IS_SECRET = _gpgme.GPGME_ATTR_IS_SECRET
GPGME_ATTR_KEY_REVOKED = _gpgme.GPGME_ATTR_KEY_REVOKED
GPGME_ATTR_KEY_INVALID = _gpgme.GPGME_ATTR_KEY_INVALID
GPGME_ATTR_UID_REVOKED = _gpgme.GPGME_ATTR_UID_REVOKED
GPGME_ATTR_UID_INVALID = _gpgme.GPGME_ATTR_UID_INVALID
GPGME_ATTR_KEY_CAPS = _gpgme.GPGME_ATTR_KEY_CAPS
GPGME_ATTR_CAN_ENCRYPT = _gpgme.GPGME_ATTR_CAN_ENCRYPT
GPGME_ATTR_CAN_SIGN = _gpgme.GPGME_ATTR_CAN_SIGN
GPGME_ATTR_CAN_CERTIFY = _gpgme.GPGME_ATTR_CAN_CERTIFY
GPGME_ATTR_KEY_EXPIRED = _gpgme.GPGME_ATTR_KEY_EXPIRED
GPGME_ATTR_KEY_DISABLED = _gpgme.GPGME_ATTR_KEY_DISABLED
GPGME_ATTR_SERIAL = _gpgme.GPGME_ATTR_SERIAL
GPGME_ATTR_ISSUER = _gpgme.GPGME_ATTR_ISSUER
GPGME_ATTR_CHAINID = _gpgme.GPGME_ATTR_CHAINID
GPGME_ATTR_SIG_STATUS = _gpgme.GPGME_ATTR_SIG_STATUS
GPGME_ATTR_ERRTOK = _gpgme.GPGME_ATTR_ERRTOK
GPGME_ATTR_SIG_SUMMARY = _gpgme.GPGME_ATTR_SIG_SUMMARY
GPGME_ATTR_SIG_CLASS = _gpgme.GPGME_ATTR_SIG_CLASS
class _gpgme_op_assuan_result(_object):
    """Proxy of C _gpgme_op_assuan_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gpgme_op_assuan_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gpgme_op_assuan_result, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(self) -> _gpgme_op_assuan_result"""
        this = _gpgme.new__gpgme_op_assuan_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gpgme.delete__gpgme_op_assuan_result
    __del__ = lambda self: None
_gpgme_op_assuan_result_swigregister = _gpgme._gpgme_op_assuan_result_swigregister
_gpgme_op_assuan_result_swigregister(_gpgme_op_assuan_result)

GPG_ERR_SOURCE_UNKNOWN = _gpgme.GPG_ERR_SOURCE_UNKNOWN
GPG_ERR_SOURCE_GCRYPT = _gpgme.GPG_ERR_SOURCE_GCRYPT
GPG_ERR_SOURCE_GPG = _gpgme.GPG_ERR_SOURCE_GPG
GPG_ERR_SOURCE_GPGSM = _gpgme.GPG_ERR_SOURCE_GPGSM
GPG_ERR_SOURCE_GPGAGENT = _gpgme.GPG_ERR_SOURCE_GPGAGENT
GPG_ERR_SOURCE_PINENTRY = _gpgme.GPG_ERR_SOURCE_PINENTRY
GPG_ERR_SOURCE_SCD = _gpgme.GPG_ERR_SOURCE_SCD
GPG_ERR_SOURCE_GPGME = _gpgme.GPG_ERR_SOURCE_GPGME
GPG_ERR_SOURCE_KEYBOX = _gpgme.GPG_ERR_SOURCE_KEYBOX
GPG_ERR_SOURCE_KSBA = _gpgme.GPG_ERR_SOURCE_KSBA
GPG_ERR_SOURCE_DIRMNGR = _gpgme.GPG_ERR_SOURCE_DIRMNGR
GPG_ERR_SOURCE_GSTI = _gpgme.GPG_ERR_SOURCE_GSTI
GPG_ERR_SOURCE_GPA = _gpgme.GPG_ERR_SOURCE_GPA
GPG_ERR_SOURCE_KLEO = _gpgme.GPG_ERR_SOURCE_KLEO
GPG_ERR_SOURCE_G13 = _gpgme.GPG_ERR_SOURCE_G13
GPG_ERR_SOURCE_ASSUAN = _gpgme.GPG_ERR_SOURCE_ASSUAN
GPG_ERR_SOURCE_TLS = _gpgme.GPG_ERR_SOURCE_TLS
GPG_ERR_SOURCE_ANY = _gpgme.GPG_ERR_SOURCE_ANY
GPG_ERR_SOURCE_USER_1 = _gpgme.GPG_ERR_SOURCE_USER_1
GPG_ERR_SOURCE_USER_2 = _gpgme.GPG_ERR_SOURCE_USER_2
GPG_ERR_SOURCE_USER_3 = _gpgme.GPG_ERR_SOURCE_USER_3
GPG_ERR_SOURCE_USER_4 = _gpgme.GPG_ERR_SOURCE_USER_4
GPG_ERR_SOURCE_DIM = _gpgme.GPG_ERR_SOURCE_DIM
GPG_ERR_NO_ERROR = _gpgme.GPG_ERR_NO_ERROR
GPG_ERR_GENERAL = _gpgme.GPG_ERR_GENERAL
GPG_ERR_UNKNOWN_PACKET = _gpgme.GPG_ERR_UNKNOWN_PACKET
GPG_ERR_UNKNOWN_VERSION = _gpgme.GPG_ERR_UNKNOWN_VERSION
GPG_ERR_PUBKEY_ALGO = _gpgme.GPG_ERR_PUBKEY_ALGO
GPG_ERR_DIGEST_ALGO = _gpgme.GPG_ERR_DIGEST_ALGO
GPG_ERR_BAD_PUBKEY = _gpgme.GPG_ERR_BAD_PUBKEY
GPG_ERR_BAD_SECKEY = _gpgme.GPG_ERR_BAD_SECKEY
GPG_ERR_BAD_SIGNATURE = _gpgme.GPG_ERR_BAD_SIGNATURE
GPG_ERR_NO_PUBKEY = _gpgme.GPG_ERR_NO_PUBKEY
GPG_ERR_CHECKSUM = _gpgme.GPG_ERR_CHECKSUM
GPG_ERR_BAD_PASSPHRASE = _gpgme.GPG_ERR_BAD_PASSPHRASE
GPG_ERR_CIPHER_ALGO = _gpgme.GPG_ERR_CIPHER_ALGO
GPG_ERR_KEYRING_OPEN = _gpgme.GPG_ERR_KEYRING_OPEN
GPG_ERR_INV_PACKET = _gpgme.GPG_ERR_INV_PACKET
GPG_ERR_INV_ARMOR = _gpgme.GPG_ERR_INV_ARMOR
GPG_ERR_NO_USER_ID = _gpgme.GPG_ERR_NO_USER_ID
GPG_ERR_NO_SECKEY = _gpgme.GPG_ERR_NO_SECKEY
GPG_ERR_WRONG_SECKEY = _gpgme.GPG_ERR_WRONG_SECKEY
GPG_ERR_BAD_KEY = _gpgme.GPG_ERR_BAD_KEY
GPG_ERR_COMPR_ALGO = _gpgme.GPG_ERR_COMPR_ALGO
GPG_ERR_NO_PRIME = _gpgme.GPG_ERR_NO_PRIME
GPG_ERR_NO_ENCODING_METHOD = _gpgme.GPG_ERR_NO_ENCODING_METHOD
GPG_ERR_NO_ENCRYPTION_SCHEME = _gpgme.GPG_ERR_NO_ENCRYPTION_SCHEME
GPG_ERR_NO_SIGNATURE_SCHEME = _gpgme.GPG_ERR_NO_SIGNATURE_SCHEME
GPG_ERR_INV_ATTR = _gpgme.GPG_ERR_INV_ATTR
GPG_ERR_NO_VALUE = _gpgme.GPG_ERR_NO_VALUE
GPG_ERR_NOT_FOUND = _gpgme.GPG_ERR_NOT_FOUND
GPG_ERR_VALUE_NOT_FOUND = _gpgme.GPG_ERR_VALUE_NOT_FOUND
GPG_ERR_SYNTAX = _gpgme.GPG_ERR_SYNTAX
GPG_ERR_BAD_MPI = _gpgme.GPG_ERR_BAD_MPI
GPG_ERR_INV_PASSPHRASE = _gpgme.GPG_ERR_INV_PASSPHRASE
GPG_ERR_SIG_CLASS = _gpgme.GPG_ERR_SIG_CLASS
GPG_ERR_RESOURCE_LIMIT = _gpgme.GPG_ERR_RESOURCE_LIMIT
GPG_ERR_INV_KEYRING = _gpgme.GPG_ERR_INV_KEYRING
GPG_ERR_TRUSTDB = _gpgme.GPG_ERR_TRUSTDB
GPG_ERR_BAD_CERT = _gpgme.GPG_ERR_BAD_CERT
GPG_ERR_INV_USER_ID = _gpgme.GPG_ERR_INV_USER_ID
GPG_ERR_UNEXPECTED = _gpgme.GPG_ERR_UNEXPECTED
GPG_ERR_TIME_CONFLICT = _gpgme.GPG_ERR_TIME_CONFLICT
GPG_ERR_KEYSERVER = _gpgme.GPG_ERR_KEYSERVER
GPG_ERR_WRONG_PUBKEY_ALGO = _gpgme.GPG_ERR_WRONG_PUBKEY_ALGO
GPG_ERR_TRIBUTE_TO_D_A = _gpgme.GPG_ERR_TRIBUTE_TO_D_A
GPG_ERR_WEAK_KEY = _gpgme.GPG_ERR_WEAK_KEY
GPG_ERR_INV_KEYLEN = _gpgme.GPG_ERR_INV_KEYLEN
GPG_ERR_INV_ARG = _gpgme.GPG_ERR_INV_ARG
GPG_ERR_BAD_URI = _gpgme.GPG_ERR_BAD_URI
GPG_ERR_INV_URI = _gpgme.GPG_ERR_INV_URI
GPG_ERR_NETWORK = _gpgme.GPG_ERR_NETWORK
GPG_ERR_UNKNOWN_HOST = _gpgme.GPG_ERR_UNKNOWN_HOST
GPG_ERR_SELFTEST_FAILED = _gpgme.GPG_ERR_SELFTEST_FAILED
GPG_ERR_NOT_ENCRYPTED = _gpgme.GPG_ERR_NOT_ENCRYPTED
GPG_ERR_NOT_PROCESSED = _gpgme.GPG_ERR_NOT_PROCESSED
GPG_ERR_UNUSABLE_PUBKEY = _gpgme.GPG_ERR_UNUSABLE_PUBKEY
GPG_ERR_UNUSABLE_SECKEY = _gpgme.GPG_ERR_UNUSABLE_SECKEY
GPG_ERR_INV_VALUE = _gpgme.GPG_ERR_INV_VALUE
GPG_ERR_BAD_CERT_CHAIN = _gpgme.GPG_ERR_BAD_CERT_CHAIN
GPG_ERR_MISSING_CERT = _gpgme.GPG_ERR_MISSING_CERT
GPG_ERR_NO_DATA = _gpgme.GPG_ERR_NO_DATA
GPG_ERR_BUG = _gpgme.GPG_ERR_BUG
GPG_ERR_NOT_SUPPORTED = _gpgme.GPG_ERR_NOT_SUPPORTED
GPG_ERR_INV_OP = _gpgme.GPG_ERR_INV_OP
GPG_ERR_TIMEOUT = _gpgme.GPG_ERR_TIMEOUT
GPG_ERR_INTERNAL = _gpgme.GPG_ERR_INTERNAL
GPG_ERR_EOF_GCRYPT = _gpgme.GPG_ERR_EOF_GCRYPT
GPG_ERR_INV_OBJ = _gpgme.GPG_ERR_INV_OBJ
GPG_ERR_TOO_SHORT = _gpgme.GPG_ERR_TOO_SHORT
GPG_ERR_TOO_LARGE = _gpgme.GPG_ERR_TOO_LARGE
GPG_ERR_NO_OBJ = _gpgme.GPG_ERR_NO_OBJ
GPG_ERR_NOT_IMPLEMENTED = _gpgme.GPG_ERR_NOT_IMPLEMENTED
GPG_ERR_CONFLICT = _gpgme.GPG_ERR_CONFLICT
GPG_ERR_INV_CIPHER_MODE = _gpgme.GPG_ERR_INV_CIPHER_MODE
GPG_ERR_INV_FLAG = _gpgme.GPG_ERR_INV_FLAG
GPG_ERR_INV_HANDLE = _gpgme.GPG_ERR_INV_HANDLE
GPG_ERR_TRUNCATED = _gpgme.GPG_ERR_TRUNCATED
GPG_ERR_INCOMPLETE_LINE = _gpgme.GPG_ERR_INCOMPLETE_LINE
GPG_ERR_INV_RESPONSE = _gpgme.GPG_ERR_INV_RESPONSE
GPG_ERR_NO_AGENT = _gpgme.GPG_ERR_NO_AGENT
GPG_ERR_AGENT = _gpgme.GPG_ERR_AGENT
GPG_ERR_INV_DATA = _gpgme.GPG_ERR_INV_DATA
GPG_ERR_ASSUAN_SERVER_FAULT = _gpgme.GPG_ERR_ASSUAN_SERVER_FAULT
GPG_ERR_ASSUAN = _gpgme.GPG_ERR_ASSUAN
GPG_ERR_INV_SESSION_KEY = _gpgme.GPG_ERR_INV_SESSION_KEY
GPG_ERR_INV_SEXP = _gpgme.GPG_ERR_INV_SEXP
GPG_ERR_UNSUPPORTED_ALGORITHM = _gpgme.GPG_ERR_UNSUPPORTED_ALGORITHM
GPG_ERR_NO_PIN_ENTRY = _gpgme.GPG_ERR_NO_PIN_ENTRY
GPG_ERR_PIN_ENTRY = _gpgme.GPG_ERR_PIN_ENTRY
GPG_ERR_BAD_PIN = _gpgme.GPG_ERR_BAD_PIN
GPG_ERR_INV_NAME = _gpgme.GPG_ERR_INV_NAME
GPG_ERR_BAD_DATA = _gpgme.GPG_ERR_BAD_DATA
GPG_ERR_INV_PARAMETER = _gpgme.GPG_ERR_INV_PARAMETER
GPG_ERR_WRONG_CARD = _gpgme.GPG_ERR_WRONG_CARD
GPG_ERR_NO_DIRMNGR = _gpgme.GPG_ERR_NO_DIRMNGR
GPG_ERR_DIRMNGR = _gpgme.GPG_ERR_DIRMNGR
GPG_ERR_CERT_REVOKED = _gpgme.GPG_ERR_CERT_REVOKED
GPG_ERR_NO_CRL_KNOWN = _gpgme.GPG_ERR_NO_CRL_KNOWN
GPG_ERR_CRL_TOO_OLD = _gpgme.GPG_ERR_CRL_TOO_OLD
GPG_ERR_LINE_TOO_LONG = _gpgme.GPG_ERR_LINE_TOO_LONG
GPG_ERR_NOT_TRUSTED = _gpgme.GPG_ERR_NOT_TRUSTED
GPG_ERR_CANCELED = _gpgme.GPG_ERR_CANCELED
GPG_ERR_BAD_CA_CERT = _gpgme.GPG_ERR_BAD_CA_CERT
GPG_ERR_CERT_EXPIRED = _gpgme.GPG_ERR_CERT_EXPIRED
GPG_ERR_CERT_TOO_YOUNG = _gpgme.GPG_ERR_CERT_TOO_YOUNG
GPG_ERR_UNSUPPORTED_CERT = _gpgme.GPG_ERR_UNSUPPORTED_CERT
GPG_ERR_UNKNOWN_SEXP = _gpgme.GPG_ERR_UNKNOWN_SEXP
GPG_ERR_UNSUPPORTED_PROTECTION = _gpgme.GPG_ERR_UNSUPPORTED_PROTECTION
GPG_ERR_CORRUPTED_PROTECTION = _gpgme.GPG_ERR_CORRUPTED_PROTECTION
GPG_ERR_AMBIGUOUS_NAME = _gpgme.GPG_ERR_AMBIGUOUS_NAME
GPG_ERR_CARD = _gpgme.GPG_ERR_CARD
GPG_ERR_CARD_RESET = _gpgme.GPG_ERR_CARD_RESET
GPG_ERR_CARD_REMOVED = _gpgme.GPG_ERR_CARD_REMOVED
GPG_ERR_INV_CARD = _gpgme.GPG_ERR_INV_CARD
GPG_ERR_CARD_NOT_PRESENT = _gpgme.GPG_ERR_CARD_NOT_PRESENT
GPG_ERR_NO_PKCS15_APP = _gpgme.GPG_ERR_NO_PKCS15_APP
GPG_ERR_NOT_CONFIRMED = _gpgme.GPG_ERR_NOT_CONFIRMED
GPG_ERR_CONFIGURATION = _gpgme.GPG_ERR_CONFIGURATION
GPG_ERR_NO_POLICY_MATCH = _gpgme.GPG_ERR_NO_POLICY_MATCH
GPG_ERR_INV_INDEX = _gpgme.GPG_ERR_INV_INDEX
GPG_ERR_INV_ID = _gpgme.GPG_ERR_INV_ID
GPG_ERR_NO_SCDAEMON = _gpgme.GPG_ERR_NO_SCDAEMON
GPG_ERR_SCDAEMON = _gpgme.GPG_ERR_SCDAEMON
GPG_ERR_UNSUPPORTED_PROTOCOL = _gpgme.GPG_ERR_UNSUPPORTED_PROTOCOL
GPG_ERR_BAD_PIN_METHOD = _gpgme.GPG_ERR_BAD_PIN_METHOD
GPG_ERR_CARD_NOT_INITIALIZED = _gpgme.GPG_ERR_CARD_NOT_INITIALIZED
GPG_ERR_UNSUPPORTED_OPERATION = _gpgme.GPG_ERR_UNSUPPORTED_OPERATION
GPG_ERR_WRONG_KEY_USAGE = _gpgme.GPG_ERR_WRONG_KEY_USAGE
GPG_ERR_NOTHING_FOUND = _gpgme.GPG_ERR_NOTHING_FOUND
GPG_ERR_WRONG_BLOB_TYPE = _gpgme.GPG_ERR_WRONG_BLOB_TYPE
GPG_ERR_MISSING_VALUE = _gpgme.GPG_ERR_MISSING_VALUE
GPG_ERR_HARDWARE = _gpgme.GPG_ERR_HARDWARE
GPG_ERR_PIN_BLOCKED = _gpgme.GPG_ERR_PIN_BLOCKED
GPG_ERR_USE_CONDITIONS = _gpgme.GPG_ERR_USE_CONDITIONS
GPG_ERR_PIN_NOT_SYNCED = _gpgme.GPG_ERR_PIN_NOT_SYNCED
GPG_ERR_INV_CRL = _gpgme.GPG_ERR_INV_CRL
GPG_ERR_BAD_BER = _gpgme.GPG_ERR_BAD_BER
GPG_ERR_INV_BER = _gpgme.GPG_ERR_INV_BER
GPG_ERR_ELEMENT_NOT_FOUND = _gpgme.GPG_ERR_ELEMENT_NOT_FOUND
GPG_ERR_IDENTIFIER_NOT_FOUND = _gpgme.GPG_ERR_IDENTIFIER_NOT_FOUND
GPG_ERR_INV_TAG = _gpgme.GPG_ERR_INV_TAG
GPG_ERR_INV_LENGTH = _gpgme.GPG_ERR_INV_LENGTH
GPG_ERR_INV_KEYINFO = _gpgme.GPG_ERR_INV_KEYINFO
GPG_ERR_UNEXPECTED_TAG = _gpgme.GPG_ERR_UNEXPECTED_TAG
GPG_ERR_NOT_DER_ENCODED = _gpgme.GPG_ERR_NOT_DER_ENCODED
GPG_ERR_NO_CMS_OBJ = _gpgme.GPG_ERR_NO_CMS_OBJ
GPG_ERR_INV_CMS_OBJ = _gpgme.GPG_ERR_INV_CMS_OBJ
GPG_ERR_UNKNOWN_CMS_OBJ = _gpgme.GPG_ERR_UNKNOWN_CMS_OBJ
GPG_ERR_UNSUPPORTED_CMS_OBJ = _gpgme.GPG_ERR_UNSUPPORTED_CMS_OBJ
GPG_ERR_UNSUPPORTED_ENCODING = _gpgme.GPG_ERR_UNSUPPORTED_ENCODING
GPG_ERR_UNSUPPORTED_CMS_VERSION = _gpgme.GPG_ERR_UNSUPPORTED_CMS_VERSION
GPG_ERR_UNKNOWN_ALGORITHM = _gpgme.GPG_ERR_UNKNOWN_ALGORITHM
GPG_ERR_INV_ENGINE = _gpgme.GPG_ERR_INV_ENGINE
GPG_ERR_PUBKEY_NOT_TRUSTED = _gpgme.GPG_ERR_PUBKEY_NOT_TRUSTED
GPG_ERR_DECRYPT_FAILED = _gpgme.GPG_ERR_DECRYPT_FAILED
GPG_ERR_KEY_EXPIRED = _gpgme.GPG_ERR_KEY_EXPIRED
GPG_ERR_SIG_EXPIRED = _gpgme.GPG_ERR_SIG_EXPIRED
GPG_ERR_ENCODING_PROBLEM = _gpgme.GPG_ERR_ENCODING_PROBLEM
GPG_ERR_INV_STATE = _gpgme.GPG_ERR_INV_STATE
GPG_ERR_DUP_VALUE = _gpgme.GPG_ERR_DUP_VALUE
GPG_ERR_MISSING_ACTION = _gpgme.GPG_ERR_MISSING_ACTION
GPG_ERR_MODULE_NOT_FOUND = _gpgme.GPG_ERR_MODULE_NOT_FOUND
GPG_ERR_INV_OID_STRING = _gpgme.GPG_ERR_INV_OID_STRING
GPG_ERR_INV_TIME = _gpgme.GPG_ERR_INV_TIME
GPG_ERR_INV_CRL_OBJ = _gpgme.GPG_ERR_INV_CRL_OBJ
GPG_ERR_UNSUPPORTED_CRL_VERSION = _gpgme.GPG_ERR_UNSUPPORTED_CRL_VERSION
GPG_ERR_INV_CERT_OBJ = _gpgme.GPG_ERR_INV_CERT_OBJ
GPG_ERR_UNKNOWN_NAME = _gpgme.GPG_ERR_UNKNOWN_NAME
GPG_ERR_LOCALE_PROBLEM = _gpgme.GPG_ERR_LOCALE_PROBLEM
GPG_ERR_NOT_LOCKED = _gpgme.GPG_ERR_NOT_LOCKED
GPG_ERR_PROTOCOL_VIOLATION = _gpgme.GPG_ERR_PROTOCOL_VIOLATION
GPG_ERR_INV_MAC = _gpgme.GPG_ERR_INV_MAC
GPG_ERR_INV_REQUEST = _gpgme.GPG_ERR_INV_REQUEST
GPG_ERR_UNKNOWN_EXTN = _gpgme.GPG_ERR_UNKNOWN_EXTN
GPG_ERR_UNKNOWN_CRIT_EXTN = _gpgme.GPG_ERR_UNKNOWN_CRIT_EXTN
GPG_ERR_LOCKED = _gpgme.GPG_ERR_LOCKED
GPG_ERR_UNKNOWN_OPTION = _gpgme.GPG_ERR_UNKNOWN_OPTION
GPG_ERR_UNKNOWN_COMMAND = _gpgme.GPG_ERR_UNKNOWN_COMMAND
GPG_ERR_NOT_OPERATIONAL = _gpgme.GPG_ERR_NOT_OPERATIONAL
GPG_ERR_NO_PASSPHRASE = _gpgme.GPG_ERR_NO_PASSPHRASE
GPG_ERR_NO_PIN = _gpgme.GPG_ERR_NO_PIN
GPG_ERR_NOT_ENABLED = _gpgme.GPG_ERR_NOT_ENABLED
GPG_ERR_NO_ENGINE = _gpgme.GPG_ERR_NO_ENGINE
GPG_ERR_MISSING_KEY = _gpgme.GPG_ERR_MISSING_KEY
GPG_ERR_TOO_MANY = _gpgme.GPG_ERR_TOO_MANY
GPG_ERR_LIMIT_REACHED = _gpgme.GPG_ERR_LIMIT_REACHED
GPG_ERR_NOT_INITIALIZED = _gpgme.GPG_ERR_NOT_INITIALIZED
GPG_ERR_MISSING_ISSUER_CERT = _gpgme.GPG_ERR_MISSING_ISSUER_CERT
GPG_ERR_NO_KEYSERVER = _gpgme.GPG_ERR_NO_KEYSERVER
GPG_ERR_INV_CURVE = _gpgme.GPG_ERR_INV_CURVE
GPG_ERR_UNKNOWN_CURVE = _gpgme.GPG_ERR_UNKNOWN_CURVE
GPG_ERR_DUP_KEY = _gpgme.GPG_ERR_DUP_KEY
GPG_ERR_AMBIGUOUS = _gpgme.GPG_ERR_AMBIGUOUS
GPG_ERR_NO_CRYPT_CTX = _gpgme.GPG_ERR_NO_CRYPT_CTX
GPG_ERR_WRONG_CRYPT_CTX = _gpgme.GPG_ERR_WRONG_CRYPT_CTX
GPG_ERR_BAD_CRYPT_CTX = _gpgme.GPG_ERR_BAD_CRYPT_CTX
GPG_ERR_CRYPT_CTX_CONFLICT = _gpgme.GPG_ERR_CRYPT_CTX_CONFLICT
GPG_ERR_BROKEN_PUBKEY = _gpgme.GPG_ERR_BROKEN_PUBKEY
GPG_ERR_BROKEN_SECKEY = _gpgme.GPG_ERR_BROKEN_SECKEY
GPG_ERR_MAC_ALGO = _gpgme.GPG_ERR_MAC_ALGO
GPG_ERR_FULLY_CANCELED = _gpgme.GPG_ERR_FULLY_CANCELED
GPG_ERR_UNFINISHED = _gpgme.GPG_ERR_UNFINISHED
GPG_ERR_BUFFER_TOO_SHORT = _gpgme.GPG_ERR_BUFFER_TOO_SHORT
GPG_ERR_SEXP_INV_LEN_SPEC = _gpgme.GPG_ERR_SEXP_INV_LEN_SPEC
GPG_ERR_SEXP_STRING_TOO_LONG = _gpgme.GPG_ERR_SEXP_STRING_TOO_LONG
GPG_ERR_SEXP_UNMATCHED_PAREN = _gpgme.GPG_ERR_SEXP_UNMATCHED_PAREN
GPG_ERR_SEXP_NOT_CANONICAL = _gpgme.GPG_ERR_SEXP_NOT_CANONICAL
GPG_ERR_SEXP_BAD_CHARACTER = _gpgme.GPG_ERR_SEXP_BAD_CHARACTER
GPG_ERR_SEXP_BAD_QUOTATION = _gpgme.GPG_ERR_SEXP_BAD_QUOTATION
GPG_ERR_SEXP_ZERO_PREFIX = _gpgme.GPG_ERR_SEXP_ZERO_PREFIX
GPG_ERR_SEXP_NESTED_DH = _gpgme.GPG_ERR_SEXP_NESTED_DH
GPG_ERR_SEXP_UNMATCHED_DH = _gpgme.GPG_ERR_SEXP_UNMATCHED_DH
GPG_ERR_SEXP_UNEXPECTED_PUNC = _gpgme.GPG_ERR_SEXP_UNEXPECTED_PUNC
GPG_ERR_SEXP_BAD_HEX_CHAR = _gpgme.GPG_ERR_SEXP_BAD_HEX_CHAR
GPG_ERR_SEXP_ODD_HEX_NUMBERS = _gpgme.GPG_ERR_SEXP_ODD_HEX_NUMBERS
GPG_ERR_SEXP_BAD_OCT_CHAR = _gpgme.GPG_ERR_SEXP_BAD_OCT_CHAR
GPG_ERR_SUBKEYS_EXP_OR_REV = _gpgme.GPG_ERR_SUBKEYS_EXP_OR_REV
GPG_ERR_DB_CORRUPTED = _gpgme.GPG_ERR_DB_CORRUPTED
GPG_ERR_SERVER_FAILED = _gpgme.GPG_ERR_SERVER_FAILED
GPG_ERR_NO_NAME = _gpgme.GPG_ERR_NO_NAME
GPG_ERR_NO_KEY = _gpgme.GPG_ERR_NO_KEY
GPG_ERR_LEGACY_KEY = _gpgme.GPG_ERR_LEGACY_KEY
GPG_ERR_REQUEST_TOO_SHORT = _gpgme.GPG_ERR_REQUEST_TOO_SHORT
GPG_ERR_REQUEST_TOO_LONG = _gpgme.GPG_ERR_REQUEST_TOO_LONG
GPG_ERR_OBJ_TERM_STATE = _gpgme.GPG_ERR_OBJ_TERM_STATE
GPG_ERR_NO_CERT_CHAIN = _gpgme.GPG_ERR_NO_CERT_CHAIN
GPG_ERR_CERT_TOO_LARGE = _gpgme.GPG_ERR_CERT_TOO_LARGE
GPG_ERR_INV_RECORD = _gpgme.GPG_ERR_INV_RECORD
GPG_ERR_BAD_MAC = _gpgme.GPG_ERR_BAD_MAC
GPG_ERR_UNEXPECTED_MSG = _gpgme.GPG_ERR_UNEXPECTED_MSG
GPG_ERR_COMPR_FAILED = _gpgme.GPG_ERR_COMPR_FAILED
GPG_ERR_WOULD_WRAP = _gpgme.GPG_ERR_WOULD_WRAP
GPG_ERR_FATAL_ALERT = _gpgme.GPG_ERR_FATAL_ALERT
GPG_ERR_NO_CIPHER = _gpgme.GPG_ERR_NO_CIPHER
GPG_ERR_MISSING_CLIENT_CERT = _gpgme.GPG_ERR_MISSING_CLIENT_CERT
GPG_ERR_CLOSE_NOTIFY = _gpgme.GPG_ERR_CLOSE_NOTIFY
GPG_ERR_TICKET_EXPIRED = _gpgme.GPG_ERR_TICKET_EXPIRED
GPG_ERR_BAD_TICKET = _gpgme.GPG_ERR_BAD_TICKET
GPG_ERR_UNKNOWN_IDENTITY = _gpgme.GPG_ERR_UNKNOWN_IDENTITY
GPG_ERR_BAD_HS_CERT = _gpgme.GPG_ERR_BAD_HS_CERT
GPG_ERR_BAD_HS_CERT_REQ = _gpgme.GPG_ERR_BAD_HS_CERT_REQ
GPG_ERR_BAD_HS_CERT_VER = _gpgme.GPG_ERR_BAD_HS_CERT_VER
GPG_ERR_BAD_HS_CHANGE_CIPHER = _gpgme.GPG_ERR_BAD_HS_CHANGE_CIPHER
GPG_ERR_BAD_HS_CLIENT_HELLO = _gpgme.GPG_ERR_BAD_HS_CLIENT_HELLO
GPG_ERR_BAD_HS_SERVER_HELLO = _gpgme.GPG_ERR_BAD_HS_SERVER_HELLO
GPG_ERR_BAD_HS_SERVER_HELLO_DONE = _gpgme.GPG_ERR_BAD_HS_SERVER_HELLO_DONE
GPG_ERR_BAD_HS_FINISHED = _gpgme.GPG_ERR_BAD_HS_FINISHED
GPG_ERR_BAD_HS_SERVER_KEX = _gpgme.GPG_ERR_BAD_HS_SERVER_KEX
GPG_ERR_BAD_HS_CLIENT_KEX = _gpgme.GPG_ERR_BAD_HS_CLIENT_KEX
GPG_ERR_BOGUS_STRING = _gpgme.GPG_ERR_BOGUS_STRING
GPG_ERR_FORBIDDEN = _gpgme.GPG_ERR_FORBIDDEN
GPG_ERR_KEY_DISABLED = _gpgme.GPG_ERR_KEY_DISABLED
GPG_ERR_KEY_ON_CARD = _gpgme.GPG_ERR_KEY_ON_CARD
GPG_ERR_INV_LOCK_OBJ = _gpgme.GPG_ERR_INV_LOCK_OBJ
GPG_ERR_TRUE = _gpgme.GPG_ERR_TRUE
GPG_ERR_FALSE = _gpgme.GPG_ERR_FALSE
GPG_ERR_ASS_GENERAL = _gpgme.GPG_ERR_ASS_GENERAL
GPG_ERR_ASS_ACCEPT_FAILED = _gpgme.GPG_ERR_ASS_ACCEPT_FAILED
GPG_ERR_ASS_CONNECT_FAILED = _gpgme.GPG_ERR_ASS_CONNECT_FAILED
GPG_ERR_ASS_INV_RESPONSE = _gpgme.GPG_ERR_ASS_INV_RESPONSE
GPG_ERR_ASS_INV_VALUE = _gpgme.GPG_ERR_ASS_INV_VALUE
GPG_ERR_ASS_INCOMPLETE_LINE = _gpgme.GPG_ERR_ASS_INCOMPLETE_LINE
GPG_ERR_ASS_LINE_TOO_LONG = _gpgme.GPG_ERR_ASS_LINE_TOO_LONG
GPG_ERR_ASS_NESTED_COMMANDS = _gpgme.GPG_ERR_ASS_NESTED_COMMANDS
GPG_ERR_ASS_NO_DATA_CB = _gpgme.GPG_ERR_ASS_NO_DATA_CB
GPG_ERR_ASS_NO_INQUIRE_CB = _gpgme.GPG_ERR_ASS_NO_INQUIRE_CB
GPG_ERR_ASS_NOT_A_SERVER = _gpgme.GPG_ERR_ASS_NOT_A_SERVER
GPG_ERR_ASS_NOT_A_CLIENT = _gpgme.GPG_ERR_ASS_NOT_A_CLIENT
GPG_ERR_ASS_SERVER_START = _gpgme.GPG_ERR_ASS_SERVER_START
GPG_ERR_ASS_READ_ERROR = _gpgme.GPG_ERR_ASS_READ_ERROR
GPG_ERR_ASS_WRITE_ERROR = _gpgme.GPG_ERR_ASS_WRITE_ERROR
GPG_ERR_ASS_TOO_MUCH_DATA = _gpgme.GPG_ERR_ASS_TOO_MUCH_DATA
GPG_ERR_ASS_UNEXPECTED_CMD = _gpgme.GPG_ERR_ASS_UNEXPECTED_CMD
GPG_ERR_ASS_UNKNOWN_CMD = _gpgme.GPG_ERR_ASS_UNKNOWN_CMD
GPG_ERR_ASS_SYNTAX = _gpgme.GPG_ERR_ASS_SYNTAX
GPG_ERR_ASS_CANCELED = _gpgme.GPG_ERR_ASS_CANCELED
GPG_ERR_ASS_NO_INPUT = _gpgme.GPG_ERR_ASS_NO_INPUT
GPG_ERR_ASS_NO_OUTPUT = _gpgme.GPG_ERR_ASS_NO_OUTPUT
GPG_ERR_ASS_PARAMETER = _gpgme.GPG_ERR_ASS_PARAMETER
GPG_ERR_ASS_UNKNOWN_INQUIRE = _gpgme.GPG_ERR_ASS_UNKNOWN_INQUIRE
GPG_ERR_ENGINE_TOO_OLD = _gpgme.GPG_ERR_ENGINE_TOO_OLD
GPG_ERR_WINDOW_TOO_SMALL = _gpgme.GPG_ERR_WINDOW_TOO_SMALL
GPG_ERR_WINDOW_TOO_LARGE = _gpgme.GPG_ERR_WINDOW_TOO_LARGE
GPG_ERR_MISSING_ENVVAR = _gpgme.GPG_ERR_MISSING_ENVVAR
GPG_ERR_USER_ID_EXISTS = _gpgme.GPG_ERR_USER_ID_EXISTS
GPG_ERR_NAME_EXISTS = _gpgme.GPG_ERR_NAME_EXISTS
GPG_ERR_DUP_NAME = _gpgme.GPG_ERR_DUP_NAME
GPG_ERR_TOO_YOUNG = _gpgme.GPG_ERR_TOO_YOUNG
GPG_ERR_TOO_OLD = _gpgme.GPG_ERR_TOO_OLD
GPG_ERR_UNKNOWN_FLAG = _gpgme.GPG_ERR_UNKNOWN_FLAG
GPG_ERR_INV_ORDER = _gpgme.GPG_ERR_INV_ORDER
GPG_ERR_ALREADY_FETCHED = _gpgme.GPG_ERR_ALREADY_FETCHED
GPG_ERR_TRY_LATER = _gpgme.GPG_ERR_TRY_LATER
GPG_ERR_WRONG_NAME = _gpgme.GPG_ERR_WRONG_NAME
GPG_ERR_SYSTEM_BUG = _gpgme.GPG_ERR_SYSTEM_BUG
GPG_ERR_DNS_UNKNOWN = _gpgme.GPG_ERR_DNS_UNKNOWN
GPG_ERR_DNS_SECTION = _gpgme.GPG_ERR_DNS_SECTION
GPG_ERR_DNS_ADDRESS = _gpgme.GPG_ERR_DNS_ADDRESS
GPG_ERR_DNS_NO_QUERY = _gpgme.GPG_ERR_DNS_NO_QUERY
GPG_ERR_DNS_NO_ANSWER = _gpgme.GPG_ERR_DNS_NO_ANSWER
GPG_ERR_DNS_CLOSED = _gpgme.GPG_ERR_DNS_CLOSED
GPG_ERR_DNS_VERIFY = _gpgme.GPG_ERR_DNS_VERIFY
GPG_ERR_DNS_TIMEOUT = _gpgme.GPG_ERR_DNS_TIMEOUT
GPG_ERR_LDAP_GENERAL = _gpgme.GPG_ERR_LDAP_GENERAL
GPG_ERR_LDAP_ATTR_GENERAL = _gpgme.GPG_ERR_LDAP_ATTR_GENERAL
GPG_ERR_LDAP_NAME_GENERAL = _gpgme.GPG_ERR_LDAP_NAME_GENERAL
GPG_ERR_LDAP_SECURITY_GENERAL = _gpgme.GPG_ERR_LDAP_SECURITY_GENERAL
GPG_ERR_LDAP_SERVICE_GENERAL = _gpgme.GPG_ERR_LDAP_SERVICE_GENERAL
GPG_ERR_LDAP_UPDATE_GENERAL = _gpgme.GPG_ERR_LDAP_UPDATE_GENERAL
GPG_ERR_LDAP_E_GENERAL = _gpgme.GPG_ERR_LDAP_E_GENERAL
GPG_ERR_LDAP_X_GENERAL = _gpgme.GPG_ERR_LDAP_X_GENERAL
GPG_ERR_LDAP_OTHER_GENERAL = _gpgme.GPG_ERR_LDAP_OTHER_GENERAL
GPG_ERR_LDAP_X_CONNECTING = _gpgme.GPG_ERR_LDAP_X_CONNECTING
GPG_ERR_LDAP_REFERRAL_LIMIT = _gpgme.GPG_ERR_LDAP_REFERRAL_LIMIT
GPG_ERR_LDAP_CLIENT_LOOP = _gpgme.GPG_ERR_LDAP_CLIENT_LOOP
GPG_ERR_LDAP_NO_RESULTS = _gpgme.GPG_ERR_LDAP_NO_RESULTS
GPG_ERR_LDAP_CONTROL_NOT_FOUND = _gpgme.GPG_ERR_LDAP_CONTROL_NOT_FOUND
GPG_ERR_LDAP_NOT_SUPPORTED = _gpgme.GPG_ERR_LDAP_NOT_SUPPORTED
GPG_ERR_LDAP_CONNECT = _gpgme.GPG_ERR_LDAP_CONNECT
GPG_ERR_LDAP_NO_MEMORY = _gpgme.GPG_ERR_LDAP_NO_MEMORY
GPG_ERR_LDAP_PARAM = _gpgme.GPG_ERR_LDAP_PARAM
GPG_ERR_LDAP_USER_CANCELLED = _gpgme.GPG_ERR_LDAP_USER_CANCELLED
GPG_ERR_LDAP_FILTER = _gpgme.GPG_ERR_LDAP_FILTER
GPG_ERR_LDAP_AUTH_UNKNOWN = _gpgme.GPG_ERR_LDAP_AUTH_UNKNOWN
GPG_ERR_LDAP_TIMEOUT = _gpgme.GPG_ERR_LDAP_TIMEOUT
GPG_ERR_LDAP_DECODING = _gpgme.GPG_ERR_LDAP_DECODING
GPG_ERR_LDAP_ENCODING = _gpgme.GPG_ERR_LDAP_ENCODING
GPG_ERR_LDAP_LOCAL = _gpgme.GPG_ERR_LDAP_LOCAL
GPG_ERR_LDAP_SERVER_DOWN = _gpgme.GPG_ERR_LDAP_SERVER_DOWN
GPG_ERR_LDAP_SUCCESS = _gpgme.GPG_ERR_LDAP_SUCCESS
GPG_ERR_LDAP_OPERATIONS = _gpgme.GPG_ERR_LDAP_OPERATIONS
GPG_ERR_LDAP_PROTOCOL = _gpgme.GPG_ERR_LDAP_PROTOCOL
GPG_ERR_LDAP_TIMELIMIT = _gpgme.GPG_ERR_LDAP_TIMELIMIT
GPG_ERR_LDAP_SIZELIMIT = _gpgme.GPG_ERR_LDAP_SIZELIMIT
GPG_ERR_LDAP_COMPARE_FALSE = _gpgme.GPG_ERR_LDAP_COMPARE_FALSE
GPG_ERR_LDAP_COMPARE_TRUE = _gpgme.GPG_ERR_LDAP_COMPARE_TRUE
GPG_ERR_LDAP_UNSUPPORTED_AUTH = _gpgme.GPG_ERR_LDAP_UNSUPPORTED_AUTH
GPG_ERR_LDAP_STRONG_AUTH_RQRD = _gpgme.GPG_ERR_LDAP_STRONG_AUTH_RQRD
GPG_ERR_LDAP_PARTIAL_RESULTS = _gpgme.GPG_ERR_LDAP_PARTIAL_RESULTS
GPG_ERR_LDAP_REFERRAL = _gpgme.GPG_ERR_LDAP_REFERRAL
GPG_ERR_LDAP_ADMINLIMIT = _gpgme.GPG_ERR_LDAP_ADMINLIMIT
GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN = _gpgme.GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN
GPG_ERR_LDAP_CONFIDENT_RQRD = _gpgme.GPG_ERR_LDAP_CONFIDENT_RQRD
GPG_ERR_LDAP_SASL_BIND_INPROG = _gpgme.GPG_ERR_LDAP_SASL_BIND_INPROG
GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE = _gpgme.GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE
GPG_ERR_LDAP_UNDEFINED_TYPE = _gpgme.GPG_ERR_LDAP_UNDEFINED_TYPE
GPG_ERR_LDAP_BAD_MATCHING = _gpgme.GPG_ERR_LDAP_BAD_MATCHING
GPG_ERR_LDAP_CONST_VIOLATION = _gpgme.GPG_ERR_LDAP_CONST_VIOLATION
GPG_ERR_LDAP_TYPE_VALUE_EXISTS = _gpgme.GPG_ERR_LDAP_TYPE_VALUE_EXISTS
GPG_ERR_LDAP_INV_SYNTAX = _gpgme.GPG_ERR_LDAP_INV_SYNTAX
GPG_ERR_LDAP_NO_SUCH_OBJ = _gpgme.GPG_ERR_LDAP_NO_SUCH_OBJ
GPG_ERR_LDAP_ALIAS_PROBLEM = _gpgme.GPG_ERR_LDAP_ALIAS_PROBLEM
GPG_ERR_LDAP_INV_DN_SYNTAX = _gpgme.GPG_ERR_LDAP_INV_DN_SYNTAX
GPG_ERR_LDAP_IS_LEAF = _gpgme.GPG_ERR_LDAP_IS_LEAF
GPG_ERR_LDAP_ALIAS_DEREF = _gpgme.GPG_ERR_LDAP_ALIAS_DEREF
GPG_ERR_LDAP_X_PROXY_AUTH_FAIL = _gpgme.GPG_ERR_LDAP_X_PROXY_AUTH_FAIL
GPG_ERR_LDAP_BAD_AUTH = _gpgme.GPG_ERR_LDAP_BAD_AUTH
GPG_ERR_LDAP_INV_CREDENTIALS = _gpgme.GPG_ERR_LDAP_INV_CREDENTIALS
GPG_ERR_LDAP_INSUFFICIENT_ACC = _gpgme.GPG_ERR_LDAP_INSUFFICIENT_ACC
GPG_ERR_LDAP_BUSY = _gpgme.GPG_ERR_LDAP_BUSY
GPG_ERR_LDAP_UNAVAILABLE = _gpgme.GPG_ERR_LDAP_UNAVAILABLE
GPG_ERR_LDAP_UNWILL_TO_PERFORM = _gpgme.GPG_ERR_LDAP_UNWILL_TO_PERFORM
GPG_ERR_LDAP_LOOP_DETECT = _gpgme.GPG_ERR_LDAP_LOOP_DETECT
GPG_ERR_LDAP_NAMING_VIOLATION = _gpgme.GPG_ERR_LDAP_NAMING_VIOLATION
GPG_ERR_LDAP_OBJ_CLS_VIOLATION = _gpgme.GPG_ERR_LDAP_OBJ_CLS_VIOLATION
GPG_ERR_LDAP_NOT_ALLOW_NONLEAF = _gpgme.GPG_ERR_LDAP_NOT_ALLOW_NONLEAF
GPG_ERR_LDAP_NOT_ALLOW_ON_RDN = _gpgme.GPG_ERR_LDAP_NOT_ALLOW_ON_RDN
GPG_ERR_LDAP_ALREADY_EXISTS = _gpgme.GPG_ERR_LDAP_ALREADY_EXISTS
GPG_ERR_LDAP_NO_OBJ_CLASS_MODS = _gpgme.GPG_ERR_LDAP_NO_OBJ_CLASS_MODS
GPG_ERR_LDAP_RESULTS_TOO_LARGE = _gpgme.GPG_ERR_LDAP_RESULTS_TOO_LARGE
GPG_ERR_LDAP_AFFECTS_MULT_DSAS = _gpgme.GPG_ERR_LDAP_AFFECTS_MULT_DSAS
GPG_ERR_LDAP_VLV = _gpgme.GPG_ERR_LDAP_VLV
GPG_ERR_LDAP_OTHER = _gpgme.GPG_ERR_LDAP_OTHER
GPG_ERR_LDAP_CUP_RESOURCE_LIMIT = _gpgme.GPG_ERR_LDAP_CUP_RESOURCE_LIMIT
GPG_ERR_LDAP_CUP_SEC_VIOLATION = _gpgme.GPG_ERR_LDAP_CUP_SEC_VIOLATION
GPG_ERR_LDAP_CUP_INV_DATA = _gpgme.GPG_ERR_LDAP_CUP_INV_DATA
GPG_ERR_LDAP_CUP_UNSUP_SCHEME = _gpgme.GPG_ERR_LDAP_CUP_UNSUP_SCHEME
GPG_ERR_LDAP_CUP_RELOAD = _gpgme.GPG_ERR_LDAP_CUP_RELOAD
GPG_ERR_LDAP_CANCELLED = _gpgme.GPG_ERR_LDAP_CANCELLED
GPG_ERR_LDAP_NO_SUCH_OPERATION = _gpgme.GPG_ERR_LDAP_NO_SUCH_OPERATION
GPG_ERR_LDAP_TOO_LATE = _gpgme.GPG_ERR_LDAP_TOO_LATE
GPG_ERR_LDAP_CANNOT_CANCEL = _gpgme.GPG_ERR_LDAP_CANNOT_CANCEL
GPG_ERR_LDAP_ASSERTION_FAILED = _gpgme.GPG_ERR_LDAP_ASSERTION_FAILED
GPG_ERR_LDAP_PROX_AUTH_DENIED = _gpgme.GPG_ERR_LDAP_PROX_AUTH_DENIED
GPG_ERR_USER_1 = _gpgme.GPG_ERR_USER_1
GPG_ERR_USER_2 = _gpgme.GPG_ERR_USER_2
GPG_ERR_USER_3 = _gpgme.GPG_ERR_USER_3
GPG_ERR_USER_4 = _gpgme.GPG_ERR_USER_4
GPG_ERR_USER_5 = _gpgme.GPG_ERR_USER_5
GPG_ERR_USER_6 = _gpgme.GPG_ERR_USER_6
GPG_ERR_USER_7 = _gpgme.GPG_ERR_USER_7
GPG_ERR_USER_8 = _gpgme.GPG_ERR_USER_8
GPG_ERR_USER_9 = _gpgme.GPG_ERR_USER_9
GPG_ERR_USER_10 = _gpgme.GPG_ERR_USER_10
GPG_ERR_USER_11 = _gpgme.GPG_ERR_USER_11
GPG_ERR_USER_12 = _gpgme.GPG_ERR_USER_12
GPG_ERR_USER_13 = _gpgme.GPG_ERR_USER_13
GPG_ERR_USER_14 = _gpgme.GPG_ERR_USER_14
GPG_ERR_USER_15 = _gpgme.GPG_ERR_USER_15
GPG_ERR_USER_16 = _gpgme.GPG_ERR_USER_16
GPG_ERR_MISSING_ERRNO = _gpgme.GPG_ERR_MISSING_ERRNO
GPG_ERR_UNKNOWN_ERRNO = _gpgme.GPG_ERR_UNKNOWN_ERRNO
GPG_ERR_EOF = _gpgme.GPG_ERR_EOF
GPG_ERR_E2BIG = _gpgme.GPG_ERR_E2BIG
GPG_ERR_EACCES = _gpgme.GPG_ERR_EACCES
GPG_ERR_EADDRINUSE = _gpgme.GPG_ERR_EADDRINUSE
GPG_ERR_EADDRNOTAVAIL = _gpgme.GPG_ERR_EADDRNOTAVAIL
GPG_ERR_EADV = _gpgme.GPG_ERR_EADV
GPG_ERR_EAFNOSUPPORT = _gpgme.GPG_ERR_EAFNOSUPPORT
GPG_ERR_EAGAIN = _gpgme.GPG_ERR_EAGAIN
GPG_ERR_EALREADY = _gpgme.GPG_ERR_EALREADY
GPG_ERR_EAUTH = _gpgme.GPG_ERR_EAUTH
GPG_ERR_EBACKGROUND = _gpgme.GPG_ERR_EBACKGROUND
GPG_ERR_EBADE = _gpgme.GPG_ERR_EBADE
GPG_ERR_EBADF = _gpgme.GPG_ERR_EBADF
GPG_ERR_EBADFD = _gpgme.GPG_ERR_EBADFD
GPG_ERR_EBADMSG = _gpgme.GPG_ERR_EBADMSG
GPG_ERR_EBADR = _gpgme.GPG_ERR_EBADR
GPG_ERR_EBADRPC = _gpgme.GPG_ERR_EBADRPC
GPG_ERR_EBADRQC = _gpgme.GPG_ERR_EBADRQC
GPG_ERR_EBADSLT = _gpgme.GPG_ERR_EBADSLT
GPG_ERR_EBFONT = _gpgme.GPG_ERR_EBFONT
GPG_ERR_EBUSY = _gpgme.GPG_ERR_EBUSY
GPG_ERR_ECANCELED = _gpgme.GPG_ERR_ECANCELED
GPG_ERR_ECHILD = _gpgme.GPG_ERR_ECHILD
GPG_ERR_ECHRNG = _gpgme.GPG_ERR_ECHRNG
GPG_ERR_ECOMM = _gpgme.GPG_ERR_ECOMM
GPG_ERR_ECONNABORTED = _gpgme.GPG_ERR_ECONNABORTED
GPG_ERR_ECONNREFUSED = _gpgme.GPG_ERR_ECONNREFUSED
GPG_ERR_ECONNRESET = _gpgme.GPG_ERR_ECONNRESET
GPG_ERR_ED = _gpgme.GPG_ERR_ED
GPG_ERR_EDEADLK = _gpgme.GPG_ERR_EDEADLK
GPG_ERR_EDEADLOCK = _gpgme.GPG_ERR_EDEADLOCK
GPG_ERR_EDESTADDRREQ = _gpgme.GPG_ERR_EDESTADDRREQ
GPG_ERR_EDIED = _gpgme.GPG_ERR_EDIED
GPG_ERR_EDOM = _gpgme.GPG_ERR_EDOM
GPG_ERR_EDOTDOT = _gpgme.GPG_ERR_EDOTDOT
GPG_ERR_EDQUOT = _gpgme.GPG_ERR_EDQUOT
GPG_ERR_EEXIST = _gpgme.GPG_ERR_EEXIST
GPG_ERR_EFAULT = _gpgme.GPG_ERR_EFAULT
GPG_ERR_EFBIG = _gpgme.GPG_ERR_EFBIG
GPG_ERR_EFTYPE = _gpgme.GPG_ERR_EFTYPE
GPG_ERR_EGRATUITOUS = _gpgme.GPG_ERR_EGRATUITOUS
GPG_ERR_EGREGIOUS = _gpgme.GPG_ERR_EGREGIOUS
GPG_ERR_EHOSTDOWN = _gpgme.GPG_ERR_EHOSTDOWN
GPG_ERR_EHOSTUNREACH = _gpgme.GPG_ERR_EHOSTUNREACH
GPG_ERR_EIDRM = _gpgme.GPG_ERR_EIDRM
GPG_ERR_EIEIO = _gpgme.GPG_ERR_EIEIO
GPG_ERR_EILSEQ = _gpgme.GPG_ERR_EILSEQ
GPG_ERR_EINPROGRESS = _gpgme.GPG_ERR_EINPROGRESS
GPG_ERR_EINTR = _gpgme.GPG_ERR_EINTR
GPG_ERR_EINVAL = _gpgme.GPG_ERR_EINVAL
GPG_ERR_EIO = _gpgme.GPG_ERR_EIO
GPG_ERR_EISCONN = _gpgme.GPG_ERR_EISCONN
GPG_ERR_EISDIR = _gpgme.GPG_ERR_EISDIR
GPG_ERR_EISNAM = _gpgme.GPG_ERR_EISNAM
GPG_ERR_EL2HLT = _gpgme.GPG_ERR_EL2HLT
GPG_ERR_EL2NSYNC = _gpgme.GPG_ERR_EL2NSYNC
GPG_ERR_EL3HLT = _gpgme.GPG_ERR_EL3HLT
GPG_ERR_EL3RST = _gpgme.GPG_ERR_EL3RST
GPG_ERR_ELIBACC = _gpgme.GPG_ERR_ELIBACC
GPG_ERR_ELIBBAD = _gpgme.GPG_ERR_ELIBBAD
GPG_ERR_ELIBEXEC = _gpgme.GPG_ERR_ELIBEXEC
GPG_ERR_ELIBMAX = _gpgme.GPG_ERR_ELIBMAX
GPG_ERR_ELIBSCN = _gpgme.GPG_ERR_ELIBSCN
GPG_ERR_ELNRNG = _gpgme.GPG_ERR_ELNRNG
GPG_ERR_ELOOP = _gpgme.GPG_ERR_ELOOP
GPG_ERR_EMEDIUMTYPE = _gpgme.GPG_ERR_EMEDIUMTYPE
GPG_ERR_EMFILE = _gpgme.GPG_ERR_EMFILE
GPG_ERR_EMLINK = _gpgme.GPG_ERR_EMLINK
GPG_ERR_EMSGSIZE = _gpgme.GPG_ERR_EMSGSIZE
GPG_ERR_EMULTIHOP = _gpgme.GPG_ERR_EMULTIHOP
GPG_ERR_ENAMETOOLONG = _gpgme.GPG_ERR_ENAMETOOLONG
GPG_ERR_ENAVAIL = _gpgme.GPG_ERR_ENAVAIL
GPG_ERR_ENEEDAUTH = _gpgme.GPG_ERR_ENEEDAUTH
GPG_ERR_ENETDOWN = _gpgme.GPG_ERR_ENETDOWN
GPG_ERR_ENETRESET = _gpgme.GPG_ERR_ENETRESET
GPG_ERR_ENETUNREACH = _gpgme.GPG_ERR_ENETUNREACH
GPG_ERR_ENFILE = _gpgme.GPG_ERR_ENFILE
GPG_ERR_ENOANO = _gpgme.GPG_ERR_ENOANO
GPG_ERR_ENOBUFS = _gpgme.GPG_ERR_ENOBUFS
GPG_ERR_ENOCSI = _gpgme.GPG_ERR_ENOCSI
GPG_ERR_ENODATA = _gpgme.GPG_ERR_ENODATA
GPG_ERR_ENODEV = _gpgme.GPG_ERR_ENODEV
GPG_ERR_ENOENT = _gpgme.GPG_ERR_ENOENT
GPG_ERR_ENOEXEC = _gpgme.GPG_ERR_ENOEXEC
GPG_ERR_ENOLCK = _gpgme.GPG_ERR_ENOLCK
GPG_ERR_ENOLINK = _gpgme.GPG_ERR_ENOLINK
GPG_ERR_ENOMEDIUM = _gpgme.GPG_ERR_ENOMEDIUM
GPG_ERR_ENOMEM = _gpgme.GPG_ERR_ENOMEM
GPG_ERR_ENOMSG = _gpgme.GPG_ERR_ENOMSG
GPG_ERR_ENONET = _gpgme.GPG_ERR_ENONET
GPG_ERR_ENOPKG = _gpgme.GPG_ERR_ENOPKG
GPG_ERR_ENOPROTOOPT = _gpgme.GPG_ERR_ENOPROTOOPT
GPG_ERR_ENOSPC = _gpgme.GPG_ERR_ENOSPC
GPG_ERR_ENOSR = _gpgme.GPG_ERR_ENOSR
GPG_ERR_ENOSTR = _gpgme.GPG_ERR_ENOSTR
GPG_ERR_ENOSYS = _gpgme.GPG_ERR_ENOSYS
GPG_ERR_ENOTBLK = _gpgme.GPG_ERR_ENOTBLK
GPG_ERR_ENOTCONN = _gpgme.GPG_ERR_ENOTCONN
GPG_ERR_ENOTDIR = _gpgme.GPG_ERR_ENOTDIR
GPG_ERR_ENOTEMPTY = _gpgme.GPG_ERR_ENOTEMPTY
GPG_ERR_ENOTNAM = _gpgme.GPG_ERR_ENOTNAM
GPG_ERR_ENOTSOCK = _gpgme.GPG_ERR_ENOTSOCK
GPG_ERR_ENOTSUP = _gpgme.GPG_ERR_ENOTSUP
GPG_ERR_ENOTTY = _gpgme.GPG_ERR_ENOTTY
GPG_ERR_ENOTUNIQ = _gpgme.GPG_ERR_ENOTUNIQ
GPG_ERR_ENXIO = _gpgme.GPG_ERR_ENXIO
GPG_ERR_EOPNOTSUPP = _gpgme.GPG_ERR_EOPNOTSUPP
GPG_ERR_EOVERFLOW = _gpgme.GPG_ERR_EOVERFLOW
GPG_ERR_EPERM = _gpgme.GPG_ERR_EPERM
GPG_ERR_EPFNOSUPPORT = _gpgme.GPG_ERR_EPFNOSUPPORT
GPG_ERR_EPIPE = _gpgme.GPG_ERR_EPIPE
GPG_ERR_EPROCLIM = _gpgme.GPG_ERR_EPROCLIM
GPG_ERR_EPROCUNAVAIL = _gpgme.GPG_ERR_EPROCUNAVAIL
GPG_ERR_EPROGMISMATCH = _gpgme.GPG_ERR_EPROGMISMATCH
GPG_ERR_EPROGUNAVAIL = _gpgme.GPG_ERR_EPROGUNAVAIL
GPG_ERR_EPROTO = _gpgme.GPG_ERR_EPROTO
GPG_ERR_EPROTONOSUPPORT = _gpgme.GPG_ERR_EPROTONOSUPPORT
GPG_ERR_EPROTOTYPE = _gpgme.GPG_ERR_EPROTOTYPE
GPG_ERR_ERANGE = _gpgme.GPG_ERR_ERANGE
GPG_ERR_EREMCHG = _gpgme.GPG_ERR_EREMCHG
GPG_ERR_EREMOTE = _gpgme.GPG_ERR_EREMOTE
GPG_ERR_EREMOTEIO = _gpgme.GPG_ERR_EREMOTEIO
GPG_ERR_ERESTART = _gpgme.GPG_ERR_ERESTART
GPG_ERR_EROFS = _gpgme.GPG_ERR_EROFS
GPG_ERR_ERPCMISMATCH = _gpgme.GPG_ERR_ERPCMISMATCH
GPG_ERR_ESHUTDOWN = _gpgme.GPG_ERR_ESHUTDOWN
GPG_ERR_ESOCKTNOSUPPORT = _gpgme.GPG_ERR_ESOCKTNOSUPPORT
GPG_ERR_ESPIPE = _gpgme.GPG_ERR_ESPIPE
GPG_ERR_ESRCH = _gpgme.GPG_ERR_ESRCH
GPG_ERR_ESRMNT = _gpgme.GPG_ERR_ESRMNT
GPG_ERR_ESTALE = _gpgme.GPG_ERR_ESTALE
GPG_ERR_ESTRPIPE = _gpgme.GPG_ERR_ESTRPIPE
GPG_ERR_ETIME = _gpgme.GPG_ERR_ETIME
GPG_ERR_ETIMEDOUT = _gpgme.GPG_ERR_ETIMEDOUT
GPG_ERR_ETOOMANYREFS = _gpgme.GPG_ERR_ETOOMANYREFS
GPG_ERR_ETXTBSY = _gpgme.GPG_ERR_ETXTBSY
GPG_ERR_EUCLEAN = _gpgme.GPG_ERR_EUCLEAN
GPG_ERR_EUNATCH = _gpgme.GPG_ERR_EUNATCH
GPG_ERR_EUSERS = _gpgme.GPG_ERR_EUSERS
GPG_ERR_EWOULDBLOCK = _gpgme.GPG_ERR_EWOULDBLOCK
GPG_ERR_EXDEV = _gpgme.GPG_ERR_EXDEV
GPG_ERR_EXFULL = _gpgme.GPG_ERR_EXFULL
GPG_ERR_CODE_DIM = _gpgme.GPG_ERR_CODE_DIM

def new_gpgme_ctx_t_p() -> "gpgme_ctx_t *":
    """new_gpgme_ctx_t_p() -> gpgme_ctx_t *"""
    return _gpgme.new_gpgme_ctx_t_p()

def copy_gpgme_ctx_t_p(value: 'gpgme_ctx_t') -> "gpgme_ctx_t *":
    """copy_gpgme_ctx_t_p(value) -> gpgme_ctx_t *"""
    return _gpgme.copy_gpgme_ctx_t_p(value)

def delete_gpgme_ctx_t_p(obj: 'gpgme_ctx_t *') -> "void":
    """delete_gpgme_ctx_t_p(obj)"""
    return _gpgme.delete_gpgme_ctx_t_p(obj)

def gpgme_ctx_t_p_assign(obj: 'gpgme_ctx_t *', value: 'gpgme_ctx_t') -> "void":
    """gpgme_ctx_t_p_assign(obj, value)"""
    return _gpgme.gpgme_ctx_t_p_assign(obj, value)

def gpgme_ctx_t_p_value(obj: 'gpgme_ctx_t *') -> "gpgme_ctx_t":
    """gpgme_ctx_t_p_value(obj) -> gpgme_ctx_t"""
    return _gpgme.gpgme_ctx_t_p_value(obj)

def new_gpgme_data_t_p() -> "gpgme_data_t *":
    """new_gpgme_data_t_p() -> gpgme_data_t *"""
    return _gpgme.new_gpgme_data_t_p()

def copy_gpgme_data_t_p(value: 'gpgme_data_t') -> "gpgme_data_t *":
    """copy_gpgme_data_t_p(value) -> gpgme_data_t *"""
    return _gpgme.copy_gpgme_data_t_p(value)

def delete_gpgme_data_t_p(obj: 'gpgme_data_t *') -> "void":
    """delete_gpgme_data_t_p(obj)"""
    return _gpgme.delete_gpgme_data_t_p(obj)

def gpgme_data_t_p_assign(obj: 'gpgme_data_t *', value: 'gpgme_data_t') -> "void":
    """gpgme_data_t_p_assign(obj, value)"""
    return _gpgme.gpgme_data_t_p_assign(obj, value)

def gpgme_data_t_p_value(obj: 'gpgme_data_t *') -> "gpgme_data_t":
    """gpgme_data_t_p_value(obj) -> gpgme_data_t"""
    return _gpgme.gpgme_data_t_p_value(obj)

def new_gpgme_key_t_p() -> "gpgme_key_t *":
    """new_gpgme_key_t_p() -> gpgme_key_t *"""
    return _gpgme.new_gpgme_key_t_p()

def copy_gpgme_key_t_p(value: '_gpgme_key') -> "gpgme_key_t *":
    """copy_gpgme_key_t_p(value) -> gpgme_key_t *"""
    return _gpgme.copy_gpgme_key_t_p(value)

def delete_gpgme_key_t_p(obj: 'gpgme_key_t *') -> "void":
    """delete_gpgme_key_t_p(obj)"""
    return _gpgme.delete_gpgme_key_t_p(obj)

def gpgme_key_t_p_assign(obj: 'gpgme_key_t *', value: '_gpgme_key') -> "void":
    """gpgme_key_t_p_assign(obj, value)"""
    return _gpgme.gpgme_key_t_p_assign(obj, value)

def gpgme_key_t_p_value(obj: 'gpgme_key_t *') -> "gpgme_key_t":
    """gpgme_key_t_p_value(obj) -> _gpgme_key"""
    return _gpgme.gpgme_key_t_p_value(obj)

def new_gpgme_error_t_p() -> "gpgme_error_t *":
    """new_gpgme_error_t_p() -> gpgme_error_t *"""
    return _gpgme.new_gpgme_error_t_p()

def copy_gpgme_error_t_p(value: 'gpgme_error_t') -> "gpgme_error_t *":
    """copy_gpgme_error_t_p(value) -> gpgme_error_t *"""
    return _gpgme.copy_gpgme_error_t_p(value)

def delete_gpgme_error_t_p(obj: 'gpgme_error_t *') -> "void":
    """delete_gpgme_error_t_p(obj)"""
    return _gpgme.delete_gpgme_error_t_p(obj)

def gpgme_error_t_p_assign(obj: 'gpgme_error_t *', value: 'gpgme_error_t') -> "void":
    """gpgme_error_t_p_assign(obj, value)"""
    return _gpgme.gpgme_error_t_p_assign(obj, value)

def gpgme_error_t_p_value(obj: 'gpgme_error_t *') -> "gpgme_error_t":
    """gpgme_error_t_p_value(obj) -> gpgme_error_t"""
    return _gpgme.gpgme_error_t_p_value(obj)

def new_gpgme_trust_item_t_p() -> "gpgme_trust_item_t *":
    """new_gpgme_trust_item_t_p() -> gpgme_trust_item_t *"""
    return _gpgme.new_gpgme_trust_item_t_p()

def copy_gpgme_trust_item_t_p(value: '_gpgme_trust_item') -> "gpgme_trust_item_t *":
    """copy_gpgme_trust_item_t_p(value) -> gpgme_trust_item_t *"""
    return _gpgme.copy_gpgme_trust_item_t_p(value)

def delete_gpgme_trust_item_t_p(obj: 'gpgme_trust_item_t *') -> "void":
    """delete_gpgme_trust_item_t_p(obj)"""
    return _gpgme.delete_gpgme_trust_item_t_p(obj)

def gpgme_trust_item_t_p_assign(obj: 'gpgme_trust_item_t *', value: '_gpgme_trust_item') -> "void":
    """gpgme_trust_item_t_p_assign(obj, value)"""
    return _gpgme.gpgme_trust_item_t_p_assign(obj, value)

def gpgme_trust_item_t_p_value(obj: 'gpgme_trust_item_t *') -> "gpgme_trust_item_t":
    """gpgme_trust_item_t_p_value(obj) -> _gpgme_trust_item"""
    return _gpgme.gpgme_trust_item_t_p_value(obj)

def new_gpgme_engine_info_t_p() -> "gpgme_engine_info_t *":
    """new_gpgme_engine_info_t_p() -> gpgme_engine_info_t *"""
    return _gpgme.new_gpgme_engine_info_t_p()

def copy_gpgme_engine_info_t_p(value: '_gpgme_engine_info') -> "gpgme_engine_info_t *":
    """copy_gpgme_engine_info_t_p(value) -> gpgme_engine_info_t *"""
    return _gpgme.copy_gpgme_engine_info_t_p(value)

def delete_gpgme_engine_info_t_p(obj: 'gpgme_engine_info_t *') -> "void":
    """delete_gpgme_engine_info_t_p(obj)"""
    return _gpgme.delete_gpgme_engine_info_t_p(obj)

def gpgme_engine_info_t_p_assign(obj: 'gpgme_engine_info_t *', value: '_gpgme_engine_info') -> "void":
    """gpgme_engine_info_t_p_assign(obj, value)"""
    return _gpgme.gpgme_engine_info_t_p_assign(obj, value)

def gpgme_engine_info_t_p_value(obj: 'gpgme_engine_info_t *') -> "gpgme_engine_info_t":
    """gpgme_engine_info_t_p_value(obj) -> _gpgme_engine_info"""
    return _gpgme.gpgme_engine_info_t_p_value(obj)

def fdopen(fildes: 'int', mode: 'char const *') -> "FILE *":
    """fdopen(fildes, mode) -> FILE *"""
    return _gpgme.fdopen(fildes, mode)

def gpg_raise_callback_exception(arg1: 'PyObject *') -> "PyObject *":
    """gpg_raise_callback_exception(arg1) -> PyObject *"""
    return _gpgme.gpg_raise_callback_exception(arg1)

def gpg_set_passphrase_cb(arg1: 'PyObject *', cb: 'PyObject *') -> "PyObject *":
    """gpg_set_passphrase_cb(arg1, cb) -> PyObject *"""
    return _gpgme.gpg_set_passphrase_cb(arg1, cb)

def gpg_set_progress_cb(arg1: 'PyObject *', cb: 'PyObject *') -> "PyObject *":
    """gpg_set_progress_cb(arg1, cb) -> PyObject *"""
    return _gpgme.gpg_set_progress_cb(arg1, cb)

def gpg_set_status_cb(arg1: 'PyObject *', cb: 'PyObject *') -> "PyObject *":
    """gpg_set_status_cb(arg1, cb) -> PyObject *"""
    return _gpgme.gpg_set_status_cb(arg1, cb)

def gpg_data_new_from_cbs(arg1: 'PyObject *', pycbs: 'PyObject *', r_data: 'gpgme_data_t *') -> "PyObject *":
    """gpg_data_new_from_cbs(arg1, pycbs, r_data) -> PyObject *"""
    return _gpgme.gpg_data_new_from_cbs(arg1, pycbs, r_data)
# This file is compatible with both classic and new-style classes.

cvar = _gpgme.cvar