@platformatic/kafka 2.10.0 → 2.11.0

package/dist/apis/consumer/fetch-v4.js

@@ -0,0 +1,87 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatches } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 4) => replica_id max_wait_ms min_bytes max_bytes isolation_level [topics]
+    replica_id => INT32
+    max_wait_ms => INT32
+    min_bytes => INT32
+    max_bytes => INT32
+    isolation_level => INT8
+    topics => topic [partitions]
+      topic => STRING
+      partitions => partition fetch_offset partition_max_bytes
+        partition => INT32
+        fetch_offset => INT64
+        partition_max_bytes => INT32
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, _sessionId, _sessionEpoch, topics, _forgottenTopicsData, _rackId) {
+    return Writer.create()
+        .appendInt32(-1)
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.topicId, false).appendArray(topic.partitions, (w, partition) => w.appendInt32(partition.partition).appendInt64(partition.fetchOffset).appendInt32(partition.partitionMaxBytes), false, false);
+    }, false, false);
+}
+/*
+  Fetch Response (Version: 4) => throttle_time_ms [responses]
+    throttle_time_ms => INT32
+    responses => topic [partitions]
+      topic => STRING
+      partitions => partition_index error_code high_watermark last_stable_offset [aborted_transactions] records
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        aborted_transactions => producer_id first_offset
+          producer_id => INT64
+          first_offset => INT64
+        records => RECORDS
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: 0,
+        sessionId: 0,
+        responses: reader.readArray((r, i) => ({
+            topicId: r.readString(false),
+            partitions: r.readArray((r, j) => {
+                const partition = {
+                    partitionIndex: r.readInt32(),
+                    errorCode: r.readInt16(),
+                    highWatermark: r.readInt64(),
+                    lastStableOffset: r.readInt64(),
+                    logStartOffset: -1n,
+                    abortedTransactions: r.readNullableArray(r => ({ producerId: r.readInt64(), firstOffset: r.readInt64() }), false, false),
+                    records: null,
+                    preferredReadReplica: -1
+                };
+                if (partition.errorCode !== 0) {
+                    errors.push([`/responses/${i}/partitions/${j}`, [partition.errorCode, null]]);
+                }
+                const records = r.readNullableBytes(false);
+                if (records === null) {
+                    partition.records = null;
+                }
+                else if (records.length > 0) {
+                    partition.records = readRecordsBatches(Reader.from(records));
+                }
+                else {
+                    partition.records = [];
+                }
+                return partition;
+            }, false, false)
+        }), false, false)
+    };
+    if (errors.length > 0) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 4, createRequest, parseResponse, false, false);

package/dist/apis/consumer/fetch-v5.d.ts

@@ -0,0 +1,51 @@
+import { Reader } from '../../protocol/reader.ts';
+import { type RecordsBatch } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface FetchRequestPartition {
+    partition: number;
+    currentLeaderEpoch: number;
+    fetchOffset: bigint;
+    lastFetchedEpoch: number;
+    partitionMaxBytes: number;
+}
+export interface FetchRequestTopic {
+    topicId: string;
+    partitions: FetchRequestPartition[];
+}
+export type FetchRequestForgottenTopicsData = {
+    topicId: string; /** @deprecated Use topicId instead. */
+    topic?: string;
+    partitions: number[];
+} | {
+    topic: string;
+    topicId?: never;
+    partitions: number[];
+};
+export type FetchRequest = Parameters<typeof createRequest>;
+export interface FetchResponsePartitionAbortedTransaction {
+    producerId: bigint;
+    firstOffset: bigint;
+}
+export interface FetchResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    highWatermark: bigint;
+    lastStableOffset: bigint;
+    logStartOffset: bigint;
+    abortedTransactions: FetchResponsePartitionAbortedTransaction[] | null;
+    preferredReadReplica: number;
+    records: RecordsBatch[] | null;
+}
+export interface FetchResponseTopic {
+    topicId: string;
+    partitions: FetchResponsePartition[];
+}
+export interface FetchResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    sessionId: number;
+    responses: FetchResponseTopic[];
+}
+export declare function createRequest(maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, _sessionId: number, _sessionEpoch: number, topics: FetchRequestTopic[], _forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FetchResponse;
+export declare const api: import("../definitions.ts").API<[maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, _sessionId: number, _sessionEpoch: number, topics: FetchRequestTopic[], _forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string], FetchResponse>;

package/dist/apis/consumer/fetch-v5.js

@@ -0,0 +1,89 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatches } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 5) => replica_id max_wait_ms min_bytes max_bytes isolation_level [topics]
+    replica_id => INT32
+    max_wait_ms => INT32
+    min_bytes => INT32
+    max_bytes => INT32
+    isolation_level => INT8
+    topics => topic [partitions]
+      topic => STRING
+      partitions => partition fetch_offset log_start_offset partition_max_bytes
+        partition => INT32
+        fetch_offset => INT64
+        log_start_offset => INT64
+        partition_max_bytes => INT32
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, _sessionId, _sessionEpoch, topics, _forgottenTopicsData, _rackId) {
+    return Writer.create()
+        .appendInt32(-1)
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendArray(topics, (w, topic) => {
+        w.appendString(topic.topicId, false).appendArray(topic.partitions, (w, partition) => w.appendInt32(partition.partition).appendInt64(partition.fetchOffset).appendInt64(-1n).appendInt32(partition.partitionMaxBytes), false, false);
+    }, false, false);
+}
+/*
+  Fetch Response (Version: 5) => throttle_time_ms [responses]
+    throttle_time_ms => INT32
+    responses => topic [partitions]
+      topic => STRING
+      partitions => partition_index error_code high_watermark last_stable_offset log_start_offset [aborted_transactions] records
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        log_start_offset => INT64
+        aborted_transactions => producer_id first_offset
+          producer_id => INT64
+          first_offset => INT64
+        records => RECORDS
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        errorCode: 0,
+        sessionId: 0,
+        responses: reader.readArray((r, i) => ({
+            topicId: r.readString(false),
+            partitions: r.readArray((r, j) => {
+                const partition = {
+                    partitionIndex: r.readInt32(),
+                    errorCode: r.readInt16(),
+                    highWatermark: r.readInt64(),
+                    lastStableOffset: r.readInt64(),
+                    logStartOffset: r.readInt64(),
+                    abortedTransactions: r.readNullableArray(r => ({ producerId: r.readInt64(), firstOffset: r.readInt64() }), false, false),
+                    records: null,
+                    preferredReadReplica: -1
+                };
+                if (partition.errorCode !== 0) {
+                    errors.push([`/responses/${i}/partitions/${j}`, [partition.errorCode, null]]);
+                }
+                const records = r.readNullableBytes(false);
+                if (records === null) {
+                    partition.records = null;
+                }
+                else if (records.length > 0) {
+                    partition.records = readRecordsBatches(Reader.from(records));
+                }
+                else {
+                    partition.records = [];
+                }
+                return partition;
+            }, false, false)
+        }), false, false)
+    };
+    if (errors.length > 0) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 5, createRequest, parseResponse, false, false);

package/dist/apis/consumer/fetch-v6.d.ts

@@ -0,0 +1,51 @@
+import { Reader } from '../../protocol/reader.ts';
+import { type RecordsBatch } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface FetchRequestPartition {
+    partition: number;
+    currentLeaderEpoch: number;
+    fetchOffset: bigint;
+    lastFetchedEpoch: number;
+    partitionMaxBytes: number;
+}
+export interface FetchRequestTopic {
+    topicId: string;
+    partitions: FetchRequestPartition[];
+}
+export type FetchRequestForgottenTopicsData = {
+    topicId: string; /** @deprecated Use topicId instead. */
+    topic?: string;
+    partitions: number[];
+} | {
+    topic: string;
+    topicId?: never;
+    partitions: number[];
+};
+export type FetchRequest = Parameters<typeof createRequest>;
+export interface FetchResponsePartitionAbortedTransaction {
+    producerId: bigint;
+    firstOffset: bigint;
+}
+export interface FetchResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    highWatermark: bigint;
+    lastStableOffset: bigint;
+    logStartOffset: bigint;
+    abortedTransactions: FetchResponsePartitionAbortedTransaction[] | null;
+    preferredReadReplica: number;
+    records: RecordsBatch[] | null;
+}
+export interface FetchResponseTopic {
+    topicId: string;
+    partitions: FetchResponsePartition[];
+}
+export type FetchResponse = {
+    throttleTimeMs: number;
+    errorCode: number;
+    sessionId: number;
+    responses: FetchResponseTopic[];
+};
+export declare function createRequest(maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, _sessionId: number, _sessionEpoch: number, topics: FetchRequestTopic[], _forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FetchResponse;
+export declare const api: import("../definitions.ts").API<[maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, _sessionId: number, _sessionEpoch: number, topics: FetchRequestTopic[], _forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string], FetchResponse>;

package/dist/apis/consumer/fetch-v6.js

@@ -0,0 +1,99 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatches } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 6) => replica_id max_wait_ms min_bytes max_bytes isolation_level [topics]
+  replica_id => INT32
+  max_wait_ms => INT32
+  min_bytes => INT32
+  max_bytes => INT32
+  isolation_level => INT8
+  topics => topic_id [partitions]
+    topic => STRING
+    partitions => partition fetch_offset log_start_offset partition_max_bytes
+      partition => INT32
+      fetch_offset => INT64
+      log_start_offset => INT64
+      partition_max_bytes => INT32
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, _sessionId, _sessionEpoch, topics, _forgottenTopicsData, _rackId) {
+    return Writer.create()
+        .appendInt32(-1)
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.topicId, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partition).appendInt64(p.fetchOffset).appendInt64(-1n).appendInt32(p.partitionMaxBytes);
+        }, false, false);
+    }, false, false);
+}
+/*
+  Fetch Response (Version: 6) => throttle_time_ms [responses]
+    throttle_time_ms => INT32
+    responses => topic [partitions]
+      topic => STRING
+      partitions => partition_index error_code high_watermark last_stable_offset log_start_offset [aborted_transactions] records
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        log_start_offset => INT64
+        aborted_transactions => producer_id first_offset
+          producer_id => INT64
+          first_offset => INT64
+        records => RECORDS
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const response = {
+        throttleTimeMs,
+        errorCode: 0,
+        sessionId: 0,
+        responses: reader.readArray((r, i) => {
+            return {
+                topicId: r.readString(false),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        highWatermark: r.readInt64(),
+                        lastStableOffset: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        abortedTransactions: r.readNullableArray(r => {
+                            return {
+                                producerId: r.readInt64(),
+                                firstOffset: r.readInt64()
+                            };
+                        }, false, false),
+                        records: null,
+                        preferredReadReplica: -1
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/responses/${i}/partitions/${j}`, [partition.errorCode, null]]);
+                    }
+                    const records = r.readNullableBytes(false);
+                    if (records === null) {
+                        partition.records = null;
+                    }
+                    else if (records.length > 0) {
+                        partition.records = readRecordsBatches(Reader.from(records));
+                    }
+                    else {
+                        partition.records = [];
+                    }
+                    return partition;
+                }, false, false)
+            };
+        }, false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 6, createRequest, parseResponse, false, false);

package/dist/apis/consumer/fetch-v7.d.ts

@@ -0,0 +1,51 @@
+import { Reader } from '../../protocol/reader.ts';
+import { type RecordsBatch } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface FetchRequestPartition {
+    partition: number;
+    currentLeaderEpoch: number;
+    fetchOffset: bigint;
+    lastFetchedEpoch: number;
+    partitionMaxBytes: number;
+}
+export interface FetchRequestTopic {
+    topicId: string;
+    partitions: FetchRequestPartition[];
+}
+export type FetchRequestForgottenTopicsData = {
+    topicId: string; /** @deprecated Use topicId instead. */
+    topic?: string;
+    partitions: number[];
+} | {
+    topic: string;
+    topicId?: never;
+    partitions: number[];
+};
+export type FetchRequest = Parameters<typeof createRequest>;
+export interface FetchResponsePartitionAbortedTransaction {
+    producerId: bigint;
+    firstOffset: bigint;
+}
+export interface FetchResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    highWatermark: bigint;
+    lastStableOffset: bigint;
+    logStartOffset: bigint;
+    abortedTransactions: FetchResponsePartitionAbortedTransaction[] | null;
+    preferredReadReplica: number;
+    records: RecordsBatch[] | null;
+}
+export interface FetchResponseTopic {
+    topicId: string;
+    partitions: FetchResponsePartition[];
+}
+export type FetchResponse = {
+    throttleTimeMs: number;
+    errorCode: number;
+    sessionId: number;
+    responses: FetchResponseTopic[];
+};
+export declare function createRequest(maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FetchResponse;
+export declare const api: import("../definitions.ts").API<[maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string], FetchResponse>;

package/dist/apis/consumer/fetch-v7.js

@@ -0,0 +1,117 @@
+import { ResponseError } from "../../errors.js";
+import { Reader } from "../../protocol/reader.js";
+import { readRecordsBatches } from "../../protocol/records.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  Fetch Request (Version: 7) => replica_id max_wait_ms min_bytes max_bytes isolation_level session_id session_epoch [topics] [forgotten_topics_data]
+  replica_id => INT32
+  max_wait_ms => INT32
+  min_bytes => INT32
+  max_bytes => INT32
+  isolation_level => INT8
+  session_id => INT32
+  session_epoch => INT32
+  topics => topic_id [partitions]
+    topic => STRING
+    partitions => partition fetch_offset log_start_offset partition_max_bytes
+      partition => INT32
+      fetch_offset => INT64
+      log_start_offset => INT64
+      partition_max_bytes => INT32
+  forgotten_topics_data => topic [partitions]
+    topic => STRING
+    partitions => INT32
+*/
+export function createRequest(maxWaitMs, minBytes, maxBytes, isolationLevel, sessionId, sessionEpoch, topics, forgottenTopicsData, _rackId) {
+    return Writer.create()
+        .appendInt32(-1)
+        .appendInt32(maxWaitMs)
+        .appendInt32(minBytes)
+        .appendInt32(maxBytes)
+        .appendInt8(isolationLevel)
+        .appendInt32(sessionId)
+        .appendInt32(sessionEpoch)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.topicId, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partition).appendInt64(p.fetchOffset).appendInt64(-1n).appendInt32(p.partitionMaxBytes);
+        }, false, false);
+    }, false, false)
+        .appendArray(forgottenTopicsData, (w, t) => {
+        w.appendString(t.topicId ?? t.topic, false).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p);
+        }, false, false);
+    }, false, false);
+}
+/*
+  Fetch Response (Version: 7) => throttle_time_ms error_code session_id [responses]
+    throttle_time_ms => INT32
+    error_code => INT16
+    session_id => INT32
+    responses => topic [partitions]
+      topic => STRING
+      partitions => partition_index error_code high_watermark last_stable_offset log_start_offset [aborted_transactions] records
+        partition_index => INT32
+        error_code => INT16
+        high_watermark => INT64
+        last_stable_offset => INT64
+        log_start_offset => INT64
+        aborted_transactions => producer_id first_offset
+          producer_id => INT64
+          first_offset => INT64
+        records => RECORDS
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const throttleTimeMs = reader.readInt32();
+    const errorCode = reader.readInt16();
+    if (errorCode !== 0) {
+        errors.push(['/', [errorCode, null]]);
+    }
+    const response = {
+        throttleTimeMs,
+        errorCode,
+        sessionId: reader.readInt32(),
+        responses: reader.readArray((r, i) => {
+            return {
+                topicId: r.readString(false),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        highWatermark: r.readInt64(),
+                        lastStableOffset: r.readInt64(),
+                        logStartOffset: r.readInt64(),
+                        abortedTransactions: r.readNullableArray(r => {
+                            return {
+                                producerId: r.readInt64(),
+                                firstOffset: r.readInt64()
+                            };
+                        }, false, false),
+                        records: null,
+                        preferredReadReplica: -1
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/responses/${i}/partitions/${j}`, [partition.errorCode, null]]);
+                    }
+                    const records = r.readNullableBytes(false);
+                    if (records === null) {
+                        partition.records = null;
+                    }
+                    else if (records.length > 0) {
+                        partition.records = readRecordsBatches(Reader.from(records));
+                    }
+                    else {
+                        partition.records = [];
+                    }
+                    return partition;
+                }, false, false)
+            };
+        }, false, false)
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(1, 7, createRequest, parseResponse, false, false);

package/dist/apis/consumer/fetch-v8.d.ts

@@ -0,0 +1,51 @@
+import { Reader } from '../../protocol/reader.ts';
+import { type RecordsBatch } from '../../protocol/records.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface FetchRequestPartition {
+    partition: number;
+    currentLeaderEpoch: number;
+    fetchOffset: bigint;
+    lastFetchedEpoch: number;
+    partitionMaxBytes: number;
+}
+export interface FetchRequestTopic {
+    topicId: string;
+    partitions: FetchRequestPartition[];
+}
+export type FetchRequestForgottenTopicsData = {
+    topicId: string; /** @deprecated Use topicId instead. */
+    topic?: string;
+    partitions: number[];
+} | {
+    topic: string;
+    topicId?: never;
+    partitions: number[];
+};
+export type FetchRequest = Parameters<typeof createRequest>;
+export interface FetchResponsePartitionAbortedTransaction {
+    producerId: bigint;
+    firstOffset: bigint;
+}
+export interface FetchResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    highWatermark: bigint;
+    lastStableOffset: bigint;
+    logStartOffset: bigint;
+    abortedTransactions: FetchResponsePartitionAbortedTransaction[] | null;
+    preferredReadReplica: number;
+    records: RecordsBatch[] | null;
+}
+export interface FetchResponseTopic {
+    topicId: string;
+    partitions: FetchResponsePartition[];
+}
+export type FetchResponse = {
+    throttleTimeMs: number;
+    errorCode: number;
+    sessionId: number;
+    responses: FetchResponseTopic[];
+};
+export declare function createRequest(maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): FetchResponse;
+export declare const api: import("../definitions.ts").API<[maxWaitMs: number, minBytes: number, maxBytes: number, isolationLevel: number, sessionId: number, sessionEpoch: number, topics: FetchRequestTopic[], forgottenTopicsData: FetchRequestForgottenTopicsData[], _rackId: string], FetchResponse>;