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