1use libc::{addrinfo, c_char, c_int, c_void, sockaddr, FILE};
4use num_enum::TryFromPrimitive;
5
6pub const RD_KAFKA_VERSION: u32 = 33882367;
7pub const RD_KAFKA_DEBUG_CONTEXTS : & [u8 ; 138] = b"all,generic,broker,topic,metadata,feature,queue,msg,protocol,cgrp,security,fetch,interceptor,plugin,consumer,admin,eos,mock,assignor,conf\0" ;
8pub const RD_KAFKA_DESTROY_F_NO_CONSUMER_CLOSE: u32 = 8;
9pub const RD_KAFKA_OFFSET_BEGINNING: i32 = -2;
10pub const RD_KAFKA_OFFSET_END: i32 = -1;
11pub const RD_KAFKA_OFFSET_STORED: i32 = -1000;
12pub const RD_KAFKA_OFFSET_INVALID: i32 = -1001;
13pub const RD_KAFKA_OFFSET_TAIL_BASE: i32 = -2000;
14pub const RD_KAFKA_MSG_F_FREE: u32 = 1;
15pub const RD_KAFKA_MSG_F_COPY: u32 = 2;
16pub const RD_KAFKA_MSG_F_BLOCK: u32 = 4;
17pub const RD_KAFKA_MSG_F_PARTITION: u32 = 8;
18pub const RD_KAFKA_PURGE_F_QUEUE: u32 = 1;
19pub const RD_KAFKA_PURGE_F_INFLIGHT: u32 = 2;
20pub const RD_KAFKA_PURGE_F_NON_BLOCKING: u32 = 4;
21pub const RD_KAFKA_EVENT_NONE: u32 = 0;
22pub const RD_KAFKA_EVENT_DR: u32 = 1;
23pub const RD_KAFKA_EVENT_FETCH: u32 = 2;
24pub const RD_KAFKA_EVENT_LOG: u32 = 4;
25pub const RD_KAFKA_EVENT_ERROR: u32 = 8;
26pub const RD_KAFKA_EVENT_REBALANCE: u32 = 16;
27pub const RD_KAFKA_EVENT_OFFSET_COMMIT: u32 = 32;
28pub const RD_KAFKA_EVENT_STATS: u32 = 64;
29pub const RD_KAFKA_EVENT_CREATETOPICS_RESULT: u32 = 100;
30pub const RD_KAFKA_EVENT_DELETETOPICS_RESULT: u32 = 101;
31pub const RD_KAFKA_EVENT_CREATEPARTITIONS_RESULT: u32 = 102;
32pub const RD_KAFKA_EVENT_ALTERCONFIGS_RESULT: u32 = 103;
33pub const RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT: u32 = 104;
34pub const RD_KAFKA_EVENT_DELETERECORDS_RESULT: u32 = 105;
35pub const RD_KAFKA_EVENT_DELETEGROUPS_RESULT: u32 = 106;
36pub const RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT: u32 = 107;
37pub const RD_KAFKA_EVENT_OAUTHBEARER_TOKEN_REFRESH: u32 = 256;
38pub const RD_KAFKA_EVENT_BACKGROUND: u32 = 512;
39pub const RD_KAFKA_EVENT_CREATEACLS_RESULT: u32 = 1024;
40pub const RD_KAFKA_EVENT_DESCRIBEACLS_RESULT: u32 = 2048;
41pub const RD_KAFKA_EVENT_DELETEACLS_RESULT: u32 = 4096;
42pub const RD_KAFKA_EVENT_LISTCONSUMERGROUPS_RESULT: u32 = 8192;
43pub const RD_KAFKA_EVENT_DESCRIBECONSUMERGROUPS_RESULT: u32 = 16384;
44pub const RD_KAFKA_EVENT_LISTCONSUMERGROUPOFFSETS_RESULT: u32 = 32768;
45pub const RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT: u32 = 65536;
46pub const RD_KAFKA_EVENT_INCREMENTALALTERCONFIGS_RESULT: u32 = 131072;
47pub const RD_KAFKA_EVENT_DESCRIBEUSERSCRAMCREDENTIALS_RESULT: u32 = 262144;
48pub const RD_KAFKA_EVENT_ALTERUSERSCRAMCREDENTIALS_RESULT: u32 = 524288;
49pub const RD_KAFKA_EVENT_DESCRIBETOPICS_RESULT: u32 = 1048576;
50pub const RD_KAFKA_EVENT_DESCRIBECLUSTER_RESULT: u32 = 2097152;
51pub const RD_KAFKA_EVENT_LISTOFFSETS_RESULT: u32 = 4194304;
52extern "C" {
53 pub fn rd_kafka_version() -> c_int;
54}
55extern "C" {
56 pub fn rd_kafka_version_str() -> *const c_char;
57}
58#[repr(u32)]
59#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
60pub enum rd_kafka_type_t {
61 RD_KAFKA_PRODUCER = 0,
62 RD_KAFKA_CONSUMER = 1,
63}
64#[repr(u32)]
65#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
66pub enum rd_kafka_timestamp_type_t {
67 RD_KAFKA_TIMESTAMP_NOT_AVAILABLE = 0,
68 RD_KAFKA_TIMESTAMP_CREATE_TIME = 1,
69 RD_KAFKA_TIMESTAMP_LOG_APPEND_TIME = 2,
70}
71extern "C" {
72 pub fn rd_kafka_get_debug_contexts() -> *const c_char;
73}
74#[repr(C)]
75#[derive(Debug, Copy, Clone)]
76pub struct rd_kafka_s {
77 _unused: [u8; 0],
78}
79pub type rd_kafka_t = rd_kafka_s;
80#[repr(C)]
81#[derive(Debug, Copy, Clone)]
82pub struct rd_kafka_topic_s {
83 _unused: [u8; 0],
84}
85pub type rd_kafka_topic_t = rd_kafka_topic_s;
86#[repr(C)]
87#[derive(Debug, Copy, Clone)]
88pub struct rd_kafka_conf_s {
89 _unused: [u8; 0],
90}
91pub type rd_kafka_conf_t = rd_kafka_conf_s;
92#[repr(C)]
93#[derive(Debug, Copy, Clone)]
94pub struct rd_kafka_topic_conf_s {
95 _unused: [u8; 0],
96}
97pub type rd_kafka_topic_conf_t = rd_kafka_topic_conf_s;
98#[repr(C)]
99#[derive(Debug, Copy, Clone)]
100pub struct rd_kafka_queue_s {
101 _unused: [u8; 0],
102}
103pub type rd_kafka_queue_t = rd_kafka_queue_s;
104#[repr(C)]
105#[derive(Debug, Copy, Clone)]
106pub struct rd_kafka_op_s {
107 _unused: [u8; 0],
108}
109pub type rd_kafka_event_t = rd_kafka_op_s;
110#[repr(C)]
111#[derive(Debug, Copy, Clone)]
112pub struct rd_kafka_topic_result_s {
113 _unused: [u8; 0],
114}
115pub type rd_kafka_topic_result_t = rd_kafka_topic_result_s;
116#[repr(C)]
117#[derive(Debug, Copy, Clone)]
118pub struct rd_kafka_consumer_group_metadata_s {
119 _unused: [u8; 0],
120}
121pub type rd_kafka_consumer_group_metadata_t = rd_kafka_consumer_group_metadata_s;
122#[repr(C)]
123#[derive(Debug, Copy, Clone)]
124pub struct rd_kafka_error_s {
125 _unused: [u8; 0],
126}
127pub type rd_kafka_error_t = rd_kafka_error_s;
128#[repr(C)]
129#[derive(Debug, Copy, Clone)]
130pub struct rd_kafka_headers_s {
131 _unused: [u8; 0],
132}
133pub type rd_kafka_headers_t = rd_kafka_headers_s;
134#[repr(C)]
135#[derive(Debug, Copy, Clone)]
136pub struct rd_kafka_group_result_s {
137 _unused: [u8; 0],
138}
139pub type rd_kafka_group_result_t = rd_kafka_group_result_s;
140#[repr(C)]
141#[derive(Debug, Copy, Clone)]
142pub struct rd_kafka_acl_result_s {
143 _unused: [u8; 0],
144}
145pub type rd_kafka_acl_result_t = rd_kafka_acl_result_s;
146#[repr(C)]
147#[derive(Debug, Copy, Clone)]
148pub struct rd_kafka_Uuid_s {
149 _unused: [u8; 0],
150}
151pub type rd_kafka_Uuid_t = rd_kafka_Uuid_s;
152#[repr(i32)]
153#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, TryFromPrimitive)]
154pub enum rd_kafka_resp_err_t {
155 RD_KAFKA_RESP_ERR__BEGIN = -200,
156 RD_KAFKA_RESP_ERR__BAD_MSG = -199,
157 RD_KAFKA_RESP_ERR__BAD_COMPRESSION = -198,
158 RD_KAFKA_RESP_ERR__DESTROY = -197,
159 RD_KAFKA_RESP_ERR__FAIL = -196,
160 RD_KAFKA_RESP_ERR__TRANSPORT = -195,
161 RD_KAFKA_RESP_ERR__CRIT_SYS_RESOURCE = -194,
162 RD_KAFKA_RESP_ERR__RESOLVE = -193,
163 RD_KAFKA_RESP_ERR__MSG_TIMED_OUT = -192,
164 RD_KAFKA_RESP_ERR__PARTITION_EOF = -191,
165 RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION = -190,
166 RD_KAFKA_RESP_ERR__FS = -189,
167 RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC = -188,
168 RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN = -187,
169 RD_KAFKA_RESP_ERR__INVALID_ARG = -186,
170 RD_KAFKA_RESP_ERR__TIMED_OUT = -185,
171 RD_KAFKA_RESP_ERR__QUEUE_FULL = -184,
172 RD_KAFKA_RESP_ERR__ISR_INSUFF = -183,
173 RD_KAFKA_RESP_ERR__NODE_UPDATE = -182,
174 RD_KAFKA_RESP_ERR__SSL = -181,
175 RD_KAFKA_RESP_ERR__WAIT_COORD = -180,
176 RD_KAFKA_RESP_ERR__UNKNOWN_GROUP = -179,
177 RD_KAFKA_RESP_ERR__IN_PROGRESS = -178,
178 RD_KAFKA_RESP_ERR__PREV_IN_PROGRESS = -177,
179 RD_KAFKA_RESP_ERR__EXISTING_SUBSCRIPTION = -176,
180 RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS = -175,
181 RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS = -174,
182 RD_KAFKA_RESP_ERR__CONFLICT = -173,
183 RD_KAFKA_RESP_ERR__STATE = -172,
184 RD_KAFKA_RESP_ERR__UNKNOWN_PROTOCOL = -171,
185 RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED = -170,
186 RD_KAFKA_RESP_ERR__AUTHENTICATION = -169,
187 RD_KAFKA_RESP_ERR__NO_OFFSET = -168,
188 RD_KAFKA_RESP_ERR__OUTDATED = -167,
189 RD_KAFKA_RESP_ERR__TIMED_OUT_QUEUE = -166,
190 RD_KAFKA_RESP_ERR__UNSUPPORTED_FEATURE = -165,
191 RD_KAFKA_RESP_ERR__WAIT_CACHE = -164,
192 RD_KAFKA_RESP_ERR__INTR = -163,
193 RD_KAFKA_RESP_ERR__KEY_SERIALIZATION = -162,
194 RD_KAFKA_RESP_ERR__VALUE_SERIALIZATION = -161,
195 RD_KAFKA_RESP_ERR__KEY_DESERIALIZATION = -160,
196 RD_KAFKA_RESP_ERR__VALUE_DESERIALIZATION = -159,
197 RD_KAFKA_RESP_ERR__PARTIAL = -158,
198 RD_KAFKA_RESP_ERR__READ_ONLY = -157,
199 RD_KAFKA_RESP_ERR__NOENT = -156,
200 RD_KAFKA_RESP_ERR__UNDERFLOW = -155,
201 RD_KAFKA_RESP_ERR__INVALID_TYPE = -154,
202 RD_KAFKA_RESP_ERR__RETRY = -153,
203 RD_KAFKA_RESP_ERR__PURGE_QUEUE = -152,
204 RD_KAFKA_RESP_ERR__PURGE_INFLIGHT = -151,
205 RD_KAFKA_RESP_ERR__FATAL = -150,
206 RD_KAFKA_RESP_ERR__INCONSISTENT = -149,
207 RD_KAFKA_RESP_ERR__GAPLESS_GUARANTEE = -148,
208 RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED = -147,
209 RD_KAFKA_RESP_ERR__UNKNOWN_BROKER = -146,
210 RD_KAFKA_RESP_ERR__NOT_CONFIGURED = -145,
211 RD_KAFKA_RESP_ERR__FENCED = -144,
212 RD_KAFKA_RESP_ERR__APPLICATION = -143,
213 RD_KAFKA_RESP_ERR__ASSIGNMENT_LOST = -142,
214 RD_KAFKA_RESP_ERR__NOOP = -141,
215 RD_KAFKA_RESP_ERR__AUTO_OFFSET_RESET = -140,
216 RD_KAFKA_RESP_ERR__LOG_TRUNCATION = -139,
217 RD_KAFKA_RESP_ERR__INVALID_DIFFERENT_RECORD = -138,
218 RD_KAFKA_RESP_ERR__END = -100,
219 RD_KAFKA_RESP_ERR_UNKNOWN = -1,
220 RD_KAFKA_RESP_ERR_NO_ERROR = 0,
221 RD_KAFKA_RESP_ERR_OFFSET_OUT_OF_RANGE = 1,
222 RD_KAFKA_RESP_ERR_INVALID_MSG = 2,
223 RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART = 3,
224 RD_KAFKA_RESP_ERR_INVALID_MSG_SIZE = 4,
225 RD_KAFKA_RESP_ERR_LEADER_NOT_AVAILABLE = 5,
226 RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION = 6,
227 RD_KAFKA_RESP_ERR_REQUEST_TIMED_OUT = 7,
228 RD_KAFKA_RESP_ERR_BROKER_NOT_AVAILABLE = 8,
229 RD_KAFKA_RESP_ERR_REPLICA_NOT_AVAILABLE = 9,
230 RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE = 10,
231 RD_KAFKA_RESP_ERR_STALE_CTRL_EPOCH = 11,
232 RD_KAFKA_RESP_ERR_OFFSET_METADATA_TOO_LARGE = 12,
233 RD_KAFKA_RESP_ERR_NETWORK_EXCEPTION = 13,
234 RD_KAFKA_RESP_ERR_COORDINATOR_LOAD_IN_PROGRESS = 14,
235 RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE = 15,
236 RD_KAFKA_RESP_ERR_NOT_COORDINATOR = 16,
237 RD_KAFKA_RESP_ERR_TOPIC_EXCEPTION = 17,
238 RD_KAFKA_RESP_ERR_RECORD_LIST_TOO_LARGE = 18,
239 RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS = 19,
240 RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS_AFTER_APPEND = 20,
241 RD_KAFKA_RESP_ERR_INVALID_REQUIRED_ACKS = 21,
242 RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION = 22,
243 RD_KAFKA_RESP_ERR_INCONSISTENT_GROUP_PROTOCOL = 23,
244 RD_KAFKA_RESP_ERR_INVALID_GROUP_ID = 24,
245 RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID = 25,
246 RD_KAFKA_RESP_ERR_INVALID_SESSION_TIMEOUT = 26,
247 RD_KAFKA_RESP_ERR_REBALANCE_IN_PROGRESS = 27,
248 RD_KAFKA_RESP_ERR_INVALID_COMMIT_OFFSET_SIZE = 28,
249 RD_KAFKA_RESP_ERR_TOPIC_AUTHORIZATION_FAILED = 29,
250 RD_KAFKA_RESP_ERR_GROUP_AUTHORIZATION_FAILED = 30,
251 RD_KAFKA_RESP_ERR_CLUSTER_AUTHORIZATION_FAILED = 31,
252 RD_KAFKA_RESP_ERR_INVALID_TIMESTAMP = 32,
253 RD_KAFKA_RESP_ERR_UNSUPPORTED_SASL_MECHANISM = 33,
254 RD_KAFKA_RESP_ERR_ILLEGAL_SASL_STATE = 34,
255 RD_KAFKA_RESP_ERR_UNSUPPORTED_VERSION = 35,
256 RD_KAFKA_RESP_ERR_TOPIC_ALREADY_EXISTS = 36,
257 RD_KAFKA_RESP_ERR_INVALID_PARTITIONS = 37,
258 RD_KAFKA_RESP_ERR_INVALID_REPLICATION_FACTOR = 38,
259 RD_KAFKA_RESP_ERR_INVALID_REPLICA_ASSIGNMENT = 39,
260 RD_KAFKA_RESP_ERR_INVALID_CONFIG = 40,
261 RD_KAFKA_RESP_ERR_NOT_CONTROLLER = 41,
262 RD_KAFKA_RESP_ERR_INVALID_REQUEST = 42,
263 RD_KAFKA_RESP_ERR_UNSUPPORTED_FOR_MESSAGE_FORMAT = 43,
264 RD_KAFKA_RESP_ERR_POLICY_VIOLATION = 44,
265 RD_KAFKA_RESP_ERR_OUT_OF_ORDER_SEQUENCE_NUMBER = 45,
266 RD_KAFKA_RESP_ERR_DUPLICATE_SEQUENCE_NUMBER = 46,
267 RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH = 47,
268 RD_KAFKA_RESP_ERR_INVALID_TXN_STATE = 48,
269 RD_KAFKA_RESP_ERR_INVALID_PRODUCER_ID_MAPPING = 49,
270 RD_KAFKA_RESP_ERR_INVALID_TRANSACTION_TIMEOUT = 50,
271 RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS = 51,
272 RD_KAFKA_RESP_ERR_TRANSACTION_COORDINATOR_FENCED = 52,
273 RD_KAFKA_RESP_ERR_TRANSACTIONAL_ID_AUTHORIZATION_FAILED = 53,
274 RD_KAFKA_RESP_ERR_SECURITY_DISABLED = 54,
275 RD_KAFKA_RESP_ERR_OPERATION_NOT_ATTEMPTED = 55,
276 RD_KAFKA_RESP_ERR_KAFKA_STORAGE_ERROR = 56,
277 RD_KAFKA_RESP_ERR_LOG_DIR_NOT_FOUND = 57,
278 RD_KAFKA_RESP_ERR_SASL_AUTHENTICATION_FAILED = 58,
279 RD_KAFKA_RESP_ERR_UNKNOWN_PRODUCER_ID = 59,
280 RD_KAFKA_RESP_ERR_REASSIGNMENT_IN_PROGRESS = 60,
281 RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTH_DISABLED = 61,
282 RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_NOT_FOUND = 62,
283 RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_OWNER_MISMATCH = 63,
284 RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_REQUEST_NOT_ALLOWED = 64,
285 RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTHORIZATION_FAILED = 65,
286 RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_EXPIRED = 66,
287 RD_KAFKA_RESP_ERR_INVALID_PRINCIPAL_TYPE = 67,
288 RD_KAFKA_RESP_ERR_NON_EMPTY_GROUP = 68,
289 RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND = 69,
290 RD_KAFKA_RESP_ERR_FETCH_SESSION_ID_NOT_FOUND = 70,
291 RD_KAFKA_RESP_ERR_INVALID_FETCH_SESSION_EPOCH = 71,
292 RD_KAFKA_RESP_ERR_LISTENER_NOT_FOUND = 72,
293 RD_KAFKA_RESP_ERR_TOPIC_DELETION_DISABLED = 73,
294 RD_KAFKA_RESP_ERR_FENCED_LEADER_EPOCH = 74,
295 RD_KAFKA_RESP_ERR_UNKNOWN_LEADER_EPOCH = 75,
296 RD_KAFKA_RESP_ERR_UNSUPPORTED_COMPRESSION_TYPE = 76,
297 RD_KAFKA_RESP_ERR_STALE_BROKER_EPOCH = 77,
298 RD_KAFKA_RESP_ERR_OFFSET_NOT_AVAILABLE = 78,
299 RD_KAFKA_RESP_ERR_MEMBER_ID_REQUIRED = 79,
300 RD_KAFKA_RESP_ERR_PREFERRED_LEADER_NOT_AVAILABLE = 80,
301 RD_KAFKA_RESP_ERR_GROUP_MAX_SIZE_REACHED = 81,
302 RD_KAFKA_RESP_ERR_FENCED_INSTANCE_ID = 82,
303 RD_KAFKA_RESP_ERR_ELIGIBLE_LEADERS_NOT_AVAILABLE = 83,
304 RD_KAFKA_RESP_ERR_ELECTION_NOT_NEEDED = 84,
305 RD_KAFKA_RESP_ERR_NO_REASSIGNMENT_IN_PROGRESS = 85,
306 RD_KAFKA_RESP_ERR_GROUP_SUBSCRIBED_TO_TOPIC = 86,
307 RD_KAFKA_RESP_ERR_INVALID_RECORD = 87,
308 RD_KAFKA_RESP_ERR_UNSTABLE_OFFSET_COMMIT = 88,
309 RD_KAFKA_RESP_ERR_THROTTLING_QUOTA_EXCEEDED = 89,
310 RD_KAFKA_RESP_ERR_PRODUCER_FENCED = 90,
311 RD_KAFKA_RESP_ERR_RESOURCE_NOT_FOUND = 91,
312 RD_KAFKA_RESP_ERR_DUPLICATE_RESOURCE = 92,
313 RD_KAFKA_RESP_ERR_UNACCEPTABLE_CREDENTIAL = 93,
314 RD_KAFKA_RESP_ERR_INCONSISTENT_VOTER_SET = 94,
315 RD_KAFKA_RESP_ERR_INVALID_UPDATE_VERSION = 95,
316 RD_KAFKA_RESP_ERR_FEATURE_UPDATE_FAILED = 96,
317 RD_KAFKA_RESP_ERR_PRINCIPAL_DESERIALIZATION_FAILURE = 97,
318 RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_ID = 100,
319 RD_KAFKA_RESP_ERR_FENCED_MEMBER_EPOCH = 110,
320 RD_KAFKA_RESP_ERR_UNRELEASED_INSTANCE_ID = 111,
321 RD_KAFKA_RESP_ERR_UNSUPPORTED_ASSIGNOR = 112,
322 RD_KAFKA_RESP_ERR_STALE_MEMBER_EPOCH = 113,
323 RD_KAFKA_RESP_ERR_UNKNOWN_SUBSCRIPTION_ID = 117,
324 RD_KAFKA_RESP_ERR_TELEMETRY_TOO_LARGE = 118,
325 RD_KAFKA_RESP_ERR_END_ALL = 119,
326}
327#[repr(C)]
328#[derive(Debug, Copy, Clone)]
329pub struct rd_kafka_err_desc {
330 pub code: rd_kafka_resp_err_t,
331 pub name: *const c_char,
332 pub desc: *const c_char,
333}
334extern "C" {
335 pub fn rd_kafka_get_err_descs(errdescs: *mut *const rd_kafka_err_desc, cntp: *mut usize);
336}
337extern "C" {
338 pub fn rd_kafka_err2str(err: rd_kafka_resp_err_t) -> *const c_char;
339}
340extern "C" {
341 pub fn rd_kafka_err2name(err: rd_kafka_resp_err_t) -> *const c_char;
342}
343extern "C" {
344 pub fn rd_kafka_last_error() -> rd_kafka_resp_err_t;
345}
346extern "C" {
347 pub fn rd_kafka_errno2err(errnox: c_int) -> rd_kafka_resp_err_t;
348}
349extern "C" {
350 pub fn rd_kafka_errno() -> c_int;
351}
352extern "C" {
353 pub fn rd_kafka_fatal_error(
354 rk: *mut rd_kafka_t,
355 errstr: *mut c_char,
356 errstr_size: usize,
357 ) -> rd_kafka_resp_err_t;
358}
359extern "C" {
360 pub fn rd_kafka_test_fatal_error(
361 rk: *mut rd_kafka_t,
362 err: rd_kafka_resp_err_t,
363 reason: *const c_char,
364 ) -> rd_kafka_resp_err_t;
365}
366extern "C" {
367 pub fn rd_kafka_error_code(error: *const rd_kafka_error_t) -> rd_kafka_resp_err_t;
368}
369extern "C" {
370 pub fn rd_kafka_error_name(error: *const rd_kafka_error_t) -> *const c_char;
371}
372extern "C" {
373 pub fn rd_kafka_error_string(error: *const rd_kafka_error_t) -> *const c_char;
374}
375extern "C" {
376 pub fn rd_kafka_error_is_fatal(error: *const rd_kafka_error_t) -> c_int;
377}
378extern "C" {
379 pub fn rd_kafka_error_is_retriable(error: *const rd_kafka_error_t) -> c_int;
380}
381extern "C" {
382 pub fn rd_kafka_error_txn_requires_abort(error: *const rd_kafka_error_t) -> c_int;
383}
384extern "C" {
385 pub fn rd_kafka_error_destroy(error: *mut rd_kafka_error_t);
386}
387extern "C" {
388 pub fn rd_kafka_error_new(
389 code: rd_kafka_resp_err_t,
390 fmt: *const c_char,
391 ...
392 ) -> *mut rd_kafka_error_t;
393}
394#[repr(C)]
395#[derive(Debug, Copy, Clone)]
396pub struct rd_kafka_topic_partition_s {
397 pub topic: *mut c_char,
398 pub partition: i32,
399 pub offset: i64,
400 pub metadata: *mut c_void,
401 pub metadata_size: usize,
402 pub opaque: *mut c_void,
403 pub err: rd_kafka_resp_err_t,
404 pub _private: *mut c_void,
405}
406pub type rd_kafka_topic_partition_t = rd_kafka_topic_partition_s;
407extern "C" {
408 pub fn rd_kafka_topic_partition_destroy(rktpar: *mut rd_kafka_topic_partition_t);
409}
410extern "C" {
411 pub fn rd_kafka_topic_partition_set_leader_epoch(
412 rktpar: *mut rd_kafka_topic_partition_t,
413 leader_epoch: i32,
414 );
415}
416extern "C" {
417 pub fn rd_kafka_topic_partition_get_leader_epoch(
418 rktpar: *const rd_kafka_topic_partition_t,
419 ) -> i32;
420}
421#[repr(C)]
422#[derive(Debug, Copy, Clone)]
423pub struct rd_kafka_topic_partition_list_s {
424 pub cnt: c_int,
425 pub size: c_int,
426 pub elems: *mut rd_kafka_topic_partition_t,
427}
428pub type rd_kafka_topic_partition_list_t = rd_kafka_topic_partition_list_s;
429extern "C" {
430 pub fn rd_kafka_topic_partition_list_new(size: c_int) -> *mut rd_kafka_topic_partition_list_t;
431}
432extern "C" {
433 pub fn rd_kafka_topic_partition_list_destroy(rkparlist: *mut rd_kafka_topic_partition_list_t);
434}
435extern "C" {
436 pub fn rd_kafka_topic_partition_list_add(
437 rktparlist: *mut rd_kafka_topic_partition_list_t,
438 topic: *const c_char,
439 partition: i32,
440 ) -> *mut rd_kafka_topic_partition_t;
441}
442extern "C" {
443 pub fn rd_kafka_topic_partition_list_add_range(
444 rktparlist: *mut rd_kafka_topic_partition_list_t,
445 topic: *const c_char,
446 start: i32,
447 stop: i32,
448 );
449}
450extern "C" {
451 pub fn rd_kafka_topic_partition_list_del(
452 rktparlist: *mut rd_kafka_topic_partition_list_t,
453 topic: *const c_char,
454 partition: i32,
455 ) -> c_int;
456}
457extern "C" {
458 pub fn rd_kafka_topic_partition_list_del_by_idx(
459 rktparlist: *mut rd_kafka_topic_partition_list_t,
460 idx: c_int,
461 ) -> c_int;
462}
463extern "C" {
464 pub fn rd_kafka_topic_partition_list_copy(
465 src: *const rd_kafka_topic_partition_list_t,
466 ) -> *mut rd_kafka_topic_partition_list_t;
467}
468extern "C" {
469 pub fn rd_kafka_topic_partition_list_set_offset(
470 rktparlist: *mut rd_kafka_topic_partition_list_t,
471 topic: *const c_char,
472 partition: i32,
473 offset: i64,
474 ) -> rd_kafka_resp_err_t;
475}
476extern "C" {
477 pub fn rd_kafka_topic_partition_list_find(
478 rktparlist: *const rd_kafka_topic_partition_list_t,
479 topic: *const c_char,
480 partition: i32,
481 ) -> *mut rd_kafka_topic_partition_t;
482}
483extern "C" {
484 pub fn rd_kafka_topic_partition_list_sort(
485 rktparlist: *mut rd_kafka_topic_partition_list_t,
486 cmp: Option<
487 unsafe extern "C" fn(
488 a: *const c_void,
489 b: *const c_void,
490 cmp_opaque: *mut c_void,
491 ) -> c_int,
492 >,
493 cmp_opaque: *mut c_void,
494 );
495}
496#[repr(u32)]
497#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
498pub enum rd_kafka_vtype_t {
499 RD_KAFKA_VTYPE_END = 0,
500 RD_KAFKA_VTYPE_TOPIC = 1,
501 RD_KAFKA_VTYPE_RKT = 2,
502 RD_KAFKA_VTYPE_PARTITION = 3,
503 RD_KAFKA_VTYPE_VALUE = 4,
504 RD_KAFKA_VTYPE_KEY = 5,
505 RD_KAFKA_VTYPE_OPAQUE = 6,
506 RD_KAFKA_VTYPE_MSGFLAGS = 7,
507 RD_KAFKA_VTYPE_TIMESTAMP = 8,
508 RD_KAFKA_VTYPE_HEADER = 9,
509 RD_KAFKA_VTYPE_HEADERS = 10,
510}
511#[repr(C)]
512#[derive(Copy, Clone)]
513pub struct rd_kafka_vu_s {
514 pub vtype: rd_kafka_vtype_t,
515 pub u: rd_kafka_vu_s__bindgen_ty_1,
516}
517#[repr(C)]
518#[derive(Copy, Clone)]
519pub union rd_kafka_vu_s__bindgen_ty_1 {
520 pub cstr: *const c_char,
521 pub rkt: *mut rd_kafka_topic_t,
522 pub i: c_int,
523 pub i32_: i32,
524 pub i64_: i64,
525 pub mem: rd_kafka_vu_s__bindgen_ty_1__bindgen_ty_1,
526 pub header: rd_kafka_vu_s__bindgen_ty_1__bindgen_ty_2,
527 pub headers: *mut rd_kafka_headers_t,
528 pub ptr: *mut c_void,
529 pub _pad: [c_char; 64usize],
530}
531#[repr(C)]
532#[derive(Debug, Copy, Clone)]
533pub struct rd_kafka_vu_s__bindgen_ty_1__bindgen_ty_1 {
534 pub ptr: *mut c_void,
535 pub size: usize,
536}
537#[repr(C)]
538#[derive(Debug, Copy, Clone)]
539pub struct rd_kafka_vu_s__bindgen_ty_1__bindgen_ty_2 {
540 pub name: *const c_char,
541 pub val: *const c_void,
542 pub size: isize,
543}
544pub type rd_kafka_vu_t = rd_kafka_vu_s;
545extern "C" {
546 pub fn rd_kafka_headers_new(initial_count: usize) -> *mut rd_kafka_headers_t;
547}
548extern "C" {
549 pub fn rd_kafka_headers_destroy(hdrs: *mut rd_kafka_headers_t);
550}
551extern "C" {
552 pub fn rd_kafka_headers_copy(src: *const rd_kafka_headers_t) -> *mut rd_kafka_headers_t;
553}
554extern "C" {
555 pub fn rd_kafka_header_add(
556 hdrs: *mut rd_kafka_headers_t,
557 name: *const c_char,
558 name_size: isize,
559 value: *const c_void,
560 value_size: isize,
561 ) -> rd_kafka_resp_err_t;
562}
563extern "C" {
564 pub fn rd_kafka_header_remove(
565 hdrs: *mut rd_kafka_headers_t,
566 name: *const c_char,
567 ) -> rd_kafka_resp_err_t;
568}
569extern "C" {
570 pub fn rd_kafka_header_get_last(
571 hdrs: *const rd_kafka_headers_t,
572 name: *const c_char,
573 valuep: *mut *const c_void,
574 sizep: *mut usize,
575 ) -> rd_kafka_resp_err_t;
576}
577extern "C" {
578 pub fn rd_kafka_header_get(
579 hdrs: *const rd_kafka_headers_t,
580 idx: usize,
581 name: *const c_char,
582 valuep: *mut *const c_void,
583 sizep: *mut usize,
584 ) -> rd_kafka_resp_err_t;
585}
586extern "C" {
587 pub fn rd_kafka_header_get_all(
588 hdrs: *const rd_kafka_headers_t,
589 idx: usize,
590 namep: *mut *const c_char,
591 valuep: *mut *const c_void,
592 sizep: *mut usize,
593 ) -> rd_kafka_resp_err_t;
594}
595#[repr(C)]
596#[derive(Debug, Copy, Clone)]
597pub struct rd_kafka_message_s {
598 pub err: rd_kafka_resp_err_t,
599 pub rkt: *mut rd_kafka_topic_t,
600 pub partition: i32,
601 pub payload: *mut c_void,
602 pub len: usize,
603 pub key: *mut c_void,
604 pub key_len: usize,
605 pub offset: i64,
606 pub _private: *mut c_void,
607}
608pub type rd_kafka_message_t = rd_kafka_message_s;
609extern "C" {
610 pub fn rd_kafka_message_destroy(rkmessage: *mut rd_kafka_message_t);
611}
612extern "C" {
613 pub fn rd_kafka_message_errstr(rkmessage: *const rd_kafka_message_t) -> *const c_char;
614}
615extern "C" {
616 pub fn rd_kafka_message_produce_errstr(rkmessage: *const rd_kafka_message_t) -> *const c_char;
617}
618extern "C" {
619 pub fn rd_kafka_message_timestamp(
620 rkmessage: *const rd_kafka_message_t,
621 tstype: *mut rd_kafka_timestamp_type_t,
622 ) -> i64;
623}
624extern "C" {
625 pub fn rd_kafka_message_latency(rkmessage: *const rd_kafka_message_t) -> i64;
626}
627extern "C" {
628 pub fn rd_kafka_message_broker_id(rkmessage: *const rd_kafka_message_t) -> i32;
629}
630extern "C" {
631 pub fn rd_kafka_message_headers(
632 rkmessage: *const rd_kafka_message_t,
633 hdrsp: *mut *mut rd_kafka_headers_t,
634 ) -> rd_kafka_resp_err_t;
635}
636extern "C" {
637 pub fn rd_kafka_message_detach_headers(
638 rkmessage: *mut rd_kafka_message_t,
639 hdrsp: *mut *mut rd_kafka_headers_t,
640 ) -> rd_kafka_resp_err_t;
641}
642extern "C" {
643 pub fn rd_kafka_message_set_headers(
644 rkmessage: *mut rd_kafka_message_t,
645 hdrs: *mut rd_kafka_headers_t,
646 );
647}
648extern "C" {
649 pub fn rd_kafka_header_cnt(hdrs: *const rd_kafka_headers_t) -> usize;
650}
651#[repr(u32)]
652#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
653pub enum rd_kafka_msg_status_t {
654 RD_KAFKA_MSG_STATUS_NOT_PERSISTED = 0,
655 RD_KAFKA_MSG_STATUS_POSSIBLY_PERSISTED = 1,
656 RD_KAFKA_MSG_STATUS_PERSISTED = 2,
657}
658extern "C" {
659 pub fn rd_kafka_message_status(rkmessage: *const rd_kafka_message_t) -> rd_kafka_msg_status_t;
660}
661extern "C" {
662 pub fn rd_kafka_message_leader_epoch(rkmessage: *const rd_kafka_message_t) -> i32;
663}
664extern "C" {
665 pub fn rd_kafka_Uuid_base64str(uuid: *const rd_kafka_Uuid_t) -> *const c_char;
666}
667extern "C" {
668 pub fn rd_kafka_Uuid_least_significant_bits(uuid: *const rd_kafka_Uuid_t) -> i64;
669}
670extern "C" {
671 pub fn rd_kafka_Uuid_most_significant_bits(uuid: *const rd_kafka_Uuid_t) -> i64;
672}
673extern "C" {
674 pub fn rd_kafka_Uuid_new(
675 most_significant_bits: i64,
676 least_significant_bits: i64,
677 ) -> *mut rd_kafka_Uuid_t;
678}
679extern "C" {
680 pub fn rd_kafka_Uuid_copy(uuid: *const rd_kafka_Uuid_t) -> *mut rd_kafka_Uuid_t;
681}
682extern "C" {
683 pub fn rd_kafka_Uuid_destroy(uuid: *mut rd_kafka_Uuid_t);
684}
685#[repr(i32)]
686#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
687pub enum rd_kafka_conf_res_t {
688 RD_KAFKA_CONF_UNKNOWN = -2,
689 RD_KAFKA_CONF_INVALID = -1,
690 RD_KAFKA_CONF_OK = 0,
691}
692extern "C" {
693 pub fn rd_kafka_conf_new() -> *mut rd_kafka_conf_t;
694}
695extern "C" {
696 pub fn rd_kafka_conf_destroy(conf: *mut rd_kafka_conf_t);
697}
698extern "C" {
699 pub fn rd_kafka_conf_dup(conf: *const rd_kafka_conf_t) -> *mut rd_kafka_conf_t;
700}
701extern "C" {
702 pub fn rd_kafka_conf_dup_filter(
703 conf: *const rd_kafka_conf_t,
704 filter_cnt: usize,
705 filter: *mut *const c_char,
706 ) -> *mut rd_kafka_conf_t;
707}
708extern "C" {
709 pub fn rd_kafka_conf(rk: *mut rd_kafka_t) -> *const rd_kafka_conf_t;
710}
711extern "C" {
712 pub fn rd_kafka_conf_set(
713 conf: *mut rd_kafka_conf_t,
714 name: *const c_char,
715 value: *const c_char,
716 errstr: *mut c_char,
717 errstr_size: usize,
718 ) -> rd_kafka_conf_res_t;
719}
720extern "C" {
721 pub fn rd_kafka_conf_set_events(conf: *mut rd_kafka_conf_t, events: c_int);
722}
723extern "C" {
724 pub fn rd_kafka_conf_set_background_event_cb(
725 conf: *mut rd_kafka_conf_t,
726 event_cb: Option<
727 unsafe extern "C" fn(
728 rk: *mut rd_kafka_t,
729 rkev: *mut rd_kafka_event_t,
730 opaque: *mut c_void,
731 ),
732 >,
733 );
734}
735extern "C" {
736 pub fn rd_kafka_conf_set_dr_cb(
737 conf: *mut rd_kafka_conf_t,
738 dr_cb: Option<
739 unsafe extern "C" fn(
740 rk: *mut rd_kafka_t,
741 payload: *mut c_void,
742 len: usize,
743 err: rd_kafka_resp_err_t,
744 opaque: *mut c_void,
745 msg_opaque: *mut c_void,
746 ),
747 >,
748 );
749}
750extern "C" {
751 pub fn rd_kafka_conf_set_dr_msg_cb(
752 conf: *mut rd_kafka_conf_t,
753 dr_msg_cb: Option<
754 unsafe extern "C" fn(
755 rk: *mut rd_kafka_t,
756 rkmessage: *const rd_kafka_message_t,
757 opaque: *mut c_void,
758 ),
759 >,
760 );
761}
762extern "C" {
763 pub fn rd_kafka_conf_set_consume_cb(
764 conf: *mut rd_kafka_conf_t,
765 consume_cb: Option<
766 unsafe extern "C" fn(rkmessage: *mut rd_kafka_message_t, opaque: *mut c_void),
767 >,
768 );
769}
770extern "C" {
771 pub fn rd_kafka_conf_set_rebalance_cb(
772 conf: *mut rd_kafka_conf_t,
773 rebalance_cb: Option<
774 unsafe extern "C" fn(
775 rk: *mut rd_kafka_t,
776 err: rd_kafka_resp_err_t,
777 partitions: *mut rd_kafka_topic_partition_list_t,
778 opaque: *mut c_void,
779 ),
780 >,
781 );
782}
783extern "C" {
784 pub fn rd_kafka_conf_set_offset_commit_cb(
785 conf: *mut rd_kafka_conf_t,
786 offset_commit_cb: Option<
787 unsafe extern "C" fn(
788 rk: *mut rd_kafka_t,
789 err: rd_kafka_resp_err_t,
790 offsets: *mut rd_kafka_topic_partition_list_t,
791 opaque: *mut c_void,
792 ),
793 >,
794 );
795}
796extern "C" {
797 pub fn rd_kafka_conf_set_error_cb(
798 conf: *mut rd_kafka_conf_t,
799 error_cb: Option<
800 unsafe extern "C" fn(
801 rk: *mut rd_kafka_t,
802 err: c_int,
803 reason: *const c_char,
804 opaque: *mut c_void,
805 ),
806 >,
807 );
808}
809extern "C" {
810 pub fn rd_kafka_conf_set_throttle_cb(
811 conf: *mut rd_kafka_conf_t,
812 throttle_cb: Option<
813 unsafe extern "C" fn(
814 rk: *mut rd_kafka_t,
815 broker_name: *const c_char,
816 broker_id: i32,
817 throttle_time_ms: c_int,
818 opaque: *mut c_void,
819 ),
820 >,
821 );
822}
823extern "C" {
824 pub fn rd_kafka_conf_set_log_cb(
825 conf: *mut rd_kafka_conf_t,
826 log_cb: Option<
827 unsafe extern "C" fn(
828 rk: *const rd_kafka_t,
829 level: c_int,
830 fac: *const c_char,
831 buf: *const c_char,
832 ),
833 >,
834 );
835}
836extern "C" {
837 pub fn rd_kafka_conf_set_stats_cb(
838 conf: *mut rd_kafka_conf_t,
839 stats_cb: Option<
840 unsafe extern "C" fn(
841 rk: *mut rd_kafka_t,
842 json: *mut c_char,
843 json_len: usize,
844 opaque: *mut c_void,
845 ) -> c_int,
846 >,
847 );
848}
849extern "C" {
850 pub fn rd_kafka_conf_set_oauthbearer_token_refresh_cb(
851 conf: *mut rd_kafka_conf_t,
852 oauthbearer_token_refresh_cb: Option<
853 unsafe extern "C" fn(
854 rk: *mut rd_kafka_t,
855 oauthbearer_config: *const c_char,
856 opaque: *mut c_void,
857 ),
858 >,
859 );
860}
861extern "C" {
862 pub fn rd_kafka_conf_enable_sasl_queue(conf: *mut rd_kafka_conf_t, enable: c_int);
863}
864extern "C" {
865 pub fn rd_kafka_conf_set_socket_cb(
866 conf: *mut rd_kafka_conf_t,
867 socket_cb: Option<
868 unsafe extern "C" fn(
869 domain: c_int,
870 type_: c_int,
871 protocol: c_int,
872 opaque: *mut c_void,
873 ) -> c_int,
874 >,
875 );
876}
877extern "C" {
878 pub fn rd_kafka_conf_set_connect_cb(
879 conf: *mut rd_kafka_conf_t,
880 connect_cb: Option<
881 unsafe extern "C" fn(
882 sockfd: c_int,
883 addr: *const sockaddr,
884 addrlen: c_int,
885 id: *const c_char,
886 opaque: *mut c_void,
887 ) -> c_int,
888 >,
889 );
890}
891extern "C" {
892 pub fn rd_kafka_conf_set_closesocket_cb(
893 conf: *mut rd_kafka_conf_t,
894 closesocket_cb: Option<unsafe extern "C" fn(sockfd: c_int, opaque: *mut c_void) -> c_int>,
895 );
896}
897extern "C" {
898 pub fn rd_kafka_conf_set_resolve_cb(
899 conf: *mut rd_kafka_conf_t,
900 resolve_cb: Option<
901 unsafe extern "C" fn(
902 node: *const c_char,
903 service: *const c_char,
904 hints: *const addrinfo,
905 res: *mut *mut addrinfo,
906 opaque: *mut c_void,
907 ) -> c_int,
908 >,
909 );
910}
911extern "C" {
912 pub fn rd_kafka_conf_set_ssl_cert_verify_cb(
913 conf: *mut rd_kafka_conf_t,
914 ssl_cert_verify_cb: Option<
915 unsafe extern "C" fn(
916 rk: *mut rd_kafka_t,
917 broker_name: *const c_char,
918 broker_id: i32,
919 x509_error: *mut c_int,
920 depth: c_int,
921 buf: *const c_char,
922 size: usize,
923 errstr: *mut c_char,
924 errstr_size: usize,
925 opaque: *mut c_void,
926 ) -> c_int,
927 >,
928 ) -> rd_kafka_conf_res_t;
929}
930#[repr(u32)]
931#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
932pub enum rd_kafka_cert_type_t {
933 RD_KAFKA_CERT_PUBLIC_KEY = 0,
934 RD_KAFKA_CERT_PRIVATE_KEY = 1,
935 RD_KAFKA_CERT_CA = 2,
936 RD_KAFKA_CERT__CNT = 3,
937}
938#[repr(u32)]
939#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
940pub enum rd_kafka_cert_enc_t {
941 RD_KAFKA_CERT_ENC_PKCS12 = 0,
942 RD_KAFKA_CERT_ENC_DER = 1,
943 RD_KAFKA_CERT_ENC_PEM = 2,
944 RD_KAFKA_CERT_ENC__CNT = 3,
945}
946extern "C" {
947 pub fn rd_kafka_conf_set_ssl_cert(
948 conf: *mut rd_kafka_conf_t,
949 cert_type: rd_kafka_cert_type_t,
950 cert_enc: rd_kafka_cert_enc_t,
951 buffer: *const c_void,
952 size: usize,
953 errstr: *mut c_char,
954 errstr_size: usize,
955 ) -> rd_kafka_conf_res_t;
956}
957extern "C" {
958 pub fn rd_kafka_conf_set_engine_callback_data(
959 conf: *mut rd_kafka_conf_t,
960 callback_data: *mut c_void,
961 );
962}
963extern "C" {
964 pub fn rd_kafka_conf_set_opaque(conf: *mut rd_kafka_conf_t, opaque: *mut c_void);
965}
966extern "C" {
967 pub fn rd_kafka_opaque(rk: *const rd_kafka_t) -> *mut c_void;
968}
969extern "C" {
970 pub fn rd_kafka_conf_set_default_topic_conf(
971 conf: *mut rd_kafka_conf_t,
972 tconf: *mut rd_kafka_topic_conf_t,
973 );
974}
975extern "C" {
976 pub fn rd_kafka_conf_get_default_topic_conf(
977 conf: *mut rd_kafka_conf_t,
978 ) -> *mut rd_kafka_topic_conf_t;
979}
980extern "C" {
981 pub fn rd_kafka_conf_get(
982 conf: *const rd_kafka_conf_t,
983 name: *const c_char,
984 dest: *mut c_char,
985 dest_size: *mut usize,
986 ) -> rd_kafka_conf_res_t;
987}
988extern "C" {
989 pub fn rd_kafka_topic_conf_get(
990 conf: *const rd_kafka_topic_conf_t,
991 name: *const c_char,
992 dest: *mut c_char,
993 dest_size: *mut usize,
994 ) -> rd_kafka_conf_res_t;
995}
996extern "C" {
997 pub fn rd_kafka_conf_dump(conf: *mut rd_kafka_conf_t, cntp: *mut usize) -> *mut *const c_char;
998}
999extern "C" {
1000 pub fn rd_kafka_topic_conf_dump(
1001 conf: *mut rd_kafka_topic_conf_t,
1002 cntp: *mut usize,
1003 ) -> *mut *const c_char;
1004}
1005extern "C" {
1006 pub fn rd_kafka_conf_dump_free(arr: *mut *const c_char, cnt: usize);
1007}
1008extern "C" {
1009 pub fn rd_kafka_conf_properties_show(fp: *mut FILE);
1010}
1011extern "C" {
1012 pub fn rd_kafka_topic_conf_new() -> *mut rd_kafka_topic_conf_t;
1013}
1014extern "C" {
1015 pub fn rd_kafka_topic_conf_dup(
1016 conf: *const rd_kafka_topic_conf_t,
1017 ) -> *mut rd_kafka_topic_conf_t;
1018}
1019extern "C" {
1020 pub fn rd_kafka_default_topic_conf_dup(rk: *mut rd_kafka_t) -> *mut rd_kafka_topic_conf_t;
1021}
1022extern "C" {
1023 pub fn rd_kafka_topic_conf_destroy(topic_conf: *mut rd_kafka_topic_conf_t);
1024}
1025extern "C" {
1026 pub fn rd_kafka_topic_conf_set(
1027 conf: *mut rd_kafka_topic_conf_t,
1028 name: *const c_char,
1029 value: *const c_char,
1030 errstr: *mut c_char,
1031 errstr_size: usize,
1032 ) -> rd_kafka_conf_res_t;
1033}
1034extern "C" {
1035 pub fn rd_kafka_topic_conf_set_opaque(
1036 conf: *mut rd_kafka_topic_conf_t,
1037 rkt_opaque: *mut c_void,
1038 );
1039}
1040extern "C" {
1041 pub fn rd_kafka_topic_conf_set_partitioner_cb(
1042 topic_conf: *mut rd_kafka_topic_conf_t,
1043 partitioner: Option<
1044 unsafe extern "C" fn(
1045 rkt: *const rd_kafka_topic_t,
1046 keydata: *const c_void,
1047 keylen: usize,
1048 partition_cnt: i32,
1049 rkt_opaque: *mut c_void,
1050 msg_opaque: *mut c_void,
1051 ) -> i32,
1052 >,
1053 );
1054}
1055extern "C" {
1056 pub fn rd_kafka_topic_conf_set_msg_order_cmp(
1057 topic_conf: *mut rd_kafka_topic_conf_t,
1058 msg_order_cmp: Option<
1059 unsafe extern "C" fn(
1060 a: *const rd_kafka_message_t,
1061 b: *const rd_kafka_message_t,
1062 ) -> c_int,
1063 >,
1064 );
1065}
1066extern "C" {
1067 pub fn rd_kafka_topic_partition_available(
1068 rkt: *const rd_kafka_topic_t,
1069 partition: i32,
1070 ) -> c_int;
1071}
1072extern "C" {
1073 pub fn rd_kafka_msg_partitioner_random(
1074 rkt: *const rd_kafka_topic_t,
1075 key: *const c_void,
1076 keylen: usize,
1077 partition_cnt: i32,
1078 rkt_opaque: *mut c_void,
1079 msg_opaque: *mut c_void,
1080 ) -> i32;
1081}
1082extern "C" {
1083 pub fn rd_kafka_msg_partitioner_consistent(
1084 rkt: *const rd_kafka_topic_t,
1085 key: *const c_void,
1086 keylen: usize,
1087 partition_cnt: i32,
1088 rkt_opaque: *mut c_void,
1089 msg_opaque: *mut c_void,
1090 ) -> i32;
1091}
1092extern "C" {
1093 pub fn rd_kafka_msg_partitioner_consistent_random(
1094 rkt: *const rd_kafka_topic_t,
1095 key: *const c_void,
1096 keylen: usize,
1097 partition_cnt: i32,
1098 rkt_opaque: *mut c_void,
1099 msg_opaque: *mut c_void,
1100 ) -> i32;
1101}
1102extern "C" {
1103 pub fn rd_kafka_msg_partitioner_murmur2(
1104 rkt: *const rd_kafka_topic_t,
1105 key: *const c_void,
1106 keylen: usize,
1107 partition_cnt: i32,
1108 rkt_opaque: *mut c_void,
1109 msg_opaque: *mut c_void,
1110 ) -> i32;
1111}
1112extern "C" {
1113 pub fn rd_kafka_msg_partitioner_murmur2_random(
1114 rkt: *const rd_kafka_topic_t,
1115 key: *const c_void,
1116 keylen: usize,
1117 partition_cnt: i32,
1118 rkt_opaque: *mut c_void,
1119 msg_opaque: *mut c_void,
1120 ) -> i32;
1121}
1122extern "C" {
1123 pub fn rd_kafka_msg_partitioner_fnv1a(
1124 rkt: *const rd_kafka_topic_t,
1125 key: *const c_void,
1126 keylen: usize,
1127 partition_cnt: i32,
1128 rkt_opaque: *mut c_void,
1129 msg_opaque: *mut c_void,
1130 ) -> i32;
1131}
1132extern "C" {
1133 pub fn rd_kafka_msg_partitioner_fnv1a_random(
1134 rkt: *const rd_kafka_topic_t,
1135 key: *const c_void,
1136 keylen: usize,
1137 partition_cnt: i32,
1138 rkt_opaque: *mut c_void,
1139 msg_opaque: *mut c_void,
1140 ) -> i32;
1141}
1142extern "C" {
1143 pub fn rd_kafka_new(
1144 type_: rd_kafka_type_t,
1145 conf: *mut rd_kafka_conf_t,
1146 errstr: *mut c_char,
1147 errstr_size: usize,
1148 ) -> *mut rd_kafka_t;
1149}
1150extern "C" {
1151 pub fn rd_kafka_destroy(rk: *mut rd_kafka_t);
1152}
1153extern "C" {
1154 pub fn rd_kafka_destroy_flags(rk: *mut rd_kafka_t, flags: c_int);
1155}
1156extern "C" {
1157 pub fn rd_kafka_name(rk: *const rd_kafka_t) -> *const c_char;
1158}
1159extern "C" {
1160 pub fn rd_kafka_type(rk: *const rd_kafka_t) -> rd_kafka_type_t;
1161}
1162extern "C" {
1163 pub fn rd_kafka_memberid(rk: *const rd_kafka_t) -> *mut c_char;
1164}
1165extern "C" {
1166 pub fn rd_kafka_clusterid(rk: *mut rd_kafka_t, timeout_ms: c_int) -> *mut c_char;
1167}
1168extern "C" {
1169 pub fn rd_kafka_controllerid(rk: *mut rd_kafka_t, timeout_ms: c_int) -> i32;
1170}
1171extern "C" {
1172 pub fn rd_kafka_topic_new(
1173 rk: *mut rd_kafka_t,
1174 topic: *const c_char,
1175 conf: *mut rd_kafka_topic_conf_t,
1176 ) -> *mut rd_kafka_topic_t;
1177}
1178extern "C" {
1179 pub fn rd_kafka_topic_destroy(rkt: *mut rd_kafka_topic_t);
1180}
1181extern "C" {
1182 pub fn rd_kafka_topic_name(rkt: *const rd_kafka_topic_t) -> *const c_char;
1183}
1184extern "C" {
1185 pub fn rd_kafka_topic_opaque(rkt: *const rd_kafka_topic_t) -> *mut c_void;
1186}
1187extern "C" {
1188 pub fn rd_kafka_poll(rk: *mut rd_kafka_t, timeout_ms: c_int) -> c_int;
1189}
1190extern "C" {
1191 pub fn rd_kafka_yield(rk: *mut rd_kafka_t);
1192}
1193extern "C" {
1194 pub fn rd_kafka_pause_partitions(
1195 rk: *mut rd_kafka_t,
1196 partitions: *mut rd_kafka_topic_partition_list_t,
1197 ) -> rd_kafka_resp_err_t;
1198}
1199extern "C" {
1200 pub fn rd_kafka_resume_partitions(
1201 rk: *mut rd_kafka_t,
1202 partitions: *mut rd_kafka_topic_partition_list_t,
1203 ) -> rd_kafka_resp_err_t;
1204}
1205extern "C" {
1206 pub fn rd_kafka_query_watermark_offsets(
1207 rk: *mut rd_kafka_t,
1208 topic: *const c_char,
1209 partition: i32,
1210 low: *mut i64,
1211 high: *mut i64,
1212 timeout_ms: c_int,
1213 ) -> rd_kafka_resp_err_t;
1214}
1215extern "C" {
1216 pub fn rd_kafka_get_watermark_offsets(
1217 rk: *mut rd_kafka_t,
1218 topic: *const c_char,
1219 partition: i32,
1220 low: *mut i64,
1221 high: *mut i64,
1222 ) -> rd_kafka_resp_err_t;
1223}
1224extern "C" {
1225 pub fn rd_kafka_offsets_for_times(
1226 rk: *mut rd_kafka_t,
1227 offsets: *mut rd_kafka_topic_partition_list_t,
1228 timeout_ms: c_int,
1229 ) -> rd_kafka_resp_err_t;
1230}
1231extern "C" {
1232 pub fn rd_kafka_mem_calloc(rk: *mut rd_kafka_t, num: usize, size: usize) -> *mut c_void;
1233}
1234extern "C" {
1235 pub fn rd_kafka_mem_malloc(rk: *mut rd_kafka_t, size: usize) -> *mut c_void;
1236}
1237extern "C" {
1238 pub fn rd_kafka_mem_free(rk: *mut rd_kafka_t, ptr: *mut c_void);
1239}
1240extern "C" {
1241 pub fn rd_kafka_queue_new(rk: *mut rd_kafka_t) -> *mut rd_kafka_queue_t;
1242}
1243extern "C" {
1244 pub fn rd_kafka_queue_destroy(rkqu: *mut rd_kafka_queue_t);
1245}
1246extern "C" {
1247 pub fn rd_kafka_queue_get_main(rk: *mut rd_kafka_t) -> *mut rd_kafka_queue_t;
1248}
1249extern "C" {
1250 pub fn rd_kafka_queue_get_sasl(rk: *mut rd_kafka_t) -> *mut rd_kafka_queue_t;
1251}
1252extern "C" {
1253 pub fn rd_kafka_sasl_background_callbacks_enable(rk: *mut rd_kafka_t) -> *mut rd_kafka_error_t;
1254}
1255extern "C" {
1256 pub fn rd_kafka_sasl_set_credentials(
1257 rk: *mut rd_kafka_t,
1258 username: *const c_char,
1259 password: *const c_char,
1260 ) -> *mut rd_kafka_error_t;
1261}
1262extern "C" {
1263 pub fn rd_kafka_queue_get_consumer(rk: *mut rd_kafka_t) -> *mut rd_kafka_queue_t;
1264}
1265extern "C" {
1266 pub fn rd_kafka_queue_get_partition(
1267 rk: *mut rd_kafka_t,
1268 topic: *const c_char,
1269 partition: i32,
1270 ) -> *mut rd_kafka_queue_t;
1271}
1272extern "C" {
1273 pub fn rd_kafka_queue_get_background(rk: *mut rd_kafka_t) -> *mut rd_kafka_queue_t;
1274}
1275extern "C" {
1276 pub fn rd_kafka_queue_forward(src: *mut rd_kafka_queue_t, dst: *mut rd_kafka_queue_t);
1277}
1278extern "C" {
1279 pub fn rd_kafka_set_log_queue(
1280 rk: *mut rd_kafka_t,
1281 rkqu: *mut rd_kafka_queue_t,
1282 ) -> rd_kafka_resp_err_t;
1283}
1284extern "C" {
1285 pub fn rd_kafka_queue_length(rkqu: *mut rd_kafka_queue_t) -> usize;
1286}
1287extern "C" {
1288 pub fn rd_kafka_queue_io_event_enable(
1289 rkqu: *mut rd_kafka_queue_t,
1290 fd: c_int,
1291 payload: *const c_void,
1292 size: usize,
1293 );
1294}
1295extern "C" {
1296 pub fn rd_kafka_queue_cb_event_enable(
1297 rkqu: *mut rd_kafka_queue_t,
1298 event_cb: Option<unsafe extern "C" fn(rk: *mut rd_kafka_t, qev_opaque: *mut c_void)>,
1299 qev_opaque: *mut c_void,
1300 );
1301}
1302extern "C" {
1303 pub fn rd_kafka_queue_yield(rkqu: *mut rd_kafka_queue_t);
1304}
1305extern "C" {
1306 pub fn rd_kafka_consume_start(rkt: *mut rd_kafka_topic_t, partition: i32, offset: i64)
1307 -> c_int;
1308}
1309extern "C" {
1310 pub fn rd_kafka_consume_start_queue(
1311 rkt: *mut rd_kafka_topic_t,
1312 partition: i32,
1313 offset: i64,
1314 rkqu: *mut rd_kafka_queue_t,
1315 ) -> c_int;
1316}
1317extern "C" {
1318 pub fn rd_kafka_consume_stop(rkt: *mut rd_kafka_topic_t, partition: i32) -> c_int;
1319}
1320extern "C" {
1321 pub fn rd_kafka_seek(
1322 rkt: *mut rd_kafka_topic_t,
1323 partition: i32,
1324 offset: i64,
1325 timeout_ms: c_int,
1326 ) -> rd_kafka_resp_err_t;
1327}
1328extern "C" {
1329 pub fn rd_kafka_seek_partitions(
1330 rk: *mut rd_kafka_t,
1331 partitions: *mut rd_kafka_topic_partition_list_t,
1332 timeout_ms: c_int,
1333 ) -> *mut rd_kafka_error_t;
1334}
1335extern "C" {
1336 pub fn rd_kafka_consume(
1337 rkt: *mut rd_kafka_topic_t,
1338 partition: i32,
1339 timeout_ms: c_int,
1340 ) -> *mut rd_kafka_message_t;
1341}
1342extern "C" {
1343 pub fn rd_kafka_consume_batch(
1344 rkt: *mut rd_kafka_topic_t,
1345 partition: i32,
1346 timeout_ms: c_int,
1347 rkmessages: *mut *mut rd_kafka_message_t,
1348 rkmessages_size: usize,
1349 ) -> isize;
1350}
1351extern "C" {
1352 pub fn rd_kafka_consume_callback(
1353 rkt: *mut rd_kafka_topic_t,
1354 partition: i32,
1355 timeout_ms: c_int,
1356 consume_cb: Option<
1357 unsafe extern "C" fn(rkmessage: *mut rd_kafka_message_t, commit_opaque: *mut c_void),
1358 >,
1359 commit_opaque: *mut c_void,
1360 ) -> c_int;
1361}
1362extern "C" {
1363 pub fn rd_kafka_consume_queue(
1364 rkqu: *mut rd_kafka_queue_t,
1365 timeout_ms: c_int,
1366 ) -> *mut rd_kafka_message_t;
1367}
1368extern "C" {
1369 pub fn rd_kafka_consume_batch_queue(
1370 rkqu: *mut rd_kafka_queue_t,
1371 timeout_ms: c_int,
1372 rkmessages: *mut *mut rd_kafka_message_t,
1373 rkmessages_size: usize,
1374 ) -> isize;
1375}
1376extern "C" {
1377 pub fn rd_kafka_consume_callback_queue(
1378 rkqu: *mut rd_kafka_queue_t,
1379 timeout_ms: c_int,
1380 consume_cb: Option<
1381 unsafe extern "C" fn(rkmessage: *mut rd_kafka_message_t, commit_opaque: *mut c_void),
1382 >,
1383 commit_opaque: *mut c_void,
1384 ) -> c_int;
1385}
1386extern "C" {
1387 pub fn rd_kafka_offset_store(
1388 rkt: *mut rd_kafka_topic_t,
1389 partition: i32,
1390 offset: i64,
1391 ) -> rd_kafka_resp_err_t;
1392}
1393extern "C" {
1394 pub fn rd_kafka_offsets_store(
1395 rk: *mut rd_kafka_t,
1396 offsets: *mut rd_kafka_topic_partition_list_t,
1397 ) -> rd_kafka_resp_err_t;
1398}
1399extern "C" {
1400 pub fn rd_kafka_offset_store_message(
1401 rkmessage: *mut rd_kafka_message_t,
1402 ) -> *mut rd_kafka_error_t;
1403}
1404extern "C" {
1405 pub fn rd_kafka_subscribe(
1406 rk: *mut rd_kafka_t,
1407 topics: *const rd_kafka_topic_partition_list_t,
1408 ) -> rd_kafka_resp_err_t;
1409}
1410extern "C" {
1411 pub fn rd_kafka_unsubscribe(rk: *mut rd_kafka_t) -> rd_kafka_resp_err_t;
1412}
1413extern "C" {
1414 pub fn rd_kafka_subscription(
1415 rk: *mut rd_kafka_t,
1416 topics: *mut *mut rd_kafka_topic_partition_list_t,
1417 ) -> rd_kafka_resp_err_t;
1418}
1419extern "C" {
1420 pub fn rd_kafka_consumer_poll(
1421 rk: *mut rd_kafka_t,
1422 timeout_ms: c_int,
1423 ) -> *mut rd_kafka_message_t;
1424}
1425extern "C" {
1426 pub fn rd_kafka_consumer_close(rk: *mut rd_kafka_t) -> rd_kafka_resp_err_t;
1427}
1428extern "C" {
1429 pub fn rd_kafka_consumer_close_queue(
1430 rk: *mut rd_kafka_t,
1431 rkqu: *mut rd_kafka_queue_t,
1432 ) -> *mut rd_kafka_error_t;
1433}
1434extern "C" {
1435 pub fn rd_kafka_consumer_closed(rk: *mut rd_kafka_t) -> c_int;
1436}
1437extern "C" {
1438 pub fn rd_kafka_incremental_assign(
1439 rk: *mut rd_kafka_t,
1440 partitions: *const rd_kafka_topic_partition_list_t,
1441 ) -> *mut rd_kafka_error_t;
1442}
1443extern "C" {
1444 pub fn rd_kafka_incremental_unassign(
1445 rk: *mut rd_kafka_t,
1446 partitions: *const rd_kafka_topic_partition_list_t,
1447 ) -> *mut rd_kafka_error_t;
1448}
1449extern "C" {
1450 pub fn rd_kafka_rebalance_protocol(rk: *mut rd_kafka_t) -> *const c_char;
1451}
1452extern "C" {
1453 pub fn rd_kafka_assign(
1454 rk: *mut rd_kafka_t,
1455 partitions: *const rd_kafka_topic_partition_list_t,
1456 ) -> rd_kafka_resp_err_t;
1457}
1458extern "C" {
1459 pub fn rd_kafka_assignment(
1460 rk: *mut rd_kafka_t,
1461 partitions: *mut *mut rd_kafka_topic_partition_list_t,
1462 ) -> rd_kafka_resp_err_t;
1463}
1464extern "C" {
1465 pub fn rd_kafka_assignment_lost(rk: *mut rd_kafka_t) -> c_int;
1466}
1467extern "C" {
1468 pub fn rd_kafka_commit(
1469 rk: *mut rd_kafka_t,
1470 offsets: *const rd_kafka_topic_partition_list_t,
1471 async_: c_int,
1472 ) -> rd_kafka_resp_err_t;
1473}
1474extern "C" {
1475 pub fn rd_kafka_commit_message(
1476 rk: *mut rd_kafka_t,
1477 rkmessage: *const rd_kafka_message_t,
1478 async_: c_int,
1479 ) -> rd_kafka_resp_err_t;
1480}
1481extern "C" {
1482 pub fn rd_kafka_commit_queue(
1483 rk: *mut rd_kafka_t,
1484 offsets: *const rd_kafka_topic_partition_list_t,
1485 rkqu: *mut rd_kafka_queue_t,
1486 cb: Option<
1487 unsafe extern "C" fn(
1488 rk: *mut rd_kafka_t,
1489 err: rd_kafka_resp_err_t,
1490 offsets: *mut rd_kafka_topic_partition_list_t,
1491 commit_opaque: *mut c_void,
1492 ),
1493 >,
1494 commit_opaque: *mut c_void,
1495 ) -> rd_kafka_resp_err_t;
1496}
1497extern "C" {
1498 pub fn rd_kafka_committed(
1499 rk: *mut rd_kafka_t,
1500 partitions: *mut rd_kafka_topic_partition_list_t,
1501 timeout_ms: c_int,
1502 ) -> rd_kafka_resp_err_t;
1503}
1504extern "C" {
1505 pub fn rd_kafka_position(
1506 rk: *mut rd_kafka_t,
1507 partitions: *mut rd_kafka_topic_partition_list_t,
1508 ) -> rd_kafka_resp_err_t;
1509}
1510extern "C" {
1511 pub fn rd_kafka_consumer_group_metadata(
1512 rk: *mut rd_kafka_t,
1513 ) -> *mut rd_kafka_consumer_group_metadata_t;
1514}
1515extern "C" {
1516 pub fn rd_kafka_consumer_group_metadata_new(
1517 group_id: *const c_char,
1518 ) -> *mut rd_kafka_consumer_group_metadata_t;
1519}
1520extern "C" {
1521 pub fn rd_kafka_consumer_group_metadata_new_with_genid(
1522 group_id: *const c_char,
1523 generation_id: i32,
1524 member_id: *const c_char,
1525 group_instance_id: *const c_char,
1526 ) -> *mut rd_kafka_consumer_group_metadata_t;
1527}
1528extern "C" {
1529 pub fn rd_kafka_consumer_group_metadata_member_id(
1530 group_metadata: *const rd_kafka_consumer_group_metadata_t,
1531 ) -> *const c_char;
1532}
1533extern "C" {
1534 pub fn rd_kafka_consumer_group_metadata_destroy(arg1: *mut rd_kafka_consumer_group_metadata_t);
1535}
1536extern "C" {
1537 pub fn rd_kafka_consumer_group_metadata_write(
1538 cgmd: *const rd_kafka_consumer_group_metadata_t,
1539 bufferp: *mut *mut c_void,
1540 sizep: *mut usize,
1541 ) -> *mut rd_kafka_error_t;
1542}
1543extern "C" {
1544 pub fn rd_kafka_consumer_group_metadata_read(
1545 cgmdp: *mut *mut rd_kafka_consumer_group_metadata_t,
1546 buffer: *const c_void,
1547 size: usize,
1548 ) -> *mut rd_kafka_error_t;
1549}
1550extern "C" {
1551 pub fn rd_kafka_produce(
1552 rkt: *mut rd_kafka_topic_t,
1553 partition: i32,
1554 msgflags: c_int,
1555 payload: *mut c_void,
1556 len: usize,
1557 key: *const c_void,
1558 keylen: usize,
1559 msg_opaque: *mut c_void,
1560 ) -> c_int;
1561}
1562extern "C" {
1563 pub fn rd_kafka_producev(rk: *mut rd_kafka_t, ...) -> rd_kafka_resp_err_t;
1564}
1565extern "C" {
1566 pub fn rd_kafka_produceva(
1567 rk: *mut rd_kafka_t,
1568 vus: *const rd_kafka_vu_t,
1569 cnt: usize,
1570 ) -> *mut rd_kafka_error_t;
1571}
1572extern "C" {
1573 pub fn rd_kafka_produce_batch(
1574 rkt: *mut rd_kafka_topic_t,
1575 partition: i32,
1576 msgflags: c_int,
1577 rkmessages: *mut rd_kafka_message_t,
1578 message_cnt: c_int,
1579 ) -> c_int;
1580}
1581extern "C" {
1582 pub fn rd_kafka_flush(rk: *mut rd_kafka_t, timeout_ms: c_int) -> rd_kafka_resp_err_t;
1583}
1584extern "C" {
1585 pub fn rd_kafka_purge(rk: *mut rd_kafka_t, purge_flags: c_int) -> rd_kafka_resp_err_t;
1586}
1587#[repr(C)]
1588#[derive(Debug, Copy, Clone)]
1589pub struct rd_kafka_metadata_broker {
1590 pub id: i32,
1591 pub host: *mut c_char,
1592 pub port: c_int,
1593}
1594pub type rd_kafka_metadata_broker_t = rd_kafka_metadata_broker;
1595#[repr(C)]
1596#[derive(Debug, Copy, Clone)]
1597pub struct rd_kafka_metadata_partition {
1598 pub id: i32,
1599 pub err: rd_kafka_resp_err_t,
1600 pub leader: i32,
1601 pub replica_cnt: c_int,
1602 pub replicas: *mut i32,
1603 pub isr_cnt: c_int,
1604 pub isrs: *mut i32,
1605}
1606pub type rd_kafka_metadata_partition_t = rd_kafka_metadata_partition;
1607#[repr(C)]
1608#[derive(Debug, Copy, Clone)]
1609pub struct rd_kafka_metadata_topic {
1610 pub topic: *mut c_char,
1611 pub partition_cnt: c_int,
1612 pub partitions: *mut rd_kafka_metadata_partition,
1613 pub err: rd_kafka_resp_err_t,
1614}
1615pub type rd_kafka_metadata_topic_t = rd_kafka_metadata_topic;
1616#[repr(C)]
1617#[derive(Debug, Copy, Clone)]
1618pub struct rd_kafka_metadata {
1619 pub broker_cnt: c_int,
1620 pub brokers: *mut rd_kafka_metadata_broker,
1621 pub topic_cnt: c_int,
1622 pub topics: *mut rd_kafka_metadata_topic,
1623 pub orig_broker_id: i32,
1624 pub orig_broker_name: *mut c_char,
1625}
1626pub type rd_kafka_metadata_t = rd_kafka_metadata;
1627extern "C" {
1628 pub fn rd_kafka_metadata(
1629 rk: *mut rd_kafka_t,
1630 all_topics: c_int,
1631 only_rkt: *mut rd_kafka_topic_t,
1632 metadatap: *mut *const rd_kafka_metadata,
1633 timeout_ms: c_int,
1634 ) -> rd_kafka_resp_err_t;
1635}
1636extern "C" {
1637 pub fn rd_kafka_metadata_destroy(metadata: *const rd_kafka_metadata);
1638}
1639#[repr(C)]
1640#[derive(Debug, Copy, Clone)]
1641pub struct rd_kafka_Node_s {
1642 _unused: [u8; 0],
1643}
1644pub type rd_kafka_Node_t = rd_kafka_Node_s;
1645extern "C" {
1646 pub fn rd_kafka_Node_id(node: *const rd_kafka_Node_t) -> c_int;
1647}
1648extern "C" {
1649 pub fn rd_kafka_Node_host(node: *const rd_kafka_Node_t) -> *const c_char;
1650}
1651extern "C" {
1652 pub fn rd_kafka_Node_port(node: *const rd_kafka_Node_t) -> u16;
1653}
1654extern "C" {
1655 pub fn rd_kafka_Node_rack(node: *const rd_kafka_Node_t) -> *const c_char;
1656}
1657#[repr(C)]
1658#[derive(Debug, Copy, Clone)]
1659pub struct rd_kafka_group_member_info {
1660 pub member_id: *mut c_char,
1661 pub client_id: *mut c_char,
1662 pub client_host: *mut c_char,
1663 pub member_metadata: *mut c_void,
1664 pub member_metadata_size: c_int,
1665 pub member_assignment: *mut c_void,
1666 pub member_assignment_size: c_int,
1667}
1668#[repr(u32)]
1669#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1670pub enum rd_kafka_consumer_group_state_t {
1671 RD_KAFKA_CONSUMER_GROUP_STATE_UNKNOWN = 0,
1672 RD_KAFKA_CONSUMER_GROUP_STATE_PREPARING_REBALANCE = 1,
1673 RD_KAFKA_CONSUMER_GROUP_STATE_COMPLETING_REBALANCE = 2,
1674 RD_KAFKA_CONSUMER_GROUP_STATE_STABLE = 3,
1675 RD_KAFKA_CONSUMER_GROUP_STATE_DEAD = 4,
1676 RD_KAFKA_CONSUMER_GROUP_STATE_EMPTY = 5,
1677 RD_KAFKA_CONSUMER_GROUP_STATE__CNT = 6,
1678}
1679#[repr(C)]
1680#[derive(Debug, Copy, Clone)]
1681pub struct rd_kafka_group_info {
1682 pub broker: rd_kafka_metadata_broker,
1683 pub group: *mut c_char,
1684 pub err: rd_kafka_resp_err_t,
1685 pub state: *mut c_char,
1686 pub protocol_type: *mut c_char,
1687 pub protocol: *mut c_char,
1688 pub members: *mut rd_kafka_group_member_info,
1689 pub member_cnt: c_int,
1690}
1691#[repr(C)]
1692#[derive(Debug, Copy, Clone)]
1693pub struct rd_kafka_group_list {
1694 pub groups: *mut rd_kafka_group_info,
1695 pub group_cnt: c_int,
1696}
1697extern "C" {
1698 pub fn rd_kafka_list_groups(
1699 rk: *mut rd_kafka_t,
1700 group: *const c_char,
1701 grplistp: *mut *const rd_kafka_group_list,
1702 timeout_ms: c_int,
1703 ) -> rd_kafka_resp_err_t;
1704}
1705extern "C" {
1706 pub fn rd_kafka_consumer_group_state_name(
1707 state: rd_kafka_consumer_group_state_t,
1708 ) -> *const c_char;
1709}
1710extern "C" {
1711 pub fn rd_kafka_consumer_group_state_code(
1712 name: *const c_char,
1713 ) -> rd_kafka_consumer_group_state_t;
1714}
1715extern "C" {
1716 pub fn rd_kafka_group_list_destroy(grplist: *const rd_kafka_group_list);
1717}
1718extern "C" {
1719 pub fn rd_kafka_brokers_add(rk: *mut rd_kafka_t, brokerlist: *const c_char) -> c_int;
1720}
1721extern "C" {
1722 pub fn rd_kafka_set_logger(
1723 rk: *mut rd_kafka_t,
1724 func: Option<
1725 unsafe extern "C" fn(
1726 rk: *const rd_kafka_t,
1727 level: c_int,
1728 fac: *const c_char,
1729 buf: *const c_char,
1730 ),
1731 >,
1732 );
1733}
1734extern "C" {
1735 pub fn rd_kafka_set_log_level(rk: *mut rd_kafka_t, level: c_int);
1736}
1737extern "C" {
1738 pub fn rd_kafka_log_print(
1739 rk: *const rd_kafka_t,
1740 level: c_int,
1741 fac: *const c_char,
1742 buf: *const c_char,
1743 );
1744}
1745extern "C" {
1746 pub fn rd_kafka_log_syslog(
1747 rk: *const rd_kafka_t,
1748 level: c_int,
1749 fac: *const c_char,
1750 buf: *const c_char,
1751 );
1752}
1753extern "C" {
1754 pub fn rd_kafka_outq_len(rk: *mut rd_kafka_t) -> c_int;
1755}
1756extern "C" {
1757 pub fn rd_kafka_dump(fp: *mut FILE, rk: *mut rd_kafka_t);
1758}
1759extern "C" {
1760 pub fn rd_kafka_thread_cnt() -> c_int;
1761}
1762#[repr(u32)]
1763#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1764pub enum rd_kafka_thread_type_t {
1765 RD_KAFKA_THREAD_MAIN = 0,
1766 RD_KAFKA_THREAD_BACKGROUND = 1,
1767 RD_KAFKA_THREAD_BROKER = 2,
1768}
1769extern "C" {
1770 pub fn rd_kafka_wait_destroyed(timeout_ms: c_int) -> ::std::os::raw::c_int;
1771}
1772extern "C" {
1773 pub fn rd_kafka_unittest() -> c_int;
1774}
1775extern "C" {
1776 pub fn rd_kafka_poll_set_consumer(rk: *mut rd_kafka_t) -> rd_kafka_resp_err_t;
1777}
1778pub type rd_kafka_event_type_t = c_int;
1779extern "C" {
1780 pub fn rd_kafka_event_type(rkev: *const rd_kafka_event_t) -> rd_kafka_event_type_t;
1781}
1782extern "C" {
1783 pub fn rd_kafka_event_name(rkev: *const rd_kafka_event_t) -> *const c_char;
1784}
1785extern "C" {
1786 pub fn rd_kafka_event_destroy(rkev: *mut rd_kafka_event_t);
1787}
1788extern "C" {
1789 pub fn rd_kafka_event_message_next(rkev: *mut rd_kafka_event_t) -> *const rd_kafka_message_t;
1790}
1791extern "C" {
1792 pub fn rd_kafka_event_message_array(
1793 rkev: *mut rd_kafka_event_t,
1794 rkmessages: *mut *const rd_kafka_message_t,
1795 size: usize,
1796 ) -> usize;
1797}
1798extern "C" {
1799 pub fn rd_kafka_event_message_count(rkev: *mut rd_kafka_event_t) -> usize;
1800}
1801extern "C" {
1802 pub fn rd_kafka_event_config_string(rkev: *mut rd_kafka_event_t) -> *const c_char;
1803}
1804extern "C" {
1805 pub fn rd_kafka_event_error(rkev: *mut rd_kafka_event_t) -> rd_kafka_resp_err_t;
1806}
1807extern "C" {
1808 pub fn rd_kafka_event_error_string(rkev: *mut rd_kafka_event_t) -> *const c_char;
1809}
1810extern "C" {
1811 pub fn rd_kafka_event_error_is_fatal(rkev: *mut rd_kafka_event_t) -> c_int;
1812}
1813extern "C" {
1814 pub fn rd_kafka_event_opaque(rkev: *mut rd_kafka_event_t) -> *mut c_void;
1815}
1816extern "C" {
1817 pub fn rd_kafka_event_log(
1818 rkev: *mut rd_kafka_event_t,
1819 fac: *mut *const c_char,
1820 str_: *mut *const c_char,
1821 level: *mut c_int,
1822 ) -> c_int;
1823}
1824extern "C" {
1825 pub fn rd_kafka_event_debug_contexts(
1826 rkev: *mut rd_kafka_event_t,
1827 dst: *mut c_char,
1828 dstsize: usize,
1829 ) -> c_int;
1830}
1831extern "C" {
1832 pub fn rd_kafka_event_stats(rkev: *mut rd_kafka_event_t) -> *const c_char;
1833}
1834extern "C" {
1835 pub fn rd_kafka_event_topic_partition_list(
1836 rkev: *mut rd_kafka_event_t,
1837 ) -> *mut rd_kafka_topic_partition_list_t;
1838}
1839extern "C" {
1840 pub fn rd_kafka_event_topic_partition(
1841 rkev: *mut rd_kafka_event_t,
1842 ) -> *mut rd_kafka_topic_partition_t;
1843}
1844pub type rd_kafka_CreateTopics_result_t = rd_kafka_event_t;
1845pub type rd_kafka_DeleteTopics_result_t = rd_kafka_event_t;
1846pub type rd_kafka_CreateAcls_result_t = rd_kafka_event_t;
1847pub type rd_kafka_DescribeAcls_result_t = rd_kafka_event_t;
1848pub type rd_kafka_DeleteAcls_result_t = rd_kafka_event_t;
1849pub type rd_kafka_CreatePartitions_result_t = rd_kafka_event_t;
1850pub type rd_kafka_AlterConfigs_result_t = rd_kafka_event_t;
1851pub type rd_kafka_IncrementalAlterConfigs_result_t = rd_kafka_event_t;
1852pub type rd_kafka_DescribeConfigs_result_t = rd_kafka_event_t;
1853pub type rd_kafka_DeleteRecords_result_t = rd_kafka_event_t;
1854pub type rd_kafka_ListConsumerGroups_result_t = rd_kafka_event_t;
1855pub type rd_kafka_DescribeConsumerGroups_result_t = rd_kafka_event_t;
1856pub type rd_kafka_DeleteGroups_result_t = rd_kafka_event_t;
1857pub type rd_kafka_DeleteConsumerGroupOffsets_result_t = rd_kafka_event_t;
1858pub type rd_kafka_AlterConsumerGroupOffsets_result_t = rd_kafka_event_t;
1859pub type rd_kafka_ListConsumerGroupOffsets_result_t = rd_kafka_event_t;
1860pub type rd_kafka_DescribeTopics_result_t = rd_kafka_event_t;
1861pub type rd_kafka_DescribeCluster_result_t = rd_kafka_event_t;
1862pub type rd_kafka_DescribeUserScramCredentials_result_t = rd_kafka_event_t;
1863pub type rd_kafka_AlterUserScramCredentials_result_t = rd_kafka_event_t;
1864pub type rd_kafka_ListOffsets_result_t = rd_kafka_event_t;
1865extern "C" {
1866 pub fn rd_kafka_event_CreateTopics_result(
1867 rkev: *mut rd_kafka_event_t,
1868 ) -> *const rd_kafka_CreateTopics_result_t;
1869}
1870extern "C" {
1871 pub fn rd_kafka_event_DeleteTopics_result(
1872 rkev: *mut rd_kafka_event_t,
1873 ) -> *const rd_kafka_DeleteTopics_result_t;
1874}
1875extern "C" {
1876 pub fn rd_kafka_event_CreatePartitions_result(
1877 rkev: *mut rd_kafka_event_t,
1878 ) -> *const rd_kafka_CreatePartitions_result_t;
1879}
1880extern "C" {
1881 pub fn rd_kafka_event_AlterConfigs_result(
1882 rkev: *mut rd_kafka_event_t,
1883 ) -> *const rd_kafka_AlterConfigs_result_t;
1884}
1885extern "C" {
1886 pub fn rd_kafka_event_IncrementalAlterConfigs_result(
1887 rkev: *mut rd_kafka_event_t,
1888 ) -> *const rd_kafka_IncrementalAlterConfigs_result_t;
1889}
1890extern "C" {
1891 pub fn rd_kafka_event_DescribeConfigs_result(
1892 rkev: *mut rd_kafka_event_t,
1893 ) -> *const rd_kafka_DescribeConfigs_result_t;
1894}
1895extern "C" {
1896 pub fn rd_kafka_event_DeleteRecords_result(
1897 rkev: *mut rd_kafka_event_t,
1898 ) -> *const rd_kafka_DeleteRecords_result_t;
1899}
1900extern "C" {
1901 pub fn rd_kafka_event_ListConsumerGroups_result(
1902 rkev: *mut rd_kafka_event_t,
1903 ) -> *const rd_kafka_ListConsumerGroups_result_t;
1904}
1905extern "C" {
1906 pub fn rd_kafka_event_DescribeConsumerGroups_result(
1907 rkev: *mut rd_kafka_event_t,
1908 ) -> *const rd_kafka_DescribeConsumerGroups_result_t;
1909}
1910extern "C" {
1911 pub fn rd_kafka_event_DescribeTopics_result(
1912 rkev: *mut rd_kafka_event_t,
1913 ) -> *const rd_kafka_DescribeTopics_result_t;
1914}
1915extern "C" {
1916 pub fn rd_kafka_event_DescribeCluster_result(
1917 rkev: *mut rd_kafka_event_t,
1918 ) -> *const rd_kafka_DescribeCluster_result_t;
1919}
1920extern "C" {
1921 pub fn rd_kafka_event_DeleteGroups_result(
1922 rkev: *mut rd_kafka_event_t,
1923 ) -> *const rd_kafka_DeleteGroups_result_t;
1924}
1925extern "C" {
1926 pub fn rd_kafka_event_DeleteConsumerGroupOffsets_result(
1927 rkev: *mut rd_kafka_event_t,
1928 ) -> *const rd_kafka_DeleteConsumerGroupOffsets_result_t;
1929}
1930extern "C" {
1931 pub fn rd_kafka_event_CreateAcls_result(
1932 rkev: *mut rd_kafka_event_t,
1933 ) -> *const rd_kafka_CreateAcls_result_t;
1934}
1935extern "C" {
1936 pub fn rd_kafka_event_DescribeAcls_result(
1937 rkev: *mut rd_kafka_event_t,
1938 ) -> *const rd_kafka_DescribeAcls_result_t;
1939}
1940extern "C" {
1941 pub fn rd_kafka_event_DeleteAcls_result(
1942 rkev: *mut rd_kafka_event_t,
1943 ) -> *const rd_kafka_DeleteAcls_result_t;
1944}
1945extern "C" {
1946 pub fn rd_kafka_event_ListConsumerGroupOffsets_result(
1947 rkev: *mut rd_kafka_event_t,
1948 ) -> *const rd_kafka_ListConsumerGroupOffsets_result_t;
1949}
1950extern "C" {
1951 pub fn rd_kafka_event_AlterConsumerGroupOffsets_result(
1952 rkev: *mut rd_kafka_event_t,
1953 ) -> *const rd_kafka_AlterConsumerGroupOffsets_result_t;
1954}
1955extern "C" {
1956 pub fn rd_kafka_event_ListOffsets_result(
1957 rkev: *mut rd_kafka_event_t,
1958 ) -> *const rd_kafka_ListOffsets_result_t;
1959}
1960extern "C" {
1961 pub fn rd_kafka_event_DescribeUserScramCredentials_result(
1962 rkev: *mut rd_kafka_event_t,
1963 ) -> *const rd_kafka_DescribeUserScramCredentials_result_t;
1964}
1965extern "C" {
1966 pub fn rd_kafka_event_AlterUserScramCredentials_result(
1967 rkev: *mut rd_kafka_event_t,
1968 ) -> *const rd_kafka_AlterUserScramCredentials_result_t;
1969}
1970extern "C" {
1971 pub fn rd_kafka_queue_poll(
1972 rkqu: *mut rd_kafka_queue_t,
1973 timeout_ms: c_int,
1974 ) -> *mut rd_kafka_event_t;
1975}
1976extern "C" {
1977 pub fn rd_kafka_queue_poll_callback(rkqu: *mut rd_kafka_queue_t, timeout_ms: c_int) -> c_int;
1978}
1979pub type rd_kafka_plugin_f_conf_init_t = Option<
1980 unsafe extern "C" fn(
1981 conf: *mut rd_kafka_conf_t,
1982 plug_opaquep: *mut *mut c_void,
1983 errstr: *mut c_char,
1984 errstr_size: usize,
1985 ) -> rd_kafka_resp_err_t,
1986>;
1987pub type rd_kafka_interceptor_f_on_conf_set_t = Option<
1988 unsafe extern "C" fn(
1989 conf: *mut rd_kafka_conf_t,
1990 name: *const c_char,
1991 val: *const c_char,
1992 errstr: *mut c_char,
1993 errstr_size: usize,
1994 ic_opaque: *mut c_void,
1995 ) -> rd_kafka_conf_res_t,
1996>;
1997pub type rd_kafka_interceptor_f_on_conf_dup_t = Option<
1998 unsafe extern "C" fn(
1999 new_conf: *mut rd_kafka_conf_t,
2000 old_conf: *const rd_kafka_conf_t,
2001 filter_cnt: usize,
2002 filter: *mut *const c_char,
2003 ic_opaque: *mut c_void,
2004 ) -> rd_kafka_resp_err_t,
2005>;
2006pub type rd_kafka_interceptor_f_on_conf_destroy_t =
2007 Option<unsafe extern "C" fn(ic_opaque: *mut c_void) -> rd_kafka_resp_err_t>;
2008pub type rd_kafka_interceptor_f_on_new_t = Option<
2009 unsafe extern "C" fn(
2010 rk: *mut rd_kafka_t,
2011 conf: *const rd_kafka_conf_t,
2012 ic_opaque: *mut c_void,
2013 errstr: *mut c_char,
2014 errstr_size: usize,
2015 ) -> rd_kafka_resp_err_t,
2016>;
2017pub type rd_kafka_interceptor_f_on_destroy_t = Option<
2018 unsafe extern "C" fn(rk: *mut rd_kafka_t, ic_opaque: *mut c_void) -> rd_kafka_resp_err_t,
2019>;
2020pub type rd_kafka_interceptor_f_on_send_t = Option<
2021 unsafe extern "C" fn(
2022 rk: *mut rd_kafka_t,
2023 rkmessage: *mut rd_kafka_message_t,
2024 ic_opaque: *mut c_void,
2025 ) -> rd_kafka_resp_err_t,
2026>;
2027pub type rd_kafka_interceptor_f_on_acknowledgement_t = Option<
2028 unsafe extern "C" fn(
2029 rk: *mut rd_kafka_t,
2030 rkmessage: *mut rd_kafka_message_t,
2031 ic_opaque: *mut c_void,
2032 ) -> rd_kafka_resp_err_t,
2033>;
2034pub type rd_kafka_interceptor_f_on_consume_t = Option<
2035 unsafe extern "C" fn(
2036 rk: *mut rd_kafka_t,
2037 rkmessage: *mut rd_kafka_message_t,
2038 ic_opaque: *mut c_void,
2039 ) -> rd_kafka_resp_err_t,
2040>;
2041pub type rd_kafka_interceptor_f_on_commit_t = Option<
2042 unsafe extern "C" fn(
2043 rk: *mut rd_kafka_t,
2044 offsets: *const rd_kafka_topic_partition_list_t,
2045 err: rd_kafka_resp_err_t,
2046 ic_opaque: *mut c_void,
2047 ) -> rd_kafka_resp_err_t,
2048>;
2049pub type rd_kafka_interceptor_f_on_request_sent_t = Option<
2050 unsafe extern "C" fn(
2051 rk: *mut rd_kafka_t,
2052 sockfd: c_int,
2053 brokername: *const c_char,
2054 brokerid: i32,
2055 ApiKey: i16,
2056 ApiVersion: i16,
2057 CorrId: i32,
2058 size: usize,
2059 ic_opaque: *mut c_void,
2060 ) -> rd_kafka_resp_err_t,
2061>;
2062pub type rd_kafka_interceptor_f_on_response_received_t = Option<
2063 unsafe extern "C" fn(
2064 rk: *mut rd_kafka_t,
2065 sockfd: c_int,
2066 brokername: *const c_char,
2067 brokerid: i32,
2068 ApiKey: i16,
2069 ApiVersion: i16,
2070 CorrId: i32,
2071 size: usize,
2072 rtt: i64,
2073 err: rd_kafka_resp_err_t,
2074 ic_opaque: *mut c_void,
2075 ) -> rd_kafka_resp_err_t,
2076>;
2077pub type rd_kafka_interceptor_f_on_thread_start_t = Option<
2078 unsafe extern "C" fn(
2079 rk: *mut rd_kafka_t,
2080 thread_type: rd_kafka_thread_type_t,
2081 thread_name: *const c_char,
2082 ic_opaque: *mut c_void,
2083 ) -> rd_kafka_resp_err_t,
2084>;
2085pub type rd_kafka_interceptor_f_on_thread_exit_t = Option<
2086 unsafe extern "C" fn(
2087 rk: *mut rd_kafka_t,
2088 thread_type: rd_kafka_thread_type_t,
2089 thread_name: *const c_char,
2090 ic_opaque: *mut c_void,
2091 ) -> rd_kafka_resp_err_t,
2092>;
2093pub type rd_kafka_interceptor_f_on_broker_state_change_t = Option<
2094 unsafe extern "C" fn(
2095 rk: *mut rd_kafka_t,
2096 broker_id: i32,
2097 secproto: *const c_char,
2098 name: *const c_char,
2099 port: c_int,
2100 state: *const c_char,
2101 ic_opaque: *mut c_void,
2102 ) -> rd_kafka_resp_err_t,
2103>;
2104extern "C" {
2105 pub fn rd_kafka_conf_interceptor_add_on_conf_set(
2106 conf: *mut rd_kafka_conf_t,
2107 ic_name: *const c_char,
2108 on_conf_set: rd_kafka_interceptor_f_on_conf_set_t,
2109 ic_opaque: *mut c_void,
2110 ) -> rd_kafka_resp_err_t;
2111}
2112extern "C" {
2113 pub fn rd_kafka_conf_interceptor_add_on_conf_dup(
2114 conf: *mut rd_kafka_conf_t,
2115 ic_name: *const c_char,
2116 on_conf_dup: rd_kafka_interceptor_f_on_conf_dup_t,
2117 ic_opaque: *mut c_void,
2118 ) -> rd_kafka_resp_err_t;
2119}
2120extern "C" {
2121 pub fn rd_kafka_conf_interceptor_add_on_conf_destroy(
2122 conf: *mut rd_kafka_conf_t,
2123 ic_name: *const c_char,
2124 on_conf_destroy: rd_kafka_interceptor_f_on_conf_destroy_t,
2125 ic_opaque: *mut c_void,
2126 ) -> rd_kafka_resp_err_t;
2127}
2128extern "C" {
2129 pub fn rd_kafka_conf_interceptor_add_on_new(
2130 conf: *mut rd_kafka_conf_t,
2131 ic_name: *const c_char,
2132 on_new: rd_kafka_interceptor_f_on_new_t,
2133 ic_opaque: *mut c_void,
2134 ) -> rd_kafka_resp_err_t;
2135}
2136extern "C" {
2137 pub fn rd_kafka_interceptor_add_on_destroy(
2138 rk: *mut rd_kafka_t,
2139 ic_name: *const c_char,
2140 on_destroy: rd_kafka_interceptor_f_on_destroy_t,
2141 ic_opaque: *mut c_void,
2142 ) -> rd_kafka_resp_err_t;
2143}
2144extern "C" {
2145 pub fn rd_kafka_interceptor_add_on_send(
2146 rk: *mut rd_kafka_t,
2147 ic_name: *const c_char,
2148 on_send: rd_kafka_interceptor_f_on_send_t,
2149 ic_opaque: *mut c_void,
2150 ) -> rd_kafka_resp_err_t;
2151}
2152extern "C" {
2153 pub fn rd_kafka_interceptor_add_on_acknowledgement(
2154 rk: *mut rd_kafka_t,
2155 ic_name: *const c_char,
2156 on_acknowledgement: rd_kafka_interceptor_f_on_acknowledgement_t,
2157 ic_opaque: *mut c_void,
2158 ) -> rd_kafka_resp_err_t;
2159}
2160extern "C" {
2161 pub fn rd_kafka_interceptor_add_on_consume(
2162 rk: *mut rd_kafka_t,
2163 ic_name: *const c_char,
2164 on_consume: rd_kafka_interceptor_f_on_consume_t,
2165 ic_opaque: *mut c_void,
2166 ) -> rd_kafka_resp_err_t;
2167}
2168extern "C" {
2169 pub fn rd_kafka_interceptor_add_on_commit(
2170 rk: *mut rd_kafka_t,
2171 ic_name: *const c_char,
2172 on_commit: rd_kafka_interceptor_f_on_commit_t,
2173 ic_opaque: *mut c_void,
2174 ) -> rd_kafka_resp_err_t;
2175}
2176extern "C" {
2177 pub fn rd_kafka_interceptor_add_on_request_sent(
2178 rk: *mut rd_kafka_t,
2179 ic_name: *const c_char,
2180 on_request_sent: rd_kafka_interceptor_f_on_request_sent_t,
2181 ic_opaque: *mut c_void,
2182 ) -> rd_kafka_resp_err_t;
2183}
2184extern "C" {
2185 pub fn rd_kafka_interceptor_add_on_response_received(
2186 rk: *mut rd_kafka_t,
2187 ic_name: *const c_char,
2188 on_response_received: rd_kafka_interceptor_f_on_response_received_t,
2189 ic_opaque: *mut c_void,
2190 ) -> rd_kafka_resp_err_t;
2191}
2192extern "C" {
2193 pub fn rd_kafka_interceptor_add_on_thread_start(
2194 rk: *mut rd_kafka_t,
2195 ic_name: *const c_char,
2196 on_thread_start: rd_kafka_interceptor_f_on_thread_start_t,
2197 ic_opaque: *mut c_void,
2198 ) -> rd_kafka_resp_err_t;
2199}
2200extern "C" {
2201 pub fn rd_kafka_interceptor_add_on_thread_exit(
2202 rk: *mut rd_kafka_t,
2203 ic_name: *const c_char,
2204 on_thread_exit: rd_kafka_interceptor_f_on_thread_exit_t,
2205 ic_opaque: *mut c_void,
2206 ) -> rd_kafka_resp_err_t;
2207}
2208extern "C" {
2209 pub fn rd_kafka_interceptor_add_on_broker_state_change(
2210 rk: *mut rd_kafka_t,
2211 ic_name: *const c_char,
2212 on_broker_state_change: rd_kafka_interceptor_f_on_broker_state_change_t,
2213 ic_opaque: *mut c_void,
2214 ) -> rd_kafka_resp_err_t;
2215}
2216extern "C" {
2217 pub fn rd_kafka_topic_result_error(
2218 topicres: *const rd_kafka_topic_result_t,
2219 ) -> rd_kafka_resp_err_t;
2220}
2221extern "C" {
2222 pub fn rd_kafka_topic_result_error_string(
2223 topicres: *const rd_kafka_topic_result_t,
2224 ) -> *const c_char;
2225}
2226extern "C" {
2227 pub fn rd_kafka_topic_result_name(topicres: *const rd_kafka_topic_result_t) -> *const c_char;
2228}
2229extern "C" {
2230 pub fn rd_kafka_group_result_error(
2231 groupres: *const rd_kafka_group_result_t,
2232 ) -> *const rd_kafka_error_t;
2233}
2234extern "C" {
2235 pub fn rd_kafka_group_result_name(groupres: *const rd_kafka_group_result_t) -> *const c_char;
2236}
2237extern "C" {
2238 pub fn rd_kafka_group_result_partitions(
2239 groupres: *const rd_kafka_group_result_t,
2240 ) -> *const rd_kafka_topic_partition_list_t;
2241}
2242#[repr(u32)]
2243#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2244pub enum rd_kafka_admin_op_t {
2245 RD_KAFKA_ADMIN_OP_ANY = 0,
2246 RD_KAFKA_ADMIN_OP_CREATETOPICS = 1,
2247 RD_KAFKA_ADMIN_OP_DELETETOPICS = 2,
2248 RD_KAFKA_ADMIN_OP_CREATEPARTITIONS = 3,
2249 RD_KAFKA_ADMIN_OP_ALTERCONFIGS = 4,
2250 RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS = 5,
2251 RD_KAFKA_ADMIN_OP_DELETERECORDS = 6,
2252 RD_KAFKA_ADMIN_OP_DELETEGROUPS = 7,
2253 RD_KAFKA_ADMIN_OP_DELETECONSUMERGROUPOFFSETS = 8,
2254 RD_KAFKA_ADMIN_OP_CREATEACLS = 9,
2255 RD_KAFKA_ADMIN_OP_DESCRIBEACLS = 10,
2256 RD_KAFKA_ADMIN_OP_DELETEACLS = 11,
2257 RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPS = 12,
2258 RD_KAFKA_ADMIN_OP_DESCRIBECONSUMERGROUPS = 13,
2259 RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPOFFSETS = 14,
2260 RD_KAFKA_ADMIN_OP_ALTERCONSUMERGROUPOFFSETS = 15,
2261 RD_KAFKA_ADMIN_OP_INCREMENTALALTERCONFIGS = 16,
2262 RD_KAFKA_ADMIN_OP_DESCRIBEUSERSCRAMCREDENTIALS = 17,
2263 RD_KAFKA_ADMIN_OP_ALTERUSERSCRAMCREDENTIALS = 18,
2264 RD_KAFKA_ADMIN_OP_DESCRIBETOPICS = 19,
2265 RD_KAFKA_ADMIN_OP_DESCRIBECLUSTER = 20,
2266 RD_KAFKA_ADMIN_OP_LISTOFFSETS = 21,
2267 RD_KAFKA_ADMIN_OP__CNT = 22,
2268}
2269#[repr(C)]
2270#[derive(Debug, Copy, Clone)]
2271pub struct rd_kafka_AdminOptions_s {
2272 _unused: [u8; 0],
2273}
2274pub type rd_kafka_AdminOptions_t = rd_kafka_AdminOptions_s;
2275#[repr(u32)]
2276#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2277pub enum rd_kafka_IsolationLevel_t {
2278 RD_KAFKA_ISOLATION_LEVEL_READ_UNCOMMITTED = 0,
2279 RD_KAFKA_ISOLATION_LEVEL_READ_COMMITTED = 1,
2280}
2281extern "C" {
2282 pub fn rd_kafka_AdminOptions_new(
2283 rk: *mut rd_kafka_t,
2284 for_api: rd_kafka_admin_op_t,
2285 ) -> *mut rd_kafka_AdminOptions_t;
2286}
2287extern "C" {
2288 pub fn rd_kafka_AdminOptions_destroy(options: *mut rd_kafka_AdminOptions_t);
2289}
2290extern "C" {
2291 pub fn rd_kafka_AdminOptions_set_request_timeout(
2292 options: *mut rd_kafka_AdminOptions_t,
2293 timeout_ms: c_int,
2294 errstr: *mut c_char,
2295 errstr_size: usize,
2296 ) -> rd_kafka_resp_err_t;
2297}
2298extern "C" {
2299 pub fn rd_kafka_AdminOptions_set_operation_timeout(
2300 options: *mut rd_kafka_AdminOptions_t,
2301 timeout_ms: c_int,
2302 errstr: *mut c_char,
2303 errstr_size: usize,
2304 ) -> rd_kafka_resp_err_t;
2305}
2306extern "C" {
2307 pub fn rd_kafka_AdminOptions_set_validate_only(
2308 options: *mut rd_kafka_AdminOptions_t,
2309 true_or_false: c_int,
2310 errstr: *mut c_char,
2311 errstr_size: usize,
2312 ) -> rd_kafka_resp_err_t;
2313}
2314extern "C" {
2315 pub fn rd_kafka_AdminOptions_set_broker(
2316 options: *mut rd_kafka_AdminOptions_t,
2317 broker_id: i32,
2318 errstr: *mut c_char,
2319 errstr_size: usize,
2320 ) -> rd_kafka_resp_err_t;
2321}
2322extern "C" {
2323 pub fn rd_kafka_AdminOptions_set_require_stable_offsets(
2324 options: *mut rd_kafka_AdminOptions_t,
2325 true_or_false: c_int,
2326 ) -> *mut rd_kafka_error_t;
2327}
2328extern "C" {
2329 pub fn rd_kafka_AdminOptions_set_include_authorized_operations(
2330 options: *mut rd_kafka_AdminOptions_t,
2331 true_or_false: c_int,
2332 ) -> *mut rd_kafka_error_t;
2333}
2334extern "C" {
2335 pub fn rd_kafka_AdminOptions_set_match_consumer_group_states(
2336 options: *mut rd_kafka_AdminOptions_t,
2337 consumer_group_states: *const rd_kafka_consumer_group_state_t,
2338 consumer_group_states_cnt: usize,
2339 ) -> *mut rd_kafka_error_t;
2340}
2341extern "C" {
2342 pub fn rd_kafka_AdminOptions_set_isolation_level(
2343 options: *mut rd_kafka_AdminOptions_t,
2344 value: rd_kafka_IsolationLevel_t,
2345 ) -> *mut rd_kafka_error_t;
2346}
2347extern "C" {
2348 pub fn rd_kafka_AdminOptions_set_opaque(
2349 options: *mut rd_kafka_AdminOptions_t,
2350 ev_opaque: *mut c_void,
2351 );
2352}
2353#[repr(u32)]
2354#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2355pub enum rd_kafka_AclOperation_t {
2356 RD_KAFKA_ACL_OPERATION_UNKNOWN = 0,
2357 RD_KAFKA_ACL_OPERATION_ANY = 1,
2358 RD_KAFKA_ACL_OPERATION_ALL = 2,
2359 RD_KAFKA_ACL_OPERATION_READ = 3,
2360 RD_KAFKA_ACL_OPERATION_WRITE = 4,
2361 RD_KAFKA_ACL_OPERATION_CREATE = 5,
2362 RD_KAFKA_ACL_OPERATION_DELETE = 6,
2363 RD_KAFKA_ACL_OPERATION_ALTER = 7,
2364 RD_KAFKA_ACL_OPERATION_DESCRIBE = 8,
2365 RD_KAFKA_ACL_OPERATION_CLUSTER_ACTION = 9,
2366 RD_KAFKA_ACL_OPERATION_DESCRIBE_CONFIGS = 10,
2367 RD_KAFKA_ACL_OPERATION_ALTER_CONFIGS = 11,
2368 RD_KAFKA_ACL_OPERATION_IDEMPOTENT_WRITE = 12,
2369 RD_KAFKA_ACL_OPERATION__CNT = 13,
2370}
2371#[repr(C)]
2372#[derive(Debug, Copy, Clone)]
2373pub struct rd_kafka_NewTopic_s {
2374 _unused: [u8; 0],
2375}
2376pub type rd_kafka_NewTopic_t = rd_kafka_NewTopic_s;
2377extern "C" {
2378 pub fn rd_kafka_NewTopic_new(
2379 topic: *const c_char,
2380 num_partitions: c_int,
2381 replication_factor: c_int,
2382 errstr: *mut c_char,
2383 errstr_size: usize,
2384 ) -> *mut rd_kafka_NewTopic_t;
2385}
2386extern "C" {
2387 pub fn rd_kafka_NewTopic_destroy(new_topic: *mut rd_kafka_NewTopic_t);
2388}
2389extern "C" {
2390 pub fn rd_kafka_NewTopic_destroy_array(
2391 new_topics: *mut *mut rd_kafka_NewTopic_t,
2392 new_topic_cnt: usize,
2393 );
2394}
2395extern "C" {
2396 pub fn rd_kafka_NewTopic_set_replica_assignment(
2397 new_topic: *mut rd_kafka_NewTopic_t,
2398 partition: i32,
2399 broker_ids: *mut i32,
2400 broker_id_cnt: usize,
2401 errstr: *mut c_char,
2402 errstr_size: usize,
2403 ) -> rd_kafka_resp_err_t;
2404}
2405extern "C" {
2406 pub fn rd_kafka_NewTopic_set_config(
2407 new_topic: *mut rd_kafka_NewTopic_t,
2408 name: *const c_char,
2409 value: *const c_char,
2410 ) -> rd_kafka_resp_err_t;
2411}
2412extern "C" {
2413 pub fn rd_kafka_CreateTopics(
2414 rk: *mut rd_kafka_t,
2415 new_topics: *mut *mut rd_kafka_NewTopic_t,
2416 new_topic_cnt: usize,
2417 options: *const rd_kafka_AdminOptions_t,
2418 rkqu: *mut rd_kafka_queue_t,
2419 );
2420}
2421extern "C" {
2422 pub fn rd_kafka_CreateTopics_result_topics(
2423 result: *const rd_kafka_CreateTopics_result_t,
2424 cntp: *mut usize,
2425 ) -> *mut *const rd_kafka_topic_result_t;
2426}
2427#[repr(C)]
2428#[derive(Debug, Copy, Clone)]
2429pub struct rd_kafka_DeleteTopic_s {
2430 _unused: [u8; 0],
2431}
2432pub type rd_kafka_DeleteTopic_t = rd_kafka_DeleteTopic_s;
2433extern "C" {
2434 pub fn rd_kafka_DeleteTopic_new(topic: *const c_char) -> *mut rd_kafka_DeleteTopic_t;
2435}
2436extern "C" {
2437 pub fn rd_kafka_DeleteTopic_destroy(del_topic: *mut rd_kafka_DeleteTopic_t);
2438}
2439extern "C" {
2440 pub fn rd_kafka_DeleteTopic_destroy_array(
2441 del_topics: *mut *mut rd_kafka_DeleteTopic_t,
2442 del_topic_cnt: usize,
2443 );
2444}
2445extern "C" {
2446 pub fn rd_kafka_DeleteTopics(
2447 rk: *mut rd_kafka_t,
2448 del_topics: *mut *mut rd_kafka_DeleteTopic_t,
2449 del_topic_cnt: usize,
2450 options: *const rd_kafka_AdminOptions_t,
2451 rkqu: *mut rd_kafka_queue_t,
2452 );
2453}
2454extern "C" {
2455 pub fn rd_kafka_DeleteTopics_result_topics(
2456 result: *const rd_kafka_DeleteTopics_result_t,
2457 cntp: *mut usize,
2458 ) -> *mut *const rd_kafka_topic_result_t;
2459}
2460#[repr(C)]
2461#[derive(Debug, Copy, Clone)]
2462pub struct rd_kafka_NewPartitions_s {
2463 _unused: [u8; 0],
2464}
2465pub type rd_kafka_NewPartitions_t = rd_kafka_NewPartitions_s;
2466extern "C" {
2467 pub fn rd_kafka_NewPartitions_new(
2468 topic: *const c_char,
2469 new_total_cnt: usize,
2470 errstr: *mut c_char,
2471 errstr_size: usize,
2472 ) -> *mut rd_kafka_NewPartitions_t;
2473}
2474extern "C" {
2475 pub fn rd_kafka_NewPartitions_destroy(new_parts: *mut rd_kafka_NewPartitions_t);
2476}
2477extern "C" {
2478 pub fn rd_kafka_NewPartitions_destroy_array(
2479 new_parts: *mut *mut rd_kafka_NewPartitions_t,
2480 new_parts_cnt: usize,
2481 );
2482}
2483extern "C" {
2484 pub fn rd_kafka_NewPartitions_set_replica_assignment(
2485 new_parts: *mut rd_kafka_NewPartitions_t,
2486 new_partition_idx: i32,
2487 broker_ids: *mut i32,
2488 broker_id_cnt: usize,
2489 errstr: *mut c_char,
2490 errstr_size: usize,
2491 ) -> rd_kafka_resp_err_t;
2492}
2493extern "C" {
2494 pub fn rd_kafka_CreatePartitions(
2495 rk: *mut rd_kafka_t,
2496 new_parts: *mut *mut rd_kafka_NewPartitions_t,
2497 new_parts_cnt: usize,
2498 options: *const rd_kafka_AdminOptions_t,
2499 rkqu: *mut rd_kafka_queue_t,
2500 );
2501}
2502extern "C" {
2503 pub fn rd_kafka_CreatePartitions_result_topics(
2504 result: *const rd_kafka_CreatePartitions_result_t,
2505 cntp: *mut usize,
2506 ) -> *mut *const rd_kafka_topic_result_t;
2507}
2508#[repr(u32)]
2509#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2510pub enum rd_kafka_ConfigSource_t {
2511 RD_KAFKA_CONFIG_SOURCE_UNKNOWN_CONFIG = 0,
2512 RD_KAFKA_CONFIG_SOURCE_DYNAMIC_TOPIC_CONFIG = 1,
2513 RD_KAFKA_CONFIG_SOURCE_DYNAMIC_BROKER_CONFIG = 2,
2514 RD_KAFKA_CONFIG_SOURCE_DYNAMIC_DEFAULT_BROKER_CONFIG = 3,
2515 RD_KAFKA_CONFIG_SOURCE_STATIC_BROKER_CONFIG = 4,
2516 RD_KAFKA_CONFIG_SOURCE_DEFAULT_CONFIG = 5,
2517 RD_KAFKA_CONFIG_SOURCE__CNT = 6,
2518}
2519extern "C" {
2520 pub fn rd_kafka_ConfigSource_name(confsource: rd_kafka_ConfigSource_t) -> *const c_char;
2521}
2522#[repr(C)]
2523#[derive(Debug, Copy, Clone)]
2524pub struct rd_kafka_ConfigEntry_s {
2525 _unused: [u8; 0],
2526}
2527pub type rd_kafka_ConfigEntry_t = rd_kafka_ConfigEntry_s;
2528extern "C" {
2529 pub fn rd_kafka_ConfigEntry_name(entry: *const rd_kafka_ConfigEntry_t) -> *const c_char;
2530}
2531extern "C" {
2532 pub fn rd_kafka_ConfigEntry_value(entry: *const rd_kafka_ConfigEntry_t) -> *const c_char;
2533}
2534extern "C" {
2535 pub fn rd_kafka_ConfigEntry_source(
2536 entry: *const rd_kafka_ConfigEntry_t,
2537 ) -> rd_kafka_ConfigSource_t;
2538}
2539extern "C" {
2540 pub fn rd_kafka_ConfigEntry_is_read_only(entry: *const rd_kafka_ConfigEntry_t) -> c_int;
2541}
2542extern "C" {
2543 pub fn rd_kafka_ConfigEntry_is_default(entry: *const rd_kafka_ConfigEntry_t) -> c_int;
2544}
2545extern "C" {
2546 pub fn rd_kafka_ConfigEntry_is_sensitive(entry: *const rd_kafka_ConfigEntry_t) -> c_int;
2547}
2548extern "C" {
2549 pub fn rd_kafka_ConfigEntry_is_synonym(entry: *const rd_kafka_ConfigEntry_t) -> c_int;
2550}
2551extern "C" {
2552 pub fn rd_kafka_ConfigEntry_synonyms(
2553 entry: *const rd_kafka_ConfigEntry_t,
2554 cntp: *mut usize,
2555 ) -> *mut *const rd_kafka_ConfigEntry_t;
2556}
2557#[repr(u32)]
2558#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2559pub enum rd_kafka_ResourceType_t {
2560 RD_KAFKA_RESOURCE_UNKNOWN = 0,
2561 RD_KAFKA_RESOURCE_ANY = 1,
2562 RD_KAFKA_RESOURCE_TOPIC = 2,
2563 RD_KAFKA_RESOURCE_GROUP = 3,
2564 RD_KAFKA_RESOURCE_BROKER = 4,
2565 RD_KAFKA_RESOURCE__CNT = 5,
2566}
2567#[repr(u32)]
2568#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2569pub enum rd_kafka_ResourcePatternType_t {
2570 RD_KAFKA_RESOURCE_PATTERN_UNKNOWN = 0,
2571 RD_KAFKA_RESOURCE_PATTERN_ANY = 1,
2572 RD_KAFKA_RESOURCE_PATTERN_MATCH = 2,
2573 RD_KAFKA_RESOURCE_PATTERN_LITERAL = 3,
2574 RD_KAFKA_RESOURCE_PATTERN_PREFIXED = 4,
2575 RD_KAFKA_RESOURCE_PATTERN_TYPE__CNT = 5,
2576}
2577#[repr(u32)]
2578#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2579pub enum rd_kafka_AlterConfigOpType_t {
2580 RD_KAFKA_ALTER_CONFIG_OP_TYPE_SET = 0,
2581 RD_KAFKA_ALTER_CONFIG_OP_TYPE_DELETE = 1,
2582 RD_KAFKA_ALTER_CONFIG_OP_TYPE_APPEND = 2,
2583 RD_KAFKA_ALTER_CONFIG_OP_TYPE_SUBTRACT = 3,
2584 RD_KAFKA_ALTER_CONFIG_OP_TYPE__CNT = 4,
2585}
2586extern "C" {
2587 pub fn rd_kafka_ResourcePatternType_name(
2588 resource_pattern_type: rd_kafka_ResourcePatternType_t,
2589 ) -> *const c_char;
2590}
2591extern "C" {
2592 pub fn rd_kafka_ResourceType_name(restype: rd_kafka_ResourceType_t) -> *const c_char;
2593}
2594#[repr(C)]
2595#[derive(Debug, Copy, Clone)]
2596pub struct rd_kafka_ConfigResource_s {
2597 _unused: [u8; 0],
2598}
2599pub type rd_kafka_ConfigResource_t = rd_kafka_ConfigResource_s;
2600extern "C" {
2601 pub fn rd_kafka_ConfigResource_new(
2602 restype: rd_kafka_ResourceType_t,
2603 resname: *const c_char,
2604 ) -> *mut rd_kafka_ConfigResource_t;
2605}
2606extern "C" {
2607 pub fn rd_kafka_ConfigResource_destroy(config: *mut rd_kafka_ConfigResource_t);
2608}
2609extern "C" {
2610 pub fn rd_kafka_ConfigResource_destroy_array(
2611 config: *mut *mut rd_kafka_ConfigResource_t,
2612 config_cnt: usize,
2613 );
2614}
2615extern "C" {
2616 pub fn rd_kafka_ConfigResource_set_config(
2617 config: *mut rd_kafka_ConfigResource_t,
2618 name: *const c_char,
2619 value: *const c_char,
2620 ) -> rd_kafka_resp_err_t;
2621}
2622extern "C" {
2623 pub fn rd_kafka_ConfigResource_add_incremental_config(
2624 config: *mut rd_kafka_ConfigResource_t,
2625 name: *const c_char,
2626 op_type: rd_kafka_AlterConfigOpType_t,
2627 value: *const c_char,
2628 ) -> *mut rd_kafka_error_t;
2629}
2630extern "C" {
2631 pub fn rd_kafka_ConfigResource_configs(
2632 config: *const rd_kafka_ConfigResource_t,
2633 cntp: *mut usize,
2634 ) -> *mut *const rd_kafka_ConfigEntry_t;
2635}
2636extern "C" {
2637 pub fn rd_kafka_ConfigResource_type(
2638 config: *const rd_kafka_ConfigResource_t,
2639 ) -> rd_kafka_ResourceType_t;
2640}
2641extern "C" {
2642 pub fn rd_kafka_ConfigResource_name(config: *const rd_kafka_ConfigResource_t) -> *const c_char;
2643}
2644extern "C" {
2645 pub fn rd_kafka_ConfigResource_error(
2646 config: *const rd_kafka_ConfigResource_t,
2647 ) -> rd_kafka_resp_err_t;
2648}
2649extern "C" {
2650 pub fn rd_kafka_ConfigResource_error_string(
2651 config: *const rd_kafka_ConfigResource_t,
2652 ) -> *const c_char;
2653}
2654extern "C" {
2655 pub fn rd_kafka_AlterConfigs(
2656 rk: *mut rd_kafka_t,
2657 configs: *mut *mut rd_kafka_ConfigResource_t,
2658 config_cnt: usize,
2659 options: *const rd_kafka_AdminOptions_t,
2660 rkqu: *mut rd_kafka_queue_t,
2661 );
2662}
2663extern "C" {
2664 pub fn rd_kafka_AlterConfigs_result_resources(
2665 result: *const rd_kafka_AlterConfigs_result_t,
2666 cntp: *mut usize,
2667 ) -> *mut *const rd_kafka_ConfigResource_t;
2668}
2669extern "C" {
2670 pub fn rd_kafka_IncrementalAlterConfigs(
2671 rk: *mut rd_kafka_t,
2672 configs: *mut *mut rd_kafka_ConfigResource_t,
2673 config_cnt: usize,
2674 options: *const rd_kafka_AdminOptions_t,
2675 rkqu: *mut rd_kafka_queue_t,
2676 );
2677}
2678extern "C" {
2679 pub fn rd_kafka_IncrementalAlterConfigs_result_resources(
2680 result: *const rd_kafka_IncrementalAlterConfigs_result_t,
2681 cntp: *mut usize,
2682 ) -> *mut *const rd_kafka_ConfigResource_t;
2683}
2684extern "C" {
2685 pub fn rd_kafka_DescribeConfigs(
2686 rk: *mut rd_kafka_t,
2687 configs: *mut *mut rd_kafka_ConfigResource_t,
2688 config_cnt: usize,
2689 options: *const rd_kafka_AdminOptions_t,
2690 rkqu: *mut rd_kafka_queue_t,
2691 );
2692}
2693extern "C" {
2694 pub fn rd_kafka_DescribeConfigs_result_resources(
2695 result: *const rd_kafka_DescribeConfigs_result_t,
2696 cntp: *mut usize,
2697 ) -> *mut *const rd_kafka_ConfigResource_t;
2698}
2699#[repr(C)]
2700#[derive(Debug, Copy, Clone)]
2701pub struct rd_kafka_DeleteRecords_s {
2702 _unused: [u8; 0],
2703}
2704pub type rd_kafka_DeleteRecords_t = rd_kafka_DeleteRecords_s;
2705extern "C" {
2706 pub fn rd_kafka_DeleteRecords_new(
2707 before_offsets: *const rd_kafka_topic_partition_list_t,
2708 ) -> *mut rd_kafka_DeleteRecords_t;
2709}
2710extern "C" {
2711 pub fn rd_kafka_DeleteRecords_destroy(del_records: *mut rd_kafka_DeleteRecords_t);
2712}
2713extern "C" {
2714 pub fn rd_kafka_DeleteRecords_destroy_array(
2715 del_records: *mut *mut rd_kafka_DeleteRecords_t,
2716 del_record_cnt: usize,
2717 );
2718}
2719extern "C" {
2720 pub fn rd_kafka_DeleteRecords(
2721 rk: *mut rd_kafka_t,
2722 del_records: *mut *mut rd_kafka_DeleteRecords_t,
2723 del_record_cnt: usize,
2724 options: *const rd_kafka_AdminOptions_t,
2725 rkqu: *mut rd_kafka_queue_t,
2726 );
2727}
2728extern "C" {
2729 pub fn rd_kafka_DeleteRecords_result_offsets(
2730 result: *const rd_kafka_DeleteRecords_result_t,
2731 ) -> *const rd_kafka_topic_partition_list_t;
2732}
2733#[repr(C)]
2734#[derive(Debug, Copy, Clone)]
2735pub struct rd_kafka_TopicCollection_s {
2736 _unused: [u8; 0],
2737}
2738pub type rd_kafka_TopicCollection_t = rd_kafka_TopicCollection_s;
2739#[repr(C)]
2740#[derive(Debug, Copy, Clone)]
2741pub struct rd_kafka_TopicPartitionInfo_s {
2742 _unused: [u8; 0],
2743}
2744pub type rd_kafka_TopicPartitionInfo_t = rd_kafka_TopicPartitionInfo_s;
2745#[repr(C)]
2746#[derive(Debug, Copy, Clone)]
2747pub struct rd_kafka_TopicDescription_s {
2748 _unused: [u8; 0],
2749}
2750pub type rd_kafka_TopicDescription_t = rd_kafka_TopicDescription_s;
2751extern "C" {
2752 pub fn rd_kafka_TopicCollection_of_topic_names(
2753 topics: *mut *const c_char,
2754 topics_cnt: usize,
2755 ) -> *mut rd_kafka_TopicCollection_t;
2756}
2757extern "C" {
2758 pub fn rd_kafka_TopicCollection_destroy(topics: *mut rd_kafka_TopicCollection_t);
2759}
2760extern "C" {
2761 pub fn rd_kafka_DescribeTopics(
2762 rk: *mut rd_kafka_t,
2763 topics: *const rd_kafka_TopicCollection_t,
2764 options: *const rd_kafka_AdminOptions_t,
2765 rkqu: *mut rd_kafka_queue_t,
2766 );
2767}
2768extern "C" {
2769 pub fn rd_kafka_DescribeTopics_result_topics(
2770 result: *const rd_kafka_DescribeTopics_result_t,
2771 cntp: *mut usize,
2772 ) -> *mut *const rd_kafka_TopicDescription_t;
2773}
2774extern "C" {
2775 pub fn rd_kafka_TopicDescription_partitions(
2776 topicdesc: *const rd_kafka_TopicDescription_t,
2777 cntp: *mut usize,
2778 ) -> *mut *const rd_kafka_TopicPartitionInfo_t;
2779}
2780extern "C" {
2781 pub fn rd_kafka_TopicPartitionInfo_partition(
2782 partition: *const rd_kafka_TopicPartitionInfo_t,
2783 ) -> c_int;
2784}
2785extern "C" {
2786 pub fn rd_kafka_TopicPartitionInfo_leader(
2787 partition: *const rd_kafka_TopicPartitionInfo_t,
2788 ) -> *const rd_kafka_Node_t;
2789}
2790extern "C" {
2791 pub fn rd_kafka_TopicPartitionInfo_isr(
2792 partition: *const rd_kafka_TopicPartitionInfo_t,
2793 cntp: *mut usize,
2794 ) -> *mut *const rd_kafka_Node_t;
2795}
2796extern "C" {
2797 pub fn rd_kafka_TopicPartitionInfo_replicas(
2798 partition: *const rd_kafka_TopicPartitionInfo_t,
2799 cntp: *mut usize,
2800 ) -> *mut *const rd_kafka_Node_t;
2801}
2802extern "C" {
2803 pub fn rd_kafka_TopicDescription_authorized_operations(
2804 topicdesc: *const rd_kafka_TopicDescription_t,
2805 cntp: *mut usize,
2806 ) -> *const rd_kafka_AclOperation_t;
2807}
2808extern "C" {
2809 pub fn rd_kafka_TopicDescription_name(
2810 topicdesc: *const rd_kafka_TopicDescription_t,
2811 ) -> *const c_char;
2812}
2813extern "C" {
2814 pub fn rd_kafka_TopicDescription_topic_id(
2815 topicdesc: *const rd_kafka_TopicDescription_t,
2816 ) -> *const rd_kafka_Uuid_t;
2817}
2818extern "C" {
2819 pub fn rd_kafka_TopicDescription_is_internal(
2820 topicdesc: *const rd_kafka_TopicDescription_t,
2821 ) -> c_int;
2822}
2823extern "C" {
2824 pub fn rd_kafka_TopicDescription_error(
2825 topicdesc: *const rd_kafka_TopicDescription_t,
2826 ) -> *const rd_kafka_error_t;
2827}
2828extern "C" {
2829 pub fn rd_kafka_DescribeCluster(
2830 rk: *mut rd_kafka_t,
2831 options: *const rd_kafka_AdminOptions_t,
2832 rkqu: *mut rd_kafka_queue_t,
2833 );
2834}
2835extern "C" {
2836 pub fn rd_kafka_DescribeCluster_result_nodes(
2837 result: *const rd_kafka_DescribeCluster_result_t,
2838 cntp: *mut usize,
2839 ) -> *mut *const rd_kafka_Node_t;
2840}
2841extern "C" {
2842 pub fn rd_kafka_DescribeCluster_result_authorized_operations(
2843 result: *const rd_kafka_DescribeCluster_result_t,
2844 cntp: *mut usize,
2845 ) -> *const rd_kafka_AclOperation_t;
2846}
2847extern "C" {
2848 pub fn rd_kafka_DescribeCluster_result_controller(
2849 result: *const rd_kafka_DescribeCluster_result_t,
2850 ) -> *const rd_kafka_Node_t;
2851}
2852extern "C" {
2853 pub fn rd_kafka_DescribeCluster_result_cluster_id(
2854 result: *const rd_kafka_DescribeCluster_result_t,
2855 ) -> *const c_char;
2856}
2857#[repr(C)]
2858#[derive(Debug, Copy, Clone)]
2859pub struct rd_kafka_ConsumerGroupListing_s {
2860 _unused: [u8; 0],
2861}
2862pub type rd_kafka_ConsumerGroupListing_t = rd_kafka_ConsumerGroupListing_s;
2863#[repr(C)]
2864#[derive(Debug, Copy, Clone)]
2865pub struct rd_kafka_ListConsumerGroupsResult_s {
2866 _unused: [u8; 0],
2867}
2868pub type rd_kafka_ListConsumerGroupsResult_t = rd_kafka_ListConsumerGroupsResult_s;
2869extern "C" {
2870 pub fn rd_kafka_ListConsumerGroups(
2871 rk: *mut rd_kafka_t,
2872 options: *const rd_kafka_AdminOptions_t,
2873 rkqu: *mut rd_kafka_queue_t,
2874 );
2875}
2876extern "C" {
2877 pub fn rd_kafka_ConsumerGroupListing_group_id(
2878 grplist: *const rd_kafka_ConsumerGroupListing_t,
2879 ) -> *const c_char;
2880}
2881extern "C" {
2882 pub fn rd_kafka_ConsumerGroupListing_is_simple_consumer_group(
2883 grplist: *const rd_kafka_ConsumerGroupListing_t,
2884 ) -> c_int;
2885}
2886extern "C" {
2887 pub fn rd_kafka_ConsumerGroupListing_state(
2888 grplist: *const rd_kafka_ConsumerGroupListing_t,
2889 ) -> rd_kafka_consumer_group_state_t;
2890}
2891extern "C" {
2892 pub fn rd_kafka_ListConsumerGroups_result_valid(
2893 result: *const rd_kafka_ListConsumerGroups_result_t,
2894 cntp: *mut usize,
2895 ) -> *mut *const rd_kafka_ConsumerGroupListing_t;
2896}
2897extern "C" {
2898 pub fn rd_kafka_ListConsumerGroups_result_errors(
2899 result: *const rd_kafka_ListConsumerGroups_result_t,
2900 cntp: *mut usize,
2901 ) -> *mut *const rd_kafka_error_t;
2902}
2903#[repr(C)]
2904#[derive(Debug, Copy, Clone)]
2905pub struct rd_kafka_ConsumerGroupDescription_s {
2906 _unused: [u8; 0],
2907}
2908pub type rd_kafka_ConsumerGroupDescription_t = rd_kafka_ConsumerGroupDescription_s;
2909#[repr(C)]
2910#[derive(Debug, Copy, Clone)]
2911pub struct rd_kafka_MemberDescription_s {
2912 _unused: [u8; 0],
2913}
2914pub type rd_kafka_MemberDescription_t = rd_kafka_MemberDescription_s;
2915#[repr(C)]
2916#[derive(Debug, Copy, Clone)]
2917pub struct rd_kafka_MemberAssignment_s {
2918 _unused: [u8; 0],
2919}
2920pub type rd_kafka_MemberAssignment_t = rd_kafka_MemberAssignment_s;
2921extern "C" {
2922 pub fn rd_kafka_DescribeConsumerGroups(
2923 rk: *mut rd_kafka_t,
2924 groups: *mut *const c_char,
2925 groups_cnt: usize,
2926 options: *const rd_kafka_AdminOptions_t,
2927 rkqu: *mut rd_kafka_queue_t,
2928 );
2929}
2930extern "C" {
2931 pub fn rd_kafka_DescribeConsumerGroups_result_groups(
2932 result: *const rd_kafka_DescribeConsumerGroups_result_t,
2933 cntp: *mut usize,
2934 ) -> *mut *const rd_kafka_ConsumerGroupDescription_t;
2935}
2936extern "C" {
2937 pub fn rd_kafka_ConsumerGroupDescription_group_id(
2938 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2939 ) -> *const c_char;
2940}
2941extern "C" {
2942 pub fn rd_kafka_ConsumerGroupDescription_error(
2943 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2944 ) -> *const rd_kafka_error_t;
2945}
2946extern "C" {
2947 pub fn rd_kafka_ConsumerGroupDescription_is_simple_consumer_group(
2948 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2949 ) -> c_int;
2950}
2951extern "C" {
2952 pub fn rd_kafka_ConsumerGroupDescription_partition_assignor(
2953 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2954 ) -> *const c_char;
2955}
2956extern "C" {
2957 pub fn rd_kafka_ConsumerGroupDescription_authorized_operations(
2958 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2959 cntp: *mut usize,
2960 ) -> *const rd_kafka_AclOperation_t;
2961}
2962extern "C" {
2963 pub fn rd_kafka_ConsumerGroupDescription_state(
2964 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2965 ) -> rd_kafka_consumer_group_state_t;
2966}
2967extern "C" {
2968 pub fn rd_kafka_ConsumerGroupDescription_coordinator(
2969 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2970 ) -> *const rd_kafka_Node_t;
2971}
2972extern "C" {
2973 pub fn rd_kafka_ConsumerGroupDescription_member_count(
2974 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2975 ) -> usize;
2976}
2977extern "C" {
2978 pub fn rd_kafka_ConsumerGroupDescription_member(
2979 grpdesc: *const rd_kafka_ConsumerGroupDescription_t,
2980 idx: usize,
2981 ) -> *const rd_kafka_MemberDescription_t;
2982}
2983extern "C" {
2984 pub fn rd_kafka_MemberDescription_client_id(
2985 member: *const rd_kafka_MemberDescription_t,
2986 ) -> *const c_char;
2987}
2988extern "C" {
2989 pub fn rd_kafka_MemberDescription_group_instance_id(
2990 member: *const rd_kafka_MemberDescription_t,
2991 ) -> *const c_char;
2992}
2993extern "C" {
2994 pub fn rd_kafka_MemberDescription_consumer_id(
2995 member: *const rd_kafka_MemberDescription_t,
2996 ) -> *const c_char;
2997}
2998extern "C" {
2999 pub fn rd_kafka_MemberDescription_host(
3000 member: *const rd_kafka_MemberDescription_t,
3001 ) -> *const c_char;
3002}
3003extern "C" {
3004 pub fn rd_kafka_MemberDescription_assignment(
3005 member: *const rd_kafka_MemberDescription_t,
3006 ) -> *const rd_kafka_MemberAssignment_t;
3007}
3008extern "C" {
3009 pub fn rd_kafka_MemberAssignment_partitions(
3010 assignment: *const rd_kafka_MemberAssignment_t,
3011 ) -> *const rd_kafka_topic_partition_list_t;
3012}
3013#[repr(C)]
3014#[derive(Debug, Copy, Clone)]
3015pub struct rd_kafka_DeleteGroup_s {
3016 _unused: [u8; 0],
3017}
3018pub type rd_kafka_DeleteGroup_t = rd_kafka_DeleteGroup_s;
3019extern "C" {
3020 pub fn rd_kafka_DeleteGroup_new(group: *const c_char) -> *mut rd_kafka_DeleteGroup_t;
3021}
3022extern "C" {
3023 pub fn rd_kafka_DeleteGroup_destroy(del_group: *mut rd_kafka_DeleteGroup_t);
3024}
3025extern "C" {
3026 pub fn rd_kafka_DeleteGroup_destroy_array(
3027 del_groups: *mut *mut rd_kafka_DeleteGroup_t,
3028 del_group_cnt: usize,
3029 );
3030}
3031extern "C" {
3032 pub fn rd_kafka_DeleteGroups(
3033 rk: *mut rd_kafka_t,
3034 del_groups: *mut *mut rd_kafka_DeleteGroup_t,
3035 del_group_cnt: usize,
3036 options: *const rd_kafka_AdminOptions_t,
3037 rkqu: *mut rd_kafka_queue_t,
3038 );
3039}
3040extern "C" {
3041 pub fn rd_kafka_DeleteGroups_result_groups(
3042 result: *const rd_kafka_DeleteGroups_result_t,
3043 cntp: *mut usize,
3044 ) -> *mut *const rd_kafka_group_result_t;
3045}
3046#[repr(C)]
3047#[derive(Debug, Copy, Clone)]
3048pub struct rd_kafka_ListConsumerGroupOffsets_s {
3049 _unused: [u8; 0],
3050}
3051pub type rd_kafka_ListConsumerGroupOffsets_t = rd_kafka_ListConsumerGroupOffsets_s;
3052extern "C" {
3053 pub fn rd_kafka_ListConsumerGroupOffsets_new(
3054 group_id: *const c_char,
3055 partitions: *const rd_kafka_topic_partition_list_t,
3056 ) -> *mut rd_kafka_ListConsumerGroupOffsets_t;
3057}
3058extern "C" {
3059 pub fn rd_kafka_ListConsumerGroupOffsets_destroy(
3060 list_grpoffsets: *mut rd_kafka_ListConsumerGroupOffsets_t,
3061 );
3062}
3063extern "C" {
3064 pub fn rd_kafka_ListConsumerGroupOffsets_destroy_array(
3065 list_grpoffsets: *mut *mut rd_kafka_ListConsumerGroupOffsets_t,
3066 list_grpoffset_cnt: usize,
3067 );
3068}
3069extern "C" {
3070 pub fn rd_kafka_ListConsumerGroupOffsets(
3071 rk: *mut rd_kafka_t,
3072 list_grpoffsets: *mut *mut rd_kafka_ListConsumerGroupOffsets_t,
3073 list_grpoffsets_cnt: usize,
3074 options: *const rd_kafka_AdminOptions_t,
3075 rkqu: *mut rd_kafka_queue_t,
3076 );
3077}
3078extern "C" {
3079 pub fn rd_kafka_ListConsumerGroupOffsets_result_groups(
3080 result: *const rd_kafka_ListConsumerGroupOffsets_result_t,
3081 cntp: *mut usize,
3082 ) -> *mut *const rd_kafka_group_result_t;
3083}
3084#[repr(C)]
3085#[derive(Debug, Copy, Clone)]
3086pub struct rd_kafka_AlterConsumerGroupOffsets_s {
3087 _unused: [u8; 0],
3088}
3089pub type rd_kafka_AlterConsumerGroupOffsets_t = rd_kafka_AlterConsumerGroupOffsets_s;
3090extern "C" {
3091 pub fn rd_kafka_AlterConsumerGroupOffsets_new(
3092 group_id: *const c_char,
3093 partitions: *const rd_kafka_topic_partition_list_t,
3094 ) -> *mut rd_kafka_AlterConsumerGroupOffsets_t;
3095}
3096extern "C" {
3097 pub fn rd_kafka_AlterConsumerGroupOffsets_destroy(
3098 alter_grpoffsets: *mut rd_kafka_AlterConsumerGroupOffsets_t,
3099 );
3100}
3101extern "C" {
3102 pub fn rd_kafka_AlterConsumerGroupOffsets_destroy_array(
3103 alter_grpoffsets: *mut *mut rd_kafka_AlterConsumerGroupOffsets_t,
3104 alter_grpoffset_cnt: usize,
3105 );
3106}
3107extern "C" {
3108 pub fn rd_kafka_AlterConsumerGroupOffsets(
3109 rk: *mut rd_kafka_t,
3110 alter_grpoffsets: *mut *mut rd_kafka_AlterConsumerGroupOffsets_t,
3111 alter_grpoffsets_cnt: usize,
3112 options: *const rd_kafka_AdminOptions_t,
3113 rkqu: *mut rd_kafka_queue_t,
3114 );
3115}
3116extern "C" {
3117 pub fn rd_kafka_AlterConsumerGroupOffsets_result_groups(
3118 result: *const rd_kafka_AlterConsumerGroupOffsets_result_t,
3119 cntp: *mut usize,
3120 ) -> *mut *const rd_kafka_group_result_t;
3121}
3122#[repr(C)]
3123#[derive(Debug, Copy, Clone)]
3124pub struct rd_kafka_DeleteConsumerGroupOffsets_s {
3125 _unused: [u8; 0],
3126}
3127pub type rd_kafka_DeleteConsumerGroupOffsets_t = rd_kafka_DeleteConsumerGroupOffsets_s;
3128extern "C" {
3129 pub fn rd_kafka_DeleteConsumerGroupOffsets_new(
3130 group: *const c_char,
3131 partitions: *const rd_kafka_topic_partition_list_t,
3132 ) -> *mut rd_kafka_DeleteConsumerGroupOffsets_t;
3133}
3134extern "C" {
3135 pub fn rd_kafka_DeleteConsumerGroupOffsets_destroy(
3136 del_grpoffsets: *mut rd_kafka_DeleteConsumerGroupOffsets_t,
3137 );
3138}
3139extern "C" {
3140 pub fn rd_kafka_DeleteConsumerGroupOffsets_destroy_array(
3141 del_grpoffsets: *mut *mut rd_kafka_DeleteConsumerGroupOffsets_t,
3142 del_grpoffset_cnt: usize,
3143 );
3144}
3145extern "C" {
3146 pub fn rd_kafka_DeleteConsumerGroupOffsets(
3147 rk: *mut rd_kafka_t,
3148 del_grpoffsets: *mut *mut rd_kafka_DeleteConsumerGroupOffsets_t,
3149 del_grpoffsets_cnt: usize,
3150 options: *const rd_kafka_AdminOptions_t,
3151 rkqu: *mut rd_kafka_queue_t,
3152 );
3153}
3154extern "C" {
3155 pub fn rd_kafka_DeleteConsumerGroupOffsets_result_groups(
3156 result: *const rd_kafka_DeleteConsumerGroupOffsets_result_t,
3157 cntp: *mut usize,
3158 ) -> *mut *const rd_kafka_group_result_t;
3159}
3160#[repr(i32)]
3161#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3162pub enum rd_kafka_OffsetSpec_t {
3163 RD_KAFKA_OFFSET_SPEC_MAX_TIMESTAMP = -3,
3164 RD_KAFKA_OFFSET_SPEC_EARLIEST = -2,
3165 RD_KAFKA_OFFSET_SPEC_LATEST = -1,
3166}
3167#[repr(C)]
3168#[derive(Debug, Copy, Clone)]
3169pub struct rd_kafka_ListOffsetsResultInfo_s {
3170 _unused: [u8; 0],
3171}
3172pub type rd_kafka_ListOffsetsResultInfo_t = rd_kafka_ListOffsetsResultInfo_s;
3173extern "C" {
3174 pub fn rd_kafka_ListOffsetsResultInfo_topic_partition(
3175 result_info: *const rd_kafka_ListOffsetsResultInfo_t,
3176 ) -> *const rd_kafka_topic_partition_t;
3177}
3178extern "C" {
3179 pub fn rd_kafka_ListOffsetsResultInfo_timestamp(
3180 result_info: *const rd_kafka_ListOffsetsResultInfo_t,
3181 ) -> i64;
3182}
3183extern "C" {
3184 pub fn rd_kafka_ListOffsets_result_infos(
3185 result: *const rd_kafka_ListOffsets_result_t,
3186 cntp: *mut usize,
3187 ) -> *mut *const rd_kafka_ListOffsetsResultInfo_t;
3188}
3189extern "C" {
3190 pub fn rd_kafka_ListOffsets(
3191 rk: *mut rd_kafka_t,
3192 topic_partitions: *mut rd_kafka_topic_partition_list_t,
3193 options: *const rd_kafka_AdminOptions_t,
3194 rkqu: *mut rd_kafka_queue_t,
3195 );
3196}
3197#[repr(u32)]
3198#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3199pub enum rd_kafka_ScramMechanism_t {
3200 RD_KAFKA_SCRAM_MECHANISM_UNKNOWN = 0,
3201 RD_KAFKA_SCRAM_MECHANISM_SHA_256 = 1,
3202 RD_KAFKA_SCRAM_MECHANISM_SHA_512 = 2,
3203 RD_KAFKA_SCRAM_MECHANISM__CNT = 3,
3204}
3205#[repr(C)]
3206#[derive(Debug, Copy, Clone)]
3207pub struct rd_kafka_ScramCredentialInfo_s {
3208 _unused: [u8; 0],
3209}
3210pub type rd_kafka_ScramCredentialInfo_t = rd_kafka_ScramCredentialInfo_s;
3211extern "C" {
3212 pub fn rd_kafka_ScramCredentialInfo_mechanism(
3213 scram_credential_info: *const rd_kafka_ScramCredentialInfo_t,
3214 ) -> rd_kafka_ScramMechanism_t;
3215}
3216extern "C" {
3217 pub fn rd_kafka_ScramCredentialInfo_iterations(
3218 scram_credential_info: *const rd_kafka_ScramCredentialInfo_t,
3219 ) -> i32;
3220}
3221#[repr(C)]
3222#[derive(Debug, Copy, Clone)]
3223pub struct rd_kafka_UserScramCredentialsDescription_s {
3224 _unused: [u8; 0],
3225}
3226pub type rd_kafka_UserScramCredentialsDescription_t = rd_kafka_UserScramCredentialsDescription_s;
3227extern "C" {
3228 pub fn rd_kafka_UserScramCredentialsDescription_user(
3229 description: *const rd_kafka_UserScramCredentialsDescription_t,
3230 ) -> *const c_char;
3231}
3232extern "C" {
3233 pub fn rd_kafka_UserScramCredentialsDescription_error(
3234 description: *const rd_kafka_UserScramCredentialsDescription_t,
3235 ) -> *const rd_kafka_error_t;
3236}
3237extern "C" {
3238 pub fn rd_kafka_UserScramCredentialsDescription_scramcredentialinfo_count(
3239 description: *const rd_kafka_UserScramCredentialsDescription_t,
3240 ) -> usize;
3241}
3242extern "C" {
3243 pub fn rd_kafka_UserScramCredentialsDescription_scramcredentialinfo(
3244 description: *const rd_kafka_UserScramCredentialsDescription_t,
3245 idx: usize,
3246 ) -> *const rd_kafka_ScramCredentialInfo_t;
3247}
3248extern "C" {
3249 pub fn rd_kafka_DescribeUserScramCredentials_result_descriptions(
3250 result: *const rd_kafka_DescribeUserScramCredentials_result_t,
3251 cntp: *mut usize,
3252 ) -> *mut *const rd_kafka_UserScramCredentialsDescription_t;
3253}
3254extern "C" {
3255 pub fn rd_kafka_DescribeUserScramCredentials(
3256 rk: *mut rd_kafka_t,
3257 users: *mut *const c_char,
3258 user_cnt: usize,
3259 options: *const rd_kafka_AdminOptions_t,
3260 rkqu: *mut rd_kafka_queue_t,
3261 );
3262}
3263#[repr(C)]
3264#[derive(Debug, Copy, Clone)]
3265pub struct rd_kafka_UserScramCredentialAlteration_s {
3266 _unused: [u8; 0],
3267}
3268pub type rd_kafka_UserScramCredentialAlteration_t = rd_kafka_UserScramCredentialAlteration_s;
3269extern "C" {
3270 pub fn rd_kafka_UserScramCredentialUpsertion_new(
3271 username: *const c_char,
3272 mechanism: rd_kafka_ScramMechanism_t,
3273 iterations: i32,
3274 password: *const ::std::os::raw::c_uchar,
3275 password_size: usize,
3276 salt: *const ::std::os::raw::c_uchar,
3277 salt_size: usize,
3278 ) -> *mut rd_kafka_UserScramCredentialAlteration_t;
3279}
3280extern "C" {
3281 pub fn rd_kafka_UserScramCredentialDeletion_new(
3282 username: *const c_char,
3283 mechanism: rd_kafka_ScramMechanism_t,
3284 ) -> *mut rd_kafka_UserScramCredentialAlteration_t;
3285}
3286extern "C" {
3287 pub fn rd_kafka_UserScramCredentialAlteration_destroy(
3288 alteration: *mut rd_kafka_UserScramCredentialAlteration_t,
3289 );
3290}
3291extern "C" {
3292 pub fn rd_kafka_UserScramCredentialAlteration_destroy_array(
3293 alterations: *mut *mut rd_kafka_UserScramCredentialAlteration_t,
3294 alteration_cnt: usize,
3295 );
3296}
3297#[repr(C)]
3298#[derive(Debug, Copy, Clone)]
3299pub struct rd_kafka_AlterUserScramCredentials_result_response_s {
3300 _unused: [u8; 0],
3301}
3302pub type rd_kafka_AlterUserScramCredentials_result_response_t =
3303 rd_kafka_AlterUserScramCredentials_result_response_s;
3304extern "C" {
3305 pub fn rd_kafka_AlterUserScramCredentials_result_response_user(
3306 response: *const rd_kafka_AlterUserScramCredentials_result_response_t,
3307 ) -> *const c_char;
3308}
3309extern "C" {
3310 pub fn rd_kafka_AlterUserScramCredentials_result_response_error(
3311 response: *const rd_kafka_AlterUserScramCredentials_result_response_t,
3312 ) -> *const rd_kafka_error_t;
3313}
3314extern "C" {
3315 pub fn rd_kafka_AlterUserScramCredentials_result_responses(
3316 result: *const rd_kafka_AlterUserScramCredentials_result_t,
3317 cntp: *mut usize,
3318 ) -> *mut *const rd_kafka_AlterUserScramCredentials_result_response_t;
3319}
3320extern "C" {
3321 pub fn rd_kafka_AlterUserScramCredentials(
3322 rk: *mut rd_kafka_t,
3323 alterations: *mut *mut rd_kafka_UserScramCredentialAlteration_t,
3324 alteration_cnt: usize,
3325 options: *const rd_kafka_AdminOptions_t,
3326 rkqu: *mut rd_kafka_queue_t,
3327 );
3328}
3329#[repr(C)]
3330#[derive(Debug, Copy, Clone)]
3331pub struct rd_kafka_AclBinding_s {
3332 _unused: [u8; 0],
3333}
3334pub type rd_kafka_AclBinding_t = rd_kafka_AclBinding_s;
3335pub type rd_kafka_AclBindingFilter_t = rd_kafka_AclBinding_t;
3336extern "C" {
3337 pub fn rd_kafka_acl_result_error(
3338 aclres: *const rd_kafka_acl_result_t,
3339 ) -> *const rd_kafka_error_t;
3340}
3341extern "C" {
3342 pub fn rd_kafka_AclOperation_name(acl_operation: rd_kafka_AclOperation_t) -> *const c_char;
3343}
3344#[repr(u32)]
3345#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3346pub enum rd_kafka_AclPermissionType_t {
3347 RD_KAFKA_ACL_PERMISSION_TYPE_UNKNOWN = 0,
3348 RD_KAFKA_ACL_PERMISSION_TYPE_ANY = 1,
3349 RD_KAFKA_ACL_PERMISSION_TYPE_DENY = 2,
3350 RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3,
3351 RD_KAFKA_ACL_PERMISSION_TYPE__CNT = 4,
3352}
3353extern "C" {
3354 pub fn rd_kafka_AclPermissionType_name(
3355 acl_permission_type: rd_kafka_AclPermissionType_t,
3356 ) -> *const c_char;
3357}
3358extern "C" {
3359 pub fn rd_kafka_AclBinding_new(
3360 restype: rd_kafka_ResourceType_t,
3361 name: *const c_char,
3362 resource_pattern_type: rd_kafka_ResourcePatternType_t,
3363 principal: *const c_char,
3364 host: *const c_char,
3365 operation: rd_kafka_AclOperation_t,
3366 permission_type: rd_kafka_AclPermissionType_t,
3367 errstr: *mut c_char,
3368 errstr_size: usize,
3369 ) -> *mut rd_kafka_AclBinding_t;
3370}
3371extern "C" {
3372 pub fn rd_kafka_AclBindingFilter_new(
3373 restype: rd_kafka_ResourceType_t,
3374 name: *const c_char,
3375 resource_pattern_type: rd_kafka_ResourcePatternType_t,
3376 principal: *const c_char,
3377 host: *const c_char,
3378 operation: rd_kafka_AclOperation_t,
3379 permission_type: rd_kafka_AclPermissionType_t,
3380 errstr: *mut c_char,
3381 errstr_size: usize,
3382 ) -> *mut rd_kafka_AclBindingFilter_t;
3383}
3384extern "C" {
3385 pub fn rd_kafka_AclBinding_restype(
3386 acl: *const rd_kafka_AclBinding_t,
3387 ) -> rd_kafka_ResourceType_t;
3388}
3389extern "C" {
3390 pub fn rd_kafka_AclBinding_name(acl: *const rd_kafka_AclBinding_t) -> *const c_char;
3391}
3392extern "C" {
3393 pub fn rd_kafka_AclBinding_principal(acl: *const rd_kafka_AclBinding_t) -> *const c_char;
3394}
3395extern "C" {
3396 pub fn rd_kafka_AclBinding_host(acl: *const rd_kafka_AclBinding_t) -> *const c_char;
3397}
3398extern "C" {
3399 pub fn rd_kafka_AclBinding_operation(
3400 acl: *const rd_kafka_AclBinding_t,
3401 ) -> rd_kafka_AclOperation_t;
3402}
3403extern "C" {
3404 pub fn rd_kafka_AclBinding_permission_type(
3405 acl: *const rd_kafka_AclBinding_t,
3406 ) -> rd_kafka_AclPermissionType_t;
3407}
3408extern "C" {
3409 pub fn rd_kafka_AclBinding_resource_pattern_type(
3410 acl: *const rd_kafka_AclBinding_t,
3411 ) -> rd_kafka_ResourcePatternType_t;
3412}
3413extern "C" {
3414 pub fn rd_kafka_AclBinding_error(acl: *const rd_kafka_AclBinding_t) -> *const rd_kafka_error_t;
3415}
3416extern "C" {
3417 pub fn rd_kafka_AclBinding_destroy(acl_binding: *mut rd_kafka_AclBinding_t);
3418}
3419extern "C" {
3420 pub fn rd_kafka_AclBinding_destroy_array(
3421 acl_bindings: *mut *mut rd_kafka_AclBinding_t,
3422 acl_bindings_cnt: usize,
3423 );
3424}
3425extern "C" {
3426 pub fn rd_kafka_CreateAcls_result_acls(
3427 result: *const rd_kafka_CreateAcls_result_t,
3428 cntp: *mut usize,
3429 ) -> *mut *const rd_kafka_acl_result_t;
3430}
3431extern "C" {
3432 pub fn rd_kafka_CreateAcls(
3433 rk: *mut rd_kafka_t,
3434 new_acls: *mut *mut rd_kafka_AclBinding_t,
3435 new_acls_cnt: usize,
3436 options: *const rd_kafka_AdminOptions_t,
3437 rkqu: *mut rd_kafka_queue_t,
3438 );
3439}
3440extern "C" {
3441 pub fn rd_kafka_DescribeAcls_result_acls(
3442 result: *const rd_kafka_DescribeAcls_result_t,
3443 cntp: *mut usize,
3444 ) -> *mut *const rd_kafka_AclBinding_t;
3445}
3446extern "C" {
3447 pub fn rd_kafka_DescribeAcls(
3448 rk: *mut rd_kafka_t,
3449 acl_filter: *mut rd_kafka_AclBindingFilter_t,
3450 options: *const rd_kafka_AdminOptions_t,
3451 rkqu: *mut rd_kafka_queue_t,
3452 );
3453}
3454#[repr(C)]
3455#[derive(Debug, Copy, Clone)]
3456pub struct rd_kafka_DeleteAcls_result_response_s {
3457 _unused: [u8; 0],
3458}
3459pub type rd_kafka_DeleteAcls_result_response_t = rd_kafka_DeleteAcls_result_response_s;
3460extern "C" {
3461 pub fn rd_kafka_DeleteAcls_result_responses(
3462 result: *const rd_kafka_DeleteAcls_result_t,
3463 cntp: *mut usize,
3464 ) -> *mut *const rd_kafka_DeleteAcls_result_response_t;
3465}
3466extern "C" {
3467 pub fn rd_kafka_DeleteAcls_result_response_error(
3468 result_response: *const rd_kafka_DeleteAcls_result_response_t,
3469 ) -> *const rd_kafka_error_t;
3470}
3471extern "C" {
3472 pub fn rd_kafka_DeleteAcls_result_response_matching_acls(
3473 result_response: *const rd_kafka_DeleteAcls_result_response_t,
3474 matching_acls_cntp: *mut usize,
3475 ) -> *mut *const rd_kafka_AclBinding_t;
3476}
3477extern "C" {
3478 pub fn rd_kafka_DeleteAcls(
3479 rk: *mut rd_kafka_t,
3480 del_acls: *mut *mut rd_kafka_AclBindingFilter_t,
3481 del_acls_cnt: usize,
3482 options: *const rd_kafka_AdminOptions_t,
3483 rkqu: *mut rd_kafka_queue_t,
3484 );
3485}
3486extern "C" {
3487 pub fn rd_kafka_oauthbearer_set_token(
3488 rk: *mut rd_kafka_t,
3489 token_value: *const c_char,
3490 md_lifetime_ms: i64,
3491 md_principal_name: *const c_char,
3492 extensions: *mut *const c_char,
3493 extension_size: usize,
3494 errstr: *mut c_char,
3495 errstr_size: usize,
3496 ) -> rd_kafka_resp_err_t;
3497}
3498extern "C" {
3499 pub fn rd_kafka_oauthbearer_set_token_failure(
3500 rk: *mut rd_kafka_t,
3501 errstr: *const c_char,
3502 ) -> rd_kafka_resp_err_t;
3503}
3504extern "C" {
3505 pub fn rd_kafka_init_transactions(
3506 rk: *mut rd_kafka_t,
3507 timeout_ms: c_int,
3508 ) -> *mut rd_kafka_error_t;
3509}
3510extern "C" {
3511 pub fn rd_kafka_begin_transaction(rk: *mut rd_kafka_t) -> *mut rd_kafka_error_t;
3512}
3513extern "C" {
3514 pub fn rd_kafka_send_offsets_to_transaction(
3515 rk: *mut rd_kafka_t,
3516 offsets: *const rd_kafka_topic_partition_list_t,
3517 cgmetadata: *const rd_kafka_consumer_group_metadata_t,
3518 timeout_ms: c_int,
3519 ) -> *mut rd_kafka_error_t;
3520}
3521extern "C" {
3522 pub fn rd_kafka_commit_transaction(
3523 rk: *mut rd_kafka_t,
3524 timeout_ms: c_int,
3525 ) -> *mut rd_kafka_error_t;
3526}
3527extern "C" {
3528 pub fn rd_kafka_abort_transaction(
3529 rk: *mut rd_kafka_t,
3530 timeout_ms: c_int,
3531 ) -> *mut rd_kafka_error_t;
3532}