@platformatic/kafka 2.0.1 → 2.2.0

package/dist/apis/producer/txn-offset-commit-v2.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-v2.js

@@ -0,0 +1,62 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  TxnOffsetCommit Request (Version: 2) => transactional_id group_id producer_id producer_epoch [topics]
+    transactional_id => STRING
+    group_id => STRING
+    producer_id => INT64
+    producer_epoch => INT16
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index committed_offset committed_leader_epoch committed_metadata
+        partition_index => INT32
+        committed_offset => INT64
+        committed_leader_epoch => INT32
+        committed_metadata => NULLABLE_STRING
+*/
+export function createRequest(transactionalId, groupId, producerId, producerEpoch, _generationId, _memberId, _groupInstanceId, topics) {
+    return Writer.create()
+        .appendString(transactionalId, false)
+        .appendString(groupId, false)
+        .appendInt64(producerId)
+        .appendInt16(producerEpoch)
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.name, false).appendArray(topic.partitions, (w, partition) => {
+            w.appendInt32(partition.partitionIndex)
+                .appendInt64(partition.committedOffset)
+                .appendInt32(partition.committedLeaderEpoch)
+                .appendString(partition.committedMetadata, false);
+        }, false, false);
+    }, false, false);
+}
+/*
+  TxnOffsetCommit Response (Version: 2) => throttle_time_ms [topics]
+    throttle_time_ms => INT32
+    topics => name [partitions]
+      name => STRING
+      partitions => partition_index error_code
+        partition_index => INT32
+        error_code => INT16
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        topics: reader.readArray((r, topicIndex) => ({
+            name: r.readString(false),
+            partitions: r.readArray((r, partitionIndex) => {
+                const partition = { partitionIndex: r.readInt32(), errorCode: r.readInt16() };
+                if (partition.errorCode !== 0) {
+                    errors.push([`/topics/${topicIndex}/partitions/${partitionIndex}`, [partition.errorCode, null]]);
+                }
+                return partition;
+            }, false, false)
+        }), false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(28, 2, createRequest, parseResponse, false, false);

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

@@ -51,21 +51,25 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
     const response = {
         throttleTimeMs: reader.readInt32(),
         topics: reader.readArray((r, i) => {
-            return {
+            const topic = {
                 name: r.readString(),
                 partitions: r.readArray((r, j) => {
                     const partition = {
                         partitionIndex: r.readInt32(),
                         errorCode: r.readInt16()
                     };
+                    r.readTaggedFields();
                     if (partition.errorCode !== 0) {
                         errors.push([`/topics/${i}/partitions/${j}`, [partition.errorCode, null]]);
                     }
                     return partition;
-                })
+                }, true, false)
             };
-        })
+            r.readTaggedFields();
+            return topic;
+        }, true, false)
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

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

@@ -51,21 +51,25 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
     const response = {
         throttleTimeMs: reader.readInt32(),
         topics: reader.readArray((r, i) => {
-            return {
+            const topic = {
                 name: r.readString(),
                 partitions: r.readArray((r, j) => {
                     const partition = {
                         partitionIndex: r.readInt32(),
                         errorCode: r.readInt16()
                     };
+                    r.readTaggedFields();
                     if (partition.errorCode !== 0) {
                         errors.push([`/topics/${i}/partitions/${j}`, [partition.errorCode, null]]);
                     }
                     return partition;
-                })
+                }, true, false)
             };
-        })
+            r.readTaggedFields();
+            return topic;
+        }, true, false)
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

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

@@ -1,2 +1,5 @@
+export * as saslAuthenticateV0 from './sasl-authenticate-v0.ts';
+export * as saslAuthenticateV1 from './sasl-authenticate-v1.ts';
 export * as saslAuthenticateV2 from './sasl-authenticate-v2.ts';
+export * as saslHandshakeV0 from './sasl-handshake-v0.ts';
 export * as saslHandshakeV1 from './sasl-handshake-v1.ts';

package/dist/apis/security/index.js

@@ -1,2 +1,5 @@
+export * as saslAuthenticateV0 from "./sasl-authenticate-v0.js";
+export * as saslAuthenticateV1 from "./sasl-authenticate-v1.js";
 export * as saslAuthenticateV2 from "./sasl-authenticate-v2.js";
+export * as saslHandshakeV0 from "./sasl-handshake-v0.js";
 export * as saslHandshakeV1 from "./sasl-handshake-v1.js";

package/dist/apis/security/sasl-authenticate-v0.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-v0.js

@@ -0,0 +1,30 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  SaslAuthenticate Request (Version: 0) => auth_bytes
+    auth_bytes => BYTES
+*/
+export function createRequest(authBytes) {
+    return Writer.create().appendBytes(authBytes, false);
+}
+/*
+  SaslAuthenticate Response (Version: 0) => error_code error_message auth_bytes
+    error_code => INT16
+    error_message => NULLABLE_STRING
+    auth_bytes => BYTES
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        errorMessage: reader.readNullableString(false),
+        authBytes: reader.readBytes(false),
+        // Version 0 predates reauthentication, so expose the existing response shape with no scheduled reauthentication.
+        sessionLifetimeMs: 0n
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, response.errorMessage] }, response);
+    }
+    return response;
+}
+export const api = createAPI(36, 0, createRequest, parseResponse, false, false);

package/dist/apis/security/sasl-authenticate-v1.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-v1.js

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

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

@@ -22,6 +22,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         authBytes: reader.readBytes(),
         sessionLifetimeMs: reader.readInt64()
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, response.errorMessage] }, response);
     }

package/dist/apis/security/sasl-handshake-v0.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-v0.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: 0) => 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, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(17, 0, createRequest, parseResponse, false, false);

package/dist/apis/tagged-fields.d.ts

@@ -0,0 +1,7 @@
+import { Reader } from '../protocol/reader.ts';
+export type TaggedFieldHandler = (reader: Reader) => void;
+export type TaggedFieldHandlers = Readonly<Record<number, TaggedFieldHandler>>;
+/**
+ * Decodes known flexible-version tagged fields and skips fields the caller does not handle.
+ */
+export declare function readKnownTaggedFields(reader: Reader, handlers: TaggedFieldHandlers): void;

package/dist/apis/tagged-fields.js

@@ -0,0 +1,27 @@
+import { Reader } from "../protocol/reader.js";
+/**
+ * Decodes known flexible-version tagged fields and skips fields the caller does not handle.
+ */
+export function readKnownTaggedFields(reader, handlers) {
+    const count = reader.readUnsignedVarInt();
+    for (let index = 0; index < count; index++) {
+        const tag = reader.readUnsignedVarInt();
+        const size = reader.readUnsignedVarInt();
+        if (size > reader.remaining) {
+            throw new RangeError(`Tagged field ${tag} declares ${size} bytes but only ${reader.remaining} remain`);
+        }
+        const handler = handlers[tag];
+        if (handler) {
+            const payload = Reader.from(reader.buffer.slice(reader.position, reader.position + size));
+            try {
+                handler(payload);
+            }
+            finally {
+                reader.skip(size);
+            }
+        }
+        else {
+            reader.skip(size);
+        }
+    }
+}

package/dist/apis/telemetry/compression-types.d.ts

@@ -0,0 +1,8 @@
+export declare const TelemetryCompressionTypes: {
+    readonly NONE: 0;
+    readonly GZIP: 1;
+    readonly SNAPPY: 2;
+    readonly LZ4: 3;
+    readonly ZSTD: 4;
+};
+export type TelemetryCompressionType = (typeof TelemetryCompressionTypes)[keyof typeof TelemetryCompressionTypes];

package/dist/apis/telemetry/compression-types.js

@@ -0,0 +1,7 @@
+export const TelemetryCompressionTypes = {
+    NONE: 0,
+    GZIP: 1,
+    SNAPPY: 2,
+    LZ4: 3,
+    ZSTD: 4
+};

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

@@ -1,13 +1,14 @@
 import { type NullableString } from '../../protocol/definitions.ts';
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type TelemetryCompressionType } from './compression-types.ts';
 export type GetTelemetrySubscriptionsRequest = Parameters<typeof createRequest>;
 export interface GetTelemetrySubscriptionsResponse {
     throttleTimeMs: number;
     errorCode: number;
     clientInstanceId: string;
     subscriptionId: number;
-    acceptedCompressionTypes: number[];
+    acceptedCompressionTypes: TelemetryCompressionType[];
     pushIntervalMs: number;
     telemetryMaxBytes: number;
     deltaTemporality: boolean;

package/dist/apis/telemetry/get-telemetry-subscriptions-v0.js

@@ -38,6 +38,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         deltaTemporality: reader.readBoolean(),
         requestedMetrics: reader.readArray(r => r.readString(), true, false)
     };
+    reader.readTaggedFields();
     if (errors.length) {
         throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
     }

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

@@ -1,3 +1,6 @@
+export { TelemetryCompressionTypes, type TelemetryCompressionType } from './compression-types.ts';
 export * as getTelemetrySubscriptionsV0 from './get-telemetry-subscriptions-v0.ts';
 export * as listClientMetricsResourcesV0 from './list-client-metrics-resources-v0.ts';
+export * as listConfigResourcesV1 from './list-config-resources-v1.ts';
+export * as listClientMetricsResourcesV1 from './list-config-resources-v1.ts';
 export * as pushTelemetryV0 from './push-telemetry-v0.ts';

package/dist/apis/telemetry/index.js

@@ -1,3 +1,6 @@
+export { TelemetryCompressionTypes } from "./compression-types.js";
 export * as getTelemetrySubscriptionsV0 from "./get-telemetry-subscriptions-v0.js";
 export * as listClientMetricsResourcesV0 from "./list-client-metrics-resources-v0.js";
+export * as listConfigResourcesV1 from "./list-config-resources-v1.js";
+export * as listClientMetricsResourcesV1 from "./list-config-resources-v1.js";
 export * as pushTelemetryV0 from "./push-telemetry-v0.js";

package/dist/apis/telemetry/list-client-metrics-resources-v0.d.ts

@@ -1,14 +1,16 @@
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type ConfigResourceTypeValue } from '../enumerations.ts';
 export type ListClientMetricsResourcesRequest = Parameters<typeof createRequest>;
 export interface ListClientMetricsResourcesResource {
-    name: string;
+    resourceName: string;
+    resourceType: ConfigResourceTypeValue;
 }
 export interface ListClientMetricsResourcesResponse {
     throttleTimeMs: number;
     errorCode: number;
-    clientMetricsResources: ListClientMetricsResourcesResource[];
+    configResources: ListClientMetricsResourcesResource[];
 }
-export declare function createRequest(): Writer;
+export declare function createRequest(_resourceTypes?: ConfigResourceTypeValue[]): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListClientMetricsResourcesResponse;
-export declare const api: import("../definitions.ts").API<[], ListClientMetricsResourcesResponse>;
+export declare const api: import("../definitions.ts").API<[_resourceTypes?: ConfigResourceTypeValue[] | undefined], ListClientMetricsResourcesResponse>;

package/dist/apis/telemetry/list-client-metrics-resources-v0.js

@@ -1,29 +1,34 @@
 import { ResponseError } from "../../errors.js";
 import { Writer } from "../../protocol/writer.js";
 import { createAPI } from "../definitions.js";
+import { ConfigResourceTypes } from "../enumerations.js";
 /*
   ListClientMetricsResources Request (Version: 0) => TAG_BUFFER
 */
-export function createRequest() {
+export function createRequest(_resourceTypes) {
     return Writer.create().appendTaggedFields();
 }
 /*
-ListClientMetricsResources Response (Version: 0) => throttle_time_ms error_code [client_metrics_resources] TAG_BUFFER
+ ListClientMetricsResources Response (Version: 0) => throttle_time_ms error_code [config_resources] TAG_BUFFER
   throttle_time_ms => INT32
   error_code => INT16
-  client_metrics_resources => name TAG_BUFFER
-    name => COMPACT_STRING
+  config_resources => resource_name TAG_BUFFER
+    resource_name => COMPACT_STRING
 */
 export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
     const response = {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16(),
-        clientMetricsResources: reader.readArray(r => {
-            return {
-                name: r.readString()
+        configResources: reader.readArray(r => {
+            const resource = {
+                resourceName: r.readString(),
+                resourceType: ConfigResourceTypes.CLIENT_METRICS
             };
-        })
+            r.readTaggedFields();
+            return resource;
+        }, true, false)
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }

package/dist/apis/telemetry/list-config-resources-v1.d.ts

@@ -0,0 +1,16 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+import { type ConfigResourceTypeValue } from '../enumerations.ts';
+export type ListConfigResourcesRequest = Parameters<typeof createRequest>;
+export interface ListConfigResourcesResource {
+    resourceName: string;
+    resourceType: ConfigResourceTypeValue;
+}
+export interface ListConfigResourcesResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    configResources: ListConfigResourcesResource[];
+}
+export declare function createRequest(resourceTypes?: ConfigResourceTypeValue[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ListConfigResourcesResponse;
+export declare const api: import("../definitions.ts").API<[resourceTypes?: ConfigResourceTypeValue[] | undefined], ListConfigResourcesResponse>;

package/dist/apis/telemetry/list-config-resources-v1.js

@@ -0,0 +1,38 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  ListConfigResources Request (Version: 1) => [resource_types] TAG_BUFFER
+    resource_types => INT8
+*/
+export function createRequest(resourceTypes = []) {
+    return Writer.create().appendArray(resourceTypes, (w, resourceType) => w.appendInt8(resourceType), true, false).appendTaggedFields();
+}
+/*
+ ListConfigResources Response (Version: 1) => throttle_time_ms error_code [config_resources] TAG_BUFFER
+   throttle_time_ms => INT32
+   error_code => INT16
+   config_resources => resource_name resource_type TAG_BUFFER
+     resource_name => COMPACT_STRING
+     resource_type => INT8
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: reader.readInt16(),
+        configResources: reader.readArray(r => {
+            const resource = {
+                resourceName: r.readString(),
+                resourceType: r.readInt8()
+            };
+            r.readTaggedFields();
+            return resource;
+        }, true, false)
+    };
+    reader.readTaggedFields();
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
+    }
+    return response;
+}
+export const api = createAPI(74, 1, createRequest, parseResponse);

package/dist/apis/telemetry/push-telemetry-v0.d.ts

@@ -1,10 +1,11 @@
 import { type Reader } from '../../protocol/reader.ts';
 import { Writer } from '../../protocol/writer.ts';
+import { type TelemetryCompressionType } from './compression-types.ts';
 export type PushTelemetryRequest = Parameters<typeof createRequest>;
 export interface PushTelemetryResponse {
     throttleTimeMs: number;
     errorCode: number;
 }
-export declare function createRequest(clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer): Writer;
+export declare function createRequest(clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: TelemetryCompressionType, metrics: Buffer): Writer;
 export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): PushTelemetryResponse;
-export declare const api: import("../definitions.ts").API<[clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: number, metrics: Buffer<ArrayBufferLike>], PushTelemetryResponse>;
+export declare const api: import("../definitions.ts").API<[clientInstanceId: string, subscriptionId: number, terminating: boolean, compressionType: TelemetryCompressionType, metrics: Buffer<ArrayBufferLike>], PushTelemetryResponse>;

package/dist/apis/telemetry/push-telemetry-v0.js

@@ -28,6 +28,7 @@ export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
         throttleTimeMs: reader.readInt32(),
         errorCode: reader.readInt16()
     };
+    reader.readTaggedFields();
     if (response.errorCode !== 0) {
         throw new ResponseError(apiKey, apiVersion, { '/': [response.errorCode, null] }, response);
     }