@platformatic/kafka 1.27.0-alpha.3 → 1.27.0

package/dist/registries/confluent-schema-registry.js

@@ -0,0 +1,222 @@
+import avro from 'avsc';
+import { createRequire } from 'node:module';
+import { jsonDeserializer, jsonSerializer, stringDeserializer, stringSerializer } from "../clients/serde.js";
+import { ajv, EMPTY_BUFFER, UnsupportedFormatError, UserError } from "../index.js";
+import { getCredential } from "../protocol/sasl/utils.js";
+import { AbstractSchemaRegistry } from "./abstract.js";
+const require = createRequire(import.meta.url);
+/* c8 ignore next 8 */
+export function defaultProtobufTypeMapper(_, type, context) {
+    // Confluent Schema Registry convention
+    return `${context.topic}-${type}`;
+}
+// TODO(ShogunPanda): Authentication support
+export class ConfluentSchemaRegistry extends AbstractSchemaRegistry {
+    #url;
+    #schemas;
+    #protobufParse;
+    #protobufTypeMapper;
+    #jsonValidateSend;
+    #auth;
+    constructor(options) {
+        super();
+        this.#url = options.url;
+        this.#schemas = new Map();
+        this.#protobufTypeMapper = options.protobufTypeMapper ?? defaultProtobufTypeMapper;
+        this.#jsonValidateSend = options.jsonValidateSend ?? false;
+        this.#auth = options.auth;
+    }
+    getSchemaId(message, type) {
+        if (Buffer.isBuffer(message)) {
+            if (type !== 'value') {
+                return undefined;
+            }
+            return message.readInt32BE(1);
+        }
+        return message.metadata?.schemas?.[type];
+    }
+    get(id) {
+        return this.#schemas.get(id);
+    }
+    async fetchSchema(id, callback) {
+        try {
+            const requestInit = {};
+            if (this.#auth) {
+                if (this.#auth.token) {
+                    const token = await getCredential('token', this.#auth.token);
+                    requestInit.headers = {
+                        Authorization: `Bearer ${token}`
+                    };
+                }
+                else {
+                    const username = await getCredential('username', this.#auth.username);
+                    const password = await getCredential('password', this.#auth.password);
+                    requestInit.headers = {
+                        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`
+                    };
+                }
+            }
+            const response = await fetch(`${this.#url}/schemas/ids/${id}`, requestInit);
+            if (!response.ok) {
+                throw new UserError(`Failed to fetch a schema: [HTTP ${response.status}]`, { response: await response.text() });
+            }
+            const responseBody = await response.json();
+            const { schema, schemaType } = responseBody;
+            switch (schemaType) {
+                case 'AVRO':
+                    this.#schemas.set(id, { id, type: 'avro', schema: avro.Type.forSchema(JSON.parse(schema)) });
+                    break;
+                case 'PROTOBUF':
+                    this.#protobufParse ??= this.#loadProtobuf();
+                    this.#schemas.set(id, { id, type: 'protobuf', schema: this.#protobufParse(schema).root });
+                    break;
+                case 'JSON':
+                    this.#schemas.set(id, { id, type: 'json', schema: ajv.compile(JSON.parse(schema)) });
+                    break;
+            }
+            process.nextTick(callback);
+        }
+        catch (err) {
+            process.nextTick(() => callback(err));
+        }
+    }
+    getSerializers() {
+        return {
+            key: this.#schemaSerializer.bind(this, 'key', stringSerializer),
+            value: this.#schemaSerializer.bind(this, 'value', jsonSerializer),
+            headerKey: this.#schemaSerializer.bind(this, 'headerKey', stringSerializer),
+            headerValue: this.#schemaSerializer.bind(this, 'headerValue', jsonSerializer)
+        };
+    }
+    getDeserializers() {
+        return {
+            key: this.#schemaDeserializer.bind(this, 'key', stringDeserializer),
+            value: this.#schemaDeserializer.bind(this, 'value', jsonDeserializer),
+            headerKey: this.#schemaDeserializer.bind(this, 'headerKey', stringDeserializer),
+            headerValue: this.#schemaDeserializer.bind(this, 'headerValue', jsonDeserializer)
+        };
+    }
+    getBeforeSerializationHook() {
+        const registry = this;
+        return function beforeSerialization(_, type, message, callback) {
+            // Extract the schema ID from the message metadata
+            const schemaId = registry.getSchemaId(message, type);
+            // When no schema ID is found, nothing to do
+            if (!schemaId) {
+                callback(null);
+                return;
+            }
+            // The schema is already fetch
+            if (registry.get(schemaId)) {
+                callback(null);
+                return;
+            }
+            registry.fetchSchema(schemaId, callback);
+        };
+    }
+    getBeforeDeserializationHook() {
+        const registry = this;
+        return function beforeDeserialization(payload, type, _message, callback) {
+            // Extract the schema ID from the message metadata
+            const schemaId = registry.getSchemaId(payload, type);
+            // When no schema ID is found, nothing to do
+            if (!schemaId) {
+                callback(null);
+                return;
+            }
+            // The schema is already fetch
+            if (registry.get(schemaId)) {
+                callback(null);
+                return;
+            }
+            registry.fetchSchema(schemaId, callback);
+        };
+    }
+    #schemaSerializer(type, fallbackSerializer, data, headers, message) {
+        /* c8 ignore next 3 - Hard to test */
+        if (typeof data === 'undefined') {
+            return EMPTY_BUFFER;
+        }
+        if (type === 'headerKey' || type === 'headerValue') {
+            message = headers;
+        }
+        const schemaId = message?.metadata?.schemas?.[type];
+        if (!schemaId) {
+            return fallbackSerializer(data);
+        }
+        const schema = this.#schemas.get(schemaId);
+        if (!schema) {
+            throw new UserError(`Schema with ID ${schemaId} not found.`, { missingSchema: schemaId });
+        }
+        let encodedMessage;
+        switch (schema.type) {
+            case 'avro':
+                encodedMessage = schema.schema.toBuffer(data);
+                break;
+            case 'protobuf':
+                {
+                    const typeName = this.#protobufTypeMapper(schemaId, type, message);
+                    const Type = schema.schema.lookupType(typeName);
+                    encodedMessage = Buffer.from(Type.encode(Type.create(data)).finish());
+                }
+                break;
+            case 'json':
+                if (this.#jsonValidateSend) {
+                    const validate = schema.schema;
+                    const valid = validate(data);
+                    if (!valid) {
+                        throw new UserError(`JSON Schema validation failed before serialization: ${ajv.errorsText(validate.errors)}`, { type, data, headers, validationErrors: validate.errors });
+                    }
+                }
+                encodedMessage = Buffer.from(JSON.stringify(data));
+                break;
+        }
+        const header = Buffer.alloc(5);
+        header.writeInt32BE(schemaId, 1);
+        return Buffer.concat([header, encodedMessage]);
+    }
+    #schemaDeserializer(type, fallbackDeserializer, data, headers, message) {
+        /* c8 ignore next 3 - Hard to test */
+        if (typeof data === 'undefined' || data.length === 0) {
+            return EMPTY_BUFFER;
+        }
+        if (type === 'headerKey' || type === 'headerValue') {
+            message = headers;
+        }
+        const schemaId = this.getSchemaId(data, type);
+        if (!schemaId) {
+            return fallbackDeserializer(data);
+        }
+        const schema = this.#schemas.get(schemaId);
+        if (!schema) {
+            throw new UserError(`Schema with ID ${schemaId} not found.`, { missingSchema: schemaId });
+        }
+        switch (schema.type) {
+            case 'avro':
+                return schema.schema.fromBuffer(data.subarray(5));
+            case 'protobuf': {
+                const typeName = this.#protobufTypeMapper(schemaId, type, message);
+                const Type = schema.schema.lookupType(typeName);
+                return Type.decode(data.subarray(5));
+            }
+            case 'json': {
+                const parsed = JSON.parse(data.subarray(5).toString('utf-8'));
+                const validate = schema.schema;
+                const valid = validate(parsed);
+                if (!valid) {
+                    throw new UserError(`JSON Schema validation failed before deserialization: ${ajv.errorsText(validate.errors)}`, { type, data: parsed, headers, validationErrors: validate.errors });
+                }
+                return parsed;
+            }
+        }
+    }
+    #loadProtobuf() {
+        try {
+            return require('protobufjs').parse;
+            /* c8 ignore next 5 - In tests protobufjs is always available */
+        }
+        catch (e) {
+            throw new UnsupportedFormatError('Cannot load protobufjs module, which is an optionalDependency. Please check your local installation.');
+        }
+    }
+}

package/dist/registries/index.d.ts

@@ -0,0 +1,2 @@
+export * from './abstract.ts';
+export * from './confluent-schema-registry.ts';

package/dist/registries/index.js

@@ -0,0 +1,2 @@
+export * from "./abstract.js";
+export * from "./confluent-schema-registry.js";

package/dist/typescript-4/dist/apis/admin/create-acls-v2.d.ts

@@ -0,0 +1,16 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type Acl } from "../types";
+export type CreateAclsRequest = Parameters<typeof createRequest>;
+export interface CreateAclsResponseResult {
+  errorCode: number;
+  errorMessage: NullableString;
+}
+export interface CreateAclsResponse {
+  throttleTimeMs: number;
+  results: CreateAclsResponseResult[];
+}
+export declare function createRequest(creations: Acl[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): CreateAclsResponse;
+export declare const api: import("../definitions").API<[creations: Acl[]], CreateAclsResponse>;

package/dist/typescript-4/dist/apis/admin/delete-acls-v2.d.ts

@@ -0,0 +1,21 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type Acl, type AclFilter } from "../types";
+export type DeleteAclsRequest = Parameters<typeof createRequest>;
+export interface DeleteAclsResponseMatchingAcl extends Acl {
+  errorCode: number;
+  errorMessage: NullableString;
+}
+export interface DeleteAclsResponseFilterResults {
+  errorCode: number;
+  errorMessage: NullableString;
+  matchingAcls: DeleteAclsResponseMatchingAcl[];
+}
+export interface DeleteAclsResponse {
+  throttleTimeMs: number;
+  filterResults: DeleteAclsResponseFilterResults[];
+}
+export declare function createRequest(filters: AclFilter[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DeleteAclsResponse;
+export declare const api: import("../definitions").API<[filters: AclFilter[]], DeleteAclsResponse>;

package/dist/typescript-4/dist/apis/admin/describe-acls-v2.d.ts

@@ -0,0 +1,17 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type AclPermission, type AclTarget, type AclFilter } from "../types";
+export type DescribeAclsRequest = Parameters<typeof createRequest>;
+export interface DescribeAclsResponseResource extends AclTarget {
+  acls: AclPermission[];
+}
+export interface DescribeAclsResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  errorMessage: NullableString;
+  resources: DescribeAclsResponseResource[];
+}
+export declare function createRequest(filter: AclFilter): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeAclsResponse;
+export declare const api: import("../definitions").API<[filter: AclFilter], DescribeAclsResponse>;

package/dist/typescript-4/dist/apis/admin/describe-cluster-v0.d.ts

@@ -0,0 +1,23 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export type DescribeClusterRequest = Parameters<typeof createRequest>;
+export interface DescribeClusterResponseBroker {
+  brokerId: number;
+  host: string;
+  port: number;
+  rack: NullableString;
+}
+export interface DescribeClusterResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  errorMessage: NullableString;
+  endpointType: number;
+  clusterId: string;
+  controllerId: number;
+  brokers: DescribeClusterResponseBroker[];
+  clusterAuthorizedOperations: number;
+}
+export declare function createRequest(includeClusterAuthorizedOperations: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeClusterResponse;
+export declare const api: import("../definitions").API<[includeClusterAuthorizedOperations: boolean], DescribeClusterResponse>;

package/dist/typescript-4/dist/apis/admin/describe-log-dirs-v2.d.ts

@@ -0,0 +1,32 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface DescribeLogDirsRequestTopic {
+  name: string;
+  partitions: number[];
+}
+export type DescribeLogDirsRequest = Parameters<typeof createRequest>;
+export interface DescribeLogDirsResponsePartition {
+  partitionIndex: number;
+  partitionSize: bigint;
+  offsetLag: bigint;
+  isFutureKey: boolean;
+}
+export interface DescribeLogDirsResponseTopic {
+  name: string;
+  partitions: DescribeLogDirsResponsePartition[];
+}
+export interface DescribeLogDirsResponseResult {
+  errorCode: number;
+  logDir: string;
+  topics: DescribeLogDirsResponseTopic[];
+  totalBytes: bigint;
+  usableBytes: bigint;
+}
+export interface DescribeLogDirsResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  results: DescribeLogDirsResponseResult[];
+}
+export declare function createRequest(topics: DescribeLogDirsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeLogDirsResponse;
+export declare const api: import("../definitions").API<[topics: DescribeLogDirsRequestTopic[]], DescribeLogDirsResponse>;

package/dist/typescript-4/dist/apis/admin/describe-log-dirs-v3.d.ts

@@ -0,0 +1,32 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface DescribeLogDirsRequestTopic {
+  name: string;
+  partitions: number[];
+}
+export type DescribeLogDirsRequest = Parameters<typeof createRequest>;
+export interface DescribeLogDirsResponsePartition {
+  partitionIndex: number;
+  partitionSize: bigint;
+  offsetLag: bigint;
+  isFutureKey: boolean;
+}
+export interface DescribeLogDirsResponseTopic {
+  name: string;
+  partitions: DescribeLogDirsResponsePartition[];
+}
+export interface DescribeLogDirsResponseResult {
+  errorCode: number;
+  logDir: string;
+  topics: DescribeLogDirsResponseTopic[];
+  totalBytes: bigint;
+  usableBytes: bigint;
+}
+export interface DescribeLogDirsResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  results: DescribeLogDirsResponseResult[];
+}
+export declare function createRequest(topics: DescribeLogDirsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): DescribeLogDirsResponse;
+export declare const api: import("../definitions").API<[topics: DescribeLogDirsRequestTopic[]], DescribeLogDirsResponse>;

package/dist/typescript-4/dist/apis/admin/index.d.ts

@@ -5,24 +5,30 @@ export * as alterPartitionV3 from "./alter-partition-v3";
 export * as alterReplicaLogDirsV2 from "./alter-replica-log-dirs-v2";
 export * as alterUserScramCredentialsV0 from "./alter-user-scram-credentials-v0";
 export * as consumerGroupDescribeV0 from "./consumer-group-describe-v0";
+export * as createAclsV2 from "./create-acls-v2";
 export * as createAclsV3 from "./create-acls-v3";
 export * as createDelegationTokenV3 from "./create-delegation-token-v3";
 export * as createPartitionsV1 from "./create-partitions-v1";
 export * as createPartitionsV2 from "./create-partitions-v2";
 export * as createPartitionsV3 from "./create-partitions-v3";
 export * as createTopicsV7 from "./create-topics-v7";
+export * as deleteAclsV2 from "./delete-acls-v2";
 export * as deleteAclsV3 from "./delete-acls-v3";
 export * as deleteGroupsV2 from "./delete-groups-v2";
 export * as deleteRecordsV2 from "./delete-records-v2";
 export * as deleteTopicsV6 from "./delete-topics-v6";
+export * as describeAclsV2 from "./describe-acls-v2";
 export * as describeAclsV3 from "./describe-acls-v3";
 export * as describeClientQuotasV0 from "./describe-client-quotas-v0";
+export * as describeClusterV0 from "./describe-cluster-v0";
 export * as describeClusterV1 from "./describe-cluster-v1";
 export * as describeConfigsV2 from "./describe-configs-v2";
 export * as describeConfigsV3 from "./describe-configs-v3";
 export * as describeConfigsV4 from "./describe-configs-v4";
 export * as describeDelegationTokenV3 from "./describe-delegation-token-v3";
 export * as describeGroupsV5 from "./describe-groups-v5";
+export * as describeLogDirsV2 from "./describe-log-dirs-v2";
+export * as describeLogDirsV3 from "./describe-log-dirs-v3";
 export * as describeLogDirsV4 from "./describe-log-dirs-v4";
 export * as describeProducersV0 from "./describe-producers-v0";
 export * as describeQuorumV2 from "./describe-quorum-v2";
@@ -35,6 +41,7 @@ export * as incrementalAlterConfigsV1 from "./incremental-alter-configs-v1";
 export * as listGroupsV4 from "./list-groups-v4";
 export * as listGroupsV5 from "./list-groups-v5";
 export * as listPartitionReassignmentsV0 from "./list-partition-reassignments-v0";
+export * as listTransactionsV0 from "./list-transactions-v0";
 export * as listTransactionsV1 from "./list-transactions-v1";
 export * as offsetDeleteV0 from "./offset-delete-v0";
 export * as renewDelegationTokenV2 from "./renew-delegation-token-v2";

package/dist/typescript-4/dist/apis/admin/list-transactions-v0.d.ts

@@ -0,0 +1,18 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+import { type TransactionState } from "../enumerations";
+export type ListTransactionsRequest = Parameters<typeof createRequest>;
+export interface ListTransactionsResponseTransactionState {
+  transactionalId: string;
+  producerId: bigint;
+  transactionState: string;
+}
+export interface ListTransactionsResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  unknownStateFilters: string[];
+  transactionStates: ListTransactionsResponseTransactionState[];
+}
+export declare function createRequest(stateFilters: TransactionState[], producerIdFilters: bigint[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListTransactionsResponse;
+export declare const api: import("../definitions").API<[stateFilters: ("EMPTY" | "ONGOING" | "PREPARE_ABORT" | "COMMITTING" | "ABORTING" | "COMPLETE_COMMIT" | "COMPLETE_ABORT")[], producerIdFilters: bigint[]], ListTransactionsResponse>;

package/dist/typescript-4/dist/apis/consumer/index.d.ts

@@ -6,8 +6,15 @@ export * as fetchV15 from "./fetch-v15";
 export * as fetchV16 from "./fetch-v16";
 export * as fetchV17 from "./fetch-v17";
 export * as heartbeatV4 from "./heartbeat-v4";
+export * as joinGroupV6 from "./join-group-v6";
+export * as joinGroupV7 from "./join-group-v7";
+export * as joinGroupV8 from "./join-group-v8";
 export * as joinGroupV9 from "./join-group-v9";
+export * as leaveGroupV4 from "./leave-group-v4";
 export * as leaveGroupV5 from "./leave-group-v5";
+export * as listOffsetsV5 from "./list-offsets-v5";
+export * as listOffsetsV6 from "./list-offsets-v6";
+export * as listOffsetsV7 from "./list-offsets-v7";
 export * as listOffsetsV8 from "./list-offsets-v8";
 export * as listOffsetsV9 from "./list-offsets-v9";
 export * as offsetCommitV8 from "./offset-commit-v8";
@@ -15,4 +22,5 @@ export * as offsetCommitV9 from "./offset-commit-v9";
 export * as offsetFetchV8 from "./offset-fetch-v8";
 export * as offsetFetchV9 from "./offset-fetch-v9";
 export * as offsetForLeaderEpochV4 from "./offset-for-leader-epoch-v4";
+export * as syncGroupV4 from "./sync-group-v4";
 export * as syncGroupV5 from "./sync-group-v5";

package/dist/typescript-4/dist/apis/consumer/join-group-v6.d.ts

@@ -0,0 +1,27 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface JoinGroupRequestProtocol {
+  name: string;
+  metadata?: Buffer | null;
+}
+export type JoinGroupRequest = Parameters<typeof createRequest>;
+export interface JoinGroupResponseMember {
+  memberId: string;
+  groupInstanceId?: NullableString;
+  metadata: Buffer | null;
+}
+export interface JoinGroupResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  generationId: number;
+  protocolType: NullableString;
+  protocolName: NullableString;
+  leader: string;
+  skipAssignment: boolean;
+  memberId: NullableString;
+  members: JoinGroupResponseMember[];
+}
+export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): JoinGroupResponse;
+export declare const api: import("../definitions").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]], JoinGroupResponse>;

package/dist/typescript-4/dist/apis/consumer/join-group-v7.d.ts

@@ -0,0 +1,27 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface JoinGroupRequestProtocol {
+  name: string;
+  metadata?: Buffer | null;
+}
+export type JoinGroupRequest = Parameters<typeof createRequest>;
+export interface JoinGroupResponseMember {
+  memberId: string;
+  groupInstanceId?: NullableString;
+  metadata: Buffer | null;
+}
+export interface JoinGroupResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  generationId: number;
+  protocolType: NullableString;
+  protocolName: NullableString;
+  leader: string;
+  skipAssignment: boolean;
+  memberId: NullableString;
+  members: JoinGroupResponseMember[];
+}
+export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): JoinGroupResponse;
+export declare const api: import("../definitions").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[]], JoinGroupResponse>;

package/dist/typescript-4/dist/apis/consumer/join-group-v8.d.ts

@@ -0,0 +1,27 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface JoinGroupRequestProtocol {
+  name: string;
+  metadata?: Buffer | null;
+}
+export type JoinGroupRequest = Parameters<typeof createRequest>;
+export interface JoinGroupResponseMember {
+  memberId: string;
+  groupInstanceId?: NullableString;
+  metadata: Buffer | null;
+}
+export interface JoinGroupResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  generationId: number;
+  protocolType: NullableString;
+  protocolName: NullableString;
+  leader: string;
+  skipAssignment: boolean;
+  memberId: NullableString;
+  members: JoinGroupResponseMember[];
+}
+export declare function createRequest(groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], reason?: NullableString): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): JoinGroupResponse;
+export declare const api: import("../definitions").API<[groupId: string, sessionTimeoutMs: number, rebalanceTimeoutMs: number, memberId: string, groupInstanceId: NullableString, protocolType: string, protocols: JoinGroupRequestProtocol[], reason?: NullableString], JoinGroupResponse>;

package/dist/typescript-4/dist/apis/consumer/leave-group-v4.d.ts

@@ -0,0 +1,22 @@
+import { type NullableString } from "../../protocol/definitions";
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface LeaveGroupRequestMember {
+  memberId: string;
+  groupInstanceId?: NullableString;
+  reason?: NullableString;
+}
+export type LeaveGroupRequest = Parameters<typeof createRequest>;
+export interface LeaveGroupResponseMember {
+  memberId: NullableString;
+  groupInstanceId: NullableString;
+  errorCode: number;
+}
+export interface LeaveGroupResponse {
+  throttleTimeMs: number;
+  errorCode: number;
+  members: LeaveGroupResponseMember[];
+}
+export declare function createRequest(groupId: string, members: LeaveGroupRequestMember[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): LeaveGroupResponse;
+export declare const api: import("../definitions").API<[groupId: string, members: LeaveGroupRequestMember[]], LeaveGroupResponse>;

package/dist/typescript-4/dist/apis/consumer/list-offsets-v5.d.ts

@@ -0,0 +1,30 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface ListOffsetsRequestPartition {
+  partitionIndex: number;
+  currentLeaderEpoch: number;
+  timestamp: bigint;
+}
+export interface ListOffsetsRequestTopic {
+  name: string;
+  partitions: ListOffsetsRequestPartition[];
+}
+export type ListOffsetsRequest = Parameters<typeof createRequest>;
+export interface ListOffsetResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  timestamp: bigint;
+  offset: bigint;
+  leaderEpoch: number;
+}
+export interface ListOffsetResponseTopic {
+  name: string;
+  partitions: ListOffsetResponsePartition[];
+}
+export interface ListOffsetsResponse {
+  throttleTimeMs: number;
+  topics: ListOffsetResponseTopic[];
+}
+export declare function createRequest(replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListOffsetsResponse;
+export declare const api: import("../definitions").API<[replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]], ListOffsetsResponse>;

package/dist/typescript-4/dist/apis/consumer/list-offsets-v6.d.ts

@@ -0,0 +1,30 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface ListOffsetsRequestPartition {
+  partitionIndex: number;
+  currentLeaderEpoch: number;
+  timestamp: bigint;
+}
+export interface ListOffsetsRequestTopic {
+  name: string;
+  partitions: ListOffsetsRequestPartition[];
+}
+export type ListOffsetsRequest = Parameters<typeof createRequest>;
+export interface ListOffsetResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  timestamp: bigint;
+  offset: bigint;
+  leaderEpoch: number;
+}
+export interface ListOffsetResponseTopic {
+  name: string;
+  partitions: ListOffsetResponsePartition[];
+}
+export interface ListOffsetsResponse {
+  throttleTimeMs: number;
+  topics: ListOffsetResponseTopic[];
+}
+export declare function createRequest(replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListOffsetsResponse;
+export declare const api: import("../definitions").API<[replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]], ListOffsetsResponse>;

package/dist/typescript-4/dist/apis/consumer/list-offsets-v7.d.ts

@@ -0,0 +1,30 @@
+import { type Reader } from "../../protocol/reader";
+import { Writer } from "../../protocol/writer";
+export interface ListOffsetsRequestPartition {
+  partitionIndex: number;
+  currentLeaderEpoch: number;
+  timestamp: bigint;
+}
+export interface ListOffsetsRequestTopic {
+  name: string;
+  partitions: ListOffsetsRequestPartition[];
+}
+export type ListOffsetsRequest = Parameters<typeof createRequest>;
+export interface ListOffsetResponsePartition {
+  partitionIndex: number;
+  errorCode: number;
+  timestamp: bigint;
+  offset: bigint;
+  leaderEpoch: number;
+}
+export interface ListOffsetResponseTopic {
+  name: string;
+  partitions: ListOffsetResponsePartition[];
+}
+export interface ListOffsetsResponse {
+  throttleTimeMs: number;
+  topics: ListOffsetResponseTopic[];
+}
+export declare function createRequest(replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListOffsetsResponse;
+export declare const api: import("../definitions").API<[replica: number, isolationLevel: number, topics: ListOffsetsRequestTopic[]], ListOffsetsResponse>;