@platformatic/kafka 0.1.0

package/dist/apis/producer/add-offsets-to-txn.d.ts

@@ -0,0 +1,10 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type AddOffsetsToTxnRequest = Parameters<typeof createRequest>;
+export interface AddOffsetsToTxnResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+}
+export declare function createRequest(transactionalId: string, producerId: bigint, producerEpoch: number, groupId: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AddOffsetsToTxnResponse;
+export declare const api: import("../definitions.ts").API<[transactionalId: string, producerId: bigint, producerEpoch: number, groupId: string], AddOffsetsToTxnResponse>;

package/dist/apis/producer/add-offsets-to-txn.js

@@ -0,0 +1,34 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  AddOffsetsToTxn Request (Version: 4) => transactional_id producer_id producer_epoch group_id TAG_BUFFER
+    transactional_id => COMPACT_STRING
+    producer_id => INT64
+    producer_epoch => INT16
+    group_id => COMPACT_STRING
+*/
+export function createRequest(transactionalId, producerId, producerEpoch, groupId) {
+    return Writer.create()
+        .appendString(transactionalId, true)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendString(groupId, true)
+        .appendTaggedFields();
+}
+/*
+  AddOffsetsToTxn Response (Version: 4) => throttle_time_ms error_code TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(25, 4, createRequest, parseResponse);

package/dist/apis/producer/add-partitions-to-txn.d.ts

@@ -0,0 +1,34 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface AddPartitionsToTxnRequestTopic {
+    name: string;
+    partitions: number[];
+}
+export interface AddPartitionsToTxnRequestTransaction {
+    transactionalId: string;
+    producerId: bigint;
+    producerEpoch: number;
+    verifyOnly: boolean;
+    topics: AddPartitionsToTxnRequestTopic[];
+}
+export type AddPartitionsToTxnRequest = Parameters<typeof createRequest>;
+export interface AddPartitionsToTxnResponsePartition {
+    partitionIndex: number;
+    partitionErrorCode: number;
+}
+export interface AddPartitionsToTxnResponseTopic {
+    name: string;
+    resultsByPartition: AddPartitionsToTxnResponsePartition[];
+}
+export interface AddPartitionsToTxnResponseTransaction {
+    transactionalId: string;
+    topicResults: AddPartitionsToTxnResponseTopic[];
+}
+export interface AddPartitionsToTxnResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    resultsByTransaction: AddPartitionsToTxnResponseTransaction[];
+}
+export declare function createRequest(transactions: AddPartitionsToTxnRequestTransaction[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AddPartitionsToTxnResponse;
+export declare const api: import("../definitions.ts").API<[transactions: AddPartitionsToTxnRequestTransaction[]], AddPartitionsToTxnResponse>;

package/dist/apis/producer/add-partitions-to-txn.js

@@ -0,0 +1,79 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  AddPartitionsToTxn Request (Version: 5) => [transactions] TAG_BUFFER
+    transactions => transactional_id producer_id producer_epoch verify_only [topics] TAG_BUFFER
+      transactional_id => COMPACT_STRING
+      producer_id => INT64
+      producer_epoch => INT16
+      verify_only => BOOLEAN
+      topics => name [partitions] TAG_BUFFER
+        name => COMPACT_STRING
+        partitions => INT32
+*/
+export function createRequest(transactions) {
+    return Writer.create()
+        .appendArray(transactions, (w, transaction) => {
+        w.appendString(transaction.transactionalId)
+            .appendInt64(transaction.producerId)
+            .appendInt16(transaction.producerEpoch)
+            .appendBoolean(transaction.verifyOnly)
+            .appendArray(transaction.topics, (w, topic) => {
+            w.appendString(topic.name).appendArray(topic.partitions, (w, partition) => w.appendInt32(partition), true, false);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  AddPartitionsToTxn Response (Version: 5) => throttle_time_ms error_code [results_by_transaction] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    results_by_transaction => transactional_id [topic_results] TAG_BUFFER
+      transactional_id => COMPACT_STRING
+      topic_results => name [results_by_partition] TAG_BUFFER
+        name => COMPACT_STRING
+        results_by_partition => partition_index partition_error_code TAG_BUFFER
+          partition_index => INT32
+          partition_error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['', errorCode]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        resultsByTransaction: reader.readArray((r, i) => {
+            return {
+                transactionalId: r.readString(),
+                topicResults: r.readArray((r, j) => {
+                    return {
+                        name: r.readString(),
+                        resultsByPartition: r.readArray((r, k) => {
+                            const partition = {
+                                partitionIndex: r.readInt32(),
+                                partitionErrorCode: r.readInt16()
+                            };
+                            if (partition.partitionErrorCode !== 0) {
+                                errors.push([
+                                    `/results_by_transaction/${i}/topic_results/${j}/results_by_partitions/${k}`,
+                                    partition.partitionErrorCode
+                                ]);
+                            }
+                            return partition;
+                        })
+                    };
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(24, 5, createRequest, parseResponse);

package/dist/apis/producer/end-txn.d.ts

@@ -0,0 +1,10 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type EndTxnRequest = Parameters<typeof createRequest>;
+export interface EndTxnResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+}
+export declare function createRequest(transactionalId: string, producerId: bigint, producerEpoch: number, committed: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): EndTxnResponse;
+export declare const api: import("../definitions.ts").API<[transactionalId: string, producerId: bigint, producerEpoch: number, committed: boolean], EndTxnResponse>;

package/dist/apis/producer/end-txn.js

@@ -0,0 +1,34 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  EndTxn Request (Version: 4) => transactional_id producer_id producer_epoch committed TAG_BUFFER
+    transactional_id => COMPACT_STRING
+    producer_id => INT64
+    producer_epoch => INT16
+    committed => BOOLEAN
+*/
+export function createRequest(transactionalId, producerId, producerEpoch, committed) {
+    return Writer.create()
+        .appendString(transactionalId, true)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendBoolean(committed)
+        .appendTaggedFields();
+}
+/*
+  EndTxn Response (Version: 4) => throttle_time_ms error_code TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(26, 4, createRequest, parseResponse);

package/dist/apis/producer/index.d.ts

@@ -0,0 +1,6 @@
+export * as addOffsetsToTxnV4 from './add-offsets-to-txn.ts';
+export * as addPartitionsToTxnV5 from './add-partitions-to-txn.ts';
+export * as endTxnV4 from './end-txn.ts';
+export * as initProducerIdV5 from './init-producer-id.ts';
+export * as produceV11 from './produce.ts';
+export * as txnOffsetCommitV4 from './txn-offset-commit.ts';

package/dist/apis/producer/index.js

@@ -0,0 +1,6 @@
+export * as addOffsetsToTxnV4 from "./add-offsets-to-txn.js";
+export * as addPartitionsToTxnV5 from "./add-partitions-to-txn.js";
+export * as endTxnV4 from "./end-txn.js";
+export * as initProducerIdV5 from "./init-producer-id.js";
+export * as produceV11 from "./produce.js";
+export * as txnOffsetCommitV4 from "./txn-offset-commit.js";

package/dist/apis/producer/init-producer-id.d.ts

@@ -0,0 +1,21 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type InitProducerIdRequest = Parameters<typeof createRequest>;
+export interface InitProducerIdResponseCoordinator {
+    key: string;
+    nodeId: number;
+    host: string;
+    port: number;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface InitProducerIdResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    producerId: bigint;
+    producerEpoch: number;
+}
+export declare function createRequest(transactionalId: NullableString, transactionTimeoutMs: number, producerId: bigint, producerEpoch: number): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): InitProducerIdResponse;
+export declare const api: import("../definitions.ts").API<[transactionalId: NullableString, transactionTimeoutMs: number, producerId: bigint, producerEpoch: number], InitProducerIdResponse>;

package/dist/apis/producer/init-producer-id.js

@@ -0,0 +1,38 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  InitProducerId Request (Version: 5) => transactional_id transaction_timeout_ms producer_id producer_epoch TAG_BUFFER
+    transactional_id => COMPACT_NULLABLE_STRING
+    transaction_timeout_ms => INT32
+    producer_id => INT64
+    producer_epoch => INT16
+*/
+export function createRequest(transactionalId, transactionTimeoutMs, producerId, producerEpoch) {
+    return Writer.create()
+        .appendString(transactionalId, true)
+        .appendInt32(transactionTimeoutMs)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendTaggedFields();
+}
+/*
+  InitProducerId Response (Version: 5) => throttle_time_ms error_code producer_id producer_epoch TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    producer_id => INT64
+    producer_epoch => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        producerId: reader.readInt64(),
+        producerEpoch: reader.readInt16()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(22, 5, createRequest, parseResponse);

package/dist/apis/producer/produce.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { type CreateRecordsBatchOptions, type MessageRecord } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ProduceRequest = Parameters<typeof createRequest>;
+export interface ProduceResponsePartitionRecordError {
+    batchIndex: number;
+    batchIndexErrorMessage: NullableString;
+}
+export interface ProduceResponsePartition {
+    index: number;
+    errorCode: number;
+    baseOffset: bigint;
+    logAppendTimeMs: bigint;
+    logStartOffset: bigint;
+    recordErrors: ProduceResponsePartitionRecordError[];
+    errorMessage: NullableString;
+}
+export interface ProduceResponseTopic {
+    name: string;
+    partitionResponses: ProduceResponsePartition[];
+}
+export interface ProduceResponse {
+    responses: ProduceResponseTopic[];
+    throttleTimeMs: number;
+}
+export declare function createRequest(acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions>): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ProduceResponse;
+export declare const api: import("../definitions.ts").API<[acks: number | undefined, timeout: number | undefined, topicData: MessageRecord[], options?: Partial<CreateRecordsBatchOptions> | undefined], boolean | ProduceResponse>;

package/dist/apis/producer/produce.js

@@ -0,0 +1,104 @@
+import { ResponseError } from "../../errors.js";
+import { createRecordsBatch } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { groupByProperty } from "../../utils.js";
+import { createAPI } from "../definitions.js";
+import { ProduceAcks } from "../enumerations.js";
+/*
+  Produce Request (Version: 11) => transactional_id acks timeout_ms [topic_data] TAG_BUFFER
+    transactional_id => COMPACT_NULLABLE_STRING
+    acks => INT16
+    timeout_ms => INT32
+    topic_data => name [partition_data] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_data => index records TAG_BUFFER
+        index => INT32
+        records => COMPACT_RECORDS
+*/
+export function createRequest(acks = 1, timeout = 0, topicData, options = {}) {
+    // Normalize the messages
+    const now = BigInt(Date.now());
+    for (const message of topicData) {
+        if (typeof message.partition === 'undefined') {
+            message.partition = 0;
+        }
+        if (typeof message.timestamp === 'undefined') {
+            message.timestamp = now;
+        }
+    }
+    const writer = Writer.create()
+        .appendString(options.transactionalId)
+        .appendInt16(acks)
+        .appendInt32(timeout)
+        .appendArray(groupByProperty(topicData, 'topic'), (w, [topic, messages]) => {
+        w.appendString(topic).appendArray(groupByProperty(messages, 'partition'), (w, [partition, messages]) => {
+            const records = createRecordsBatch(messages, options);
+            w.appendInt32(partition)
+                .appendUnsignedVarInt(records.length + 1)
+                .appendFrom(records);
+        });
+    })
+        .appendTaggedFields();
+    if (acks === ProduceAcks.NO_RESPONSE) {
+        writer.context.noResponse = true;
+    }
+    return writer;
+}
+/*
+  Produce Response (Version: 11) => [responses] throttle_time_ms TAG_BUFFER
+    responses => name [partition_responses] TAG_BUFFER
+      name => COMPACT_STRING
+      partition_responses => index error_code base_offset log_append_time_ms log_start_offset [record_errors] error_message TAG_BUFFER
+        index => INT32
+        error_code => INT16
+        base_offset => INT64
+        log_append_time_ms => INT64
+        log_start_offset => INT64
+        record_errors => batch_index batch_index_error_message TAG_BUFFER
+          batch_index => INT32
+          batch_index_error_message => COMPACT_NULLABLE_STRING
+        error_message => COMPACT_NULLABLE_STRING
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        responses: reader.readArray((r, i) => {
+            const topicResponse = {
+                name: r.readString(),
+                partitionResponses: r.readArray((r, j) => {
+                    const index = r.readInt32();
+                    const errorCode = r.readInt16();
+                    if (errorCode !== 0) {
+                        errors.push([`/responses/${i}/partition_responses/${j}`, errorCode]);
+                    }
+                    return {
+                        index,
+                        errorCode,
+                        baseOffset: r.readInt64(),
+                        logAppendTimeMs: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        recordErrors: r.readArray((r, k) => {
+                            const recordError = {
+                                batchIndex: r.readInt32(),
+                                batchIndexErrorMessage: r.readNullableString()
+                            };
+                            if (recordError.batchIndexErrorMessage) {
+                                errors.push([`/responses/${i}/partition_responses/${j}/record_errors/${k}`, -1]);
+                            }
+                            return recordError;
+                        }),
+                        errorMessage: r.readNullableString()
+                    };
+                })
+            };
+            return topicResponse;
+        }),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(0, 11, createRequest, parseResponse);

package/dist/apis/producer/txn-offset-commit.d.ts

@@ -0,0 +1,29 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface TxnOffsetCommitRequestPartition {
+    partitionIndex: number;
+    committedOffset: bigint;
+    committedLeaderEpoch: number;
+    committedMetadata?: NullableString;
+}
+export interface TxnOffsetCommitRequestTopic {
+    name: string;
+    partitions: TxnOffsetCommitRequestPartition[];
+}
+export type TxnOffsetCommitRequest = Parameters<typeof createRequest>;
+export interface TxnOffsetCommitResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+}
+export interface TxnOffsetCommitResponseTopic {
+    name: string;
+    partitions: TxnOffsetCommitResponsePartition[];
+}
+export interface TxnOffsetCommitResponse {
+    throttleTimeMs: number;
+    topics: TxnOffsetCommitResponseTopic[];
+}
+export declare function createRequest(transactionalId: string, groupId: string, producerId: bigint, producerEpoch: number, generationId: number, memberId: string, groupInstanceId: NullableString, topics: TxnOffsetCommitRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): TxnOffsetCommitResponse;
+export declare const api: import("../definitions.ts").API<[transactionalId: string, groupId: string, producerId: bigint, producerEpoch: number, generationId: number, memberId: string, groupInstanceId: NullableString, topics: TxnOffsetCommitRequestTopic[]], TxnOffsetCommitResponse>;

package/dist/apis/producer/txn-offset-commit.js

@@ -0,0 +1,77 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  TxnOffsetCommit Request (Version: 4) => transactional_id group_id producer_id producer_epoch generation_id member_id group_instance_id [topics] TAG_BUFFER
+    transactional_id => COMPACT_STRING
+    group_id => COMPACT_STRING
+    producer_id => INT64
+    producer_epoch => INT16
+    generation_id => INT32
+    member_id => COMPACT_STRING
+    group_instance_id => COMPACT_NULLABLE_STRING
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index committed_offset committed_leader_epoch committed_metadata TAG_BUFFER
+        partition_index => INT32
+        committed_offset => INT64
+        committed_leader_epoch => INT32
+        committed_metadata => COMPACT_NULLABLE_STRING
+*/
+export function createRequest(transactionalId, groupId, producerId, producerEpoch, generationId, memberId, groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(transactionalId, true)
+        .appendString(groupId, true)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendInt32(generationId)
+        .appendString(memberId, true)
+        .appendString(groupInstanceId, true)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name, true)
+            .appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex)
+                .appendInt64(p.committedOffset)
+                .appendInt32(p.committedLeaderEpoch)
+                .appendString(p.committedMetadata, true)
+                .appendTaggedFields(); // Add tagged fields for partitions
+        }, true, true)
+            .appendTaggedFields(); // Add tagged fields for topics
+    }, true, true)
+        .appendTaggedFields();
+}
+/*
+  TxnOffsetCommit Response (Version: 4) => throttle_time_ms [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index error_code TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, i) => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16()
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/topics/${i}/partitions/${j}`, partition.errorCode]);
+                    }
+                    return partition;
+                })
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(28, 4, createRequest, parseResponse);

package/dist/apis/security/index.d.ts

@@ -0,0 +1,2 @@
+export * as saslAuthenticateV2 from './sasl-authenticate.ts';
+export * as saslHandshakeV1 from './sasl-handshake.ts';

package/dist/apis/security/index.js

@@ -0,0 +1,2 @@
+export * as saslAuthenticateV2 from "./sasl-authenticate.js";
+export * as saslHandshakeV1 from "./sasl-handshake.js";

package/dist/apis/security/sasl-authenticate.d.ts

@@ -0,0 +1,15 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+import { type API } from '../definitions.ts';
+export type SaslAuthenticateRequest = Parameters<typeof createRequest>;
+export interface SaslAuthenticateResponse {
+    errorCode: number;
+    errorMessage: NullableString;
+    authBytes: Buffer;
+    sessionLifetimeMs: bigint;
+}
+export type SASLAuthenticationAPI = API<[Buffer], SaslAuthenticateResponse>;
+export declare function createRequest(authBytes: Buffer): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): SaslAuthenticateResponse;
+export declare const api: API<[authBytes: Buffer<ArrayBufferLike>], SaslAuthenticateResponse>;

package/dist/apis/security/sasl-authenticate.js

@@ -0,0 +1,30 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  SaslAuthenticate Request (Version: 2) => auth_bytes TAG_BUFFER
+    auth_bytes => COMPACT_BYTES
+*/
+export function createRequest(authBytes) {
+    return Writer.create().appendBytes(authBytes).appendTaggedFields();
+}
+/*
+  SaslAuthenticate Response (Version: 2) => error_code error_message auth_bytes session_lifetime_ms TAG_BUFFER
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    auth_bytes => COMPACT_BYTES
+    session_lifetime_ms => INT64
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString(),
+        authBytes: reader.readBytes(),
+        sessionLifetimeMs: reader.readInt64()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(36, 2, createRequest, parseResponse);

package/dist/apis/security/sasl-handshake.d.ts

@@ -0,0 +1,10 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type SaslHandshakeRequest = Parameters<typeof createRequest>;
+export interface SaslHandshakeResponse {
+    errorCode?: number;
+    mechanisms?: string[];
+}
+export declare function createRequest(mechanism: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): SaslHandshakeResponse;
+export declare const api: import("../definitions.ts").API<[mechanism: string], SaslHandshakeResponse>;

package/dist/apis/security/sasl-handshake.js

@@ -0,0 +1,28 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  SaslHandshake Request (Version: 0) => mechanism
+    mechanism => STRING
+*/
+export function createRequest(mechanism) {
+    return Writer.create().appendString(mechanism, false);
+}
+/*
+  SaslHandshake Response (Version: 1) => error_code [mechanisms]
+    error_code => INT16
+    mechanisms => STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        mechanisms: reader.readArray(r => {
+            return r.readString(false);
+        }, false, false)
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(17, 1, createRequest, parseResponse, false, false);

package/dist/apis/telemetry/get-telemetry-subscriptions.d.ts

@@ -0,0 +1,18 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type GetTelemetrySubscriptionsRequest = Parameters<typeof createRequest>;
+export interface GetTelemetrySubscriptionsResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    clientInstanceId: string;
+    subscriptionId: number;
+    acceptedCompressionTypes: number[];
+    pushIntervalMs: number;
+    telemetryMaxBytes: number;
+    deltaTemporality: boolean;
+    requestedMetrics: string[];
+}
+export declare function createRequest(clientInstanceId?: NullableString): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): GetTelemetrySubscriptionsResponse;
+export declare const api: import("../definitions.ts").API<[clientInstanceId?: NullableString], GetTelemetrySubscriptionsResponse>;