@platformatic/kafka 0.1.0

package/dist/apis/admin/alter-partition-reassignments.js

@@ -0,0 +1,68 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  AlterPartitionReassignments Request (Version: 0) => timeout_ms [topics] TAG_BUFFER
+    timeout_ms => INT32
+    topics => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index [replicas] TAG_BUFFER
+        partition_index => INT32
+        replicas => INT32
+*/
+export function createRequest(timeoutMs, topics) {
+    return Writer.create()
+        .appendInt32(timeoutMs)
+        .appendArray(topics, (w, t) => {
+        w.appendString(t.name).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex).appendArray(p.replicas, (w, r) => w.appendInt32(r), true, false);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  AlterPartitionReassignments Response (Version: 0) => throttle_time_ms error_code error_message [responses] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+    responses => name [partitions] TAG_BUFFER
+      name => COMPACT_STRING
+      partitions => partition_index error_code error_message TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+        error_message => COMPACT_NULLABLE_STRING
+*/
+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,
+        errorMessage: reader.readNullableString(),
+        responses: reader.readArray((r, i) => {
+            return {
+                name: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        errorMessage: r.readNullableString()
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`responses/${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(45, 0, createRequest, parseResponse);

package/dist/apis/admin/alter-partition.d.ts

@@ -0,0 +1,39 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface AlterPartitionRequestISR {
+    brokerId: number;
+    brokerEpoch: bigint;
+}
+export interface AlterPartitionRequestPartition {
+    partitionIndex: number;
+    leaderEpoch: number;
+    newIsrWithEpochs: AlterPartitionRequestISR[];
+    leaderRecoveryState: number;
+    partitionEpoch: number;
+}
+export interface AlterPartitionRequestTopic {
+    topicId: string;
+    partitions: AlterPartitionRequestPartition[];
+}
+export type AlterPartitionRequest = Parameters<typeof createRequest>;
+export interface AlterPartitionResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+    leaderId: number;
+    leaderEpoch: number;
+    isr: number;
+    leaderRecoveryState: number;
+    partitionEpoch: number;
+}
+export interface AlterPartitionResponseTopic {
+    topicId: string;
+    partitions: AlterPartitionResponsePartition[];
+}
+export interface AlterPartitionResponse {
+    throttleTimeMs: number;
+    errorCode: number;
+    topics: AlterPartitionResponseTopic[];
+}
+export declare function createRequest(brokerId: number, brokerEpoch: bigint, topic: AlterPartitionRequestTopic[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterPartitionResponse;
+export declare const api: import("../definitions.ts").API<[brokerId: number, brokerEpoch: bigint, topic: AlterPartitionRequestTopic[]], AlterPartitionResponse>;

package/dist/apis/admin/alter-partition.js

@@ -0,0 +1,87 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  AlterPartition Request (Version: 3) => broker_id broker_epoch [topics] TAG_BUFFER
+    broker_id => INT32
+    broker_epoch => INT64
+    topics => topic_id [partitions] TAG_BUFFER
+      topic_id => UUID
+      partitions => partition_index leader_epoch [new_isr_with_epochs] leader_recovery_state partition_epoch TAG_BUFFER
+        partition_index => INT32
+        leader_epoch => INT32
+        new_isr_with_epochs => broker_id broker_epoch TAG_BUFFER
+          broker_id => INT32
+          broker_epoch => INT64
+        leader_recovery_state => INT8
+        partition_epoch => INT32
+*/
+export function createRequest(brokerId, brokerEpoch, topic) {
+    return Writer.create()
+        .appendInt32(brokerId)
+        .appendInt64(brokerEpoch)
+        .appendArray(topic, (w, t) => {
+        w.appendString(t.topicId).appendArray(t.partitions, (w, p) => {
+            w.appendInt32(p.partitionIndex)
+                .appendInt32(p.leaderEpoch)
+                .appendArray(p.newIsrWithEpochs, (w, n) => {
+                w.appendInt32(n.brokerId).appendInt64(n.brokerEpoch);
+            })
+                .appendInt8(p.leaderRecoveryState)
+                .appendInt32(p.partitionEpoch);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  AlterPartition Response (Version: 3) => throttle_time_ms error_code [topics] TAG_BUFFER
+    throttle_time_ms => INT32
+    error_code => INT16
+    topics => topic_id [partitions] TAG_BUFFER
+      topic_id => UUID
+      partitions => partition_index error_code leader_id leader_epoch [isr] leader_recovery_state partition_epoch TAG_BUFFER
+        partition_index => INT32
+        error_code => INT16
+        leader_id => INT32
+        leader_epoch => INT32
+        isr => INT32
+        leader_recovery_state => INT8
+        partition_epoch => INT32
+*/
+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,
+        topics: reader.readArray((r, i) => {
+            return {
+                topicId: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16(),
+                        leaderId: r.readInt32(),
+                        leaderEpoch: r.readInt32(),
+                        isr: r.readInt32(),
+                        leaderRecoveryState: r.readInt8(),
+                        partitionEpoch: r.readInt32()
+                    };
+                    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(56, 3, createRequest, parseResponse);

package/dist/apis/admin/alter-replica-log-dirs.d.ts

@@ -0,0 +1,26 @@
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface AlterReplicaLogDirsRequestTopic {
+    name: string;
+    partitions: number[];
+}
+export interface AlterReplicaLogDirsRequestDir {
+    path: string;
+    topics: AlterReplicaLogDirsRequestTopic[];
+}
+export type AlterReplicaLogDirsRequest = Parameters<typeof createRequest>;
+export interface AlterReplicaLogDirsResponsePartition {
+    partitionIndex: number;
+    errorCode: number;
+}
+export interface AlterReplicaLogDirsResponseResult {
+    topicName: string;
+    partitions: AlterReplicaLogDirsResponsePartition[];
+}
+export interface AlterReplicaLogDirsResponse {
+    throttleTimeMs?: number;
+    results: AlterReplicaLogDirsResponseResult[];
+}
+export declare function createRequest(dirs: AlterReplicaLogDirsRequestDir[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterReplicaLogDirsResponse;
+export declare const api: import("../definitions.ts").API<[dirs: AlterReplicaLogDirsRequestDir[]], AlterReplicaLogDirsResponse>;

package/dist/apis/admin/alter-replica-log-dirs.js

@@ -0,0 +1,55 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  AlterReplicaLogDirs Request (Version: 2) => [dirs] TAG_BUFFER
+    dirs => path [topics] TAG_BUFFER
+      path => COMPACT_STRING
+      topics => name [partitions] TAG_BUFFER
+        name => COMPACT_STRING
+        partitions => INT32
+*/
+export function createRequest(dirs) {
+    return Writer.create()
+        .appendArray(dirs, (w, d) => {
+        w.appendString(d.path).appendArray(d.topics, (w, t) => {
+            w.appendString(t.name).appendArray(t.partitions, (w, p) => w.appendInt32(p), true, false);
+        });
+    })
+        .appendTaggedFields();
+}
+/*
+  AlterReplicaLogDirs Response (Version: 2) => throttle_time_ms [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    results => topic_name [partitions] TAG_BUFFER
+      topic_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(),
+        results: reader.readArray((r, i) => {
+            return {
+                topicName: r.readString(),
+                partitions: r.readArray((r, j) => {
+                    const partition = {
+                        partitionIndex: r.readInt32(),
+                        errorCode: r.readInt16()
+                    };
+                    if (partition.errorCode !== 0) {
+                        errors.push([`/results/${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(34, 2, createRequest, parseResponse);

package/dist/apis/admin/alter-user-scram-credentials.d.ts

@@ -0,0 +1,27 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface AlterUserScramCredentialsRequestDeletions {
+    name: string;
+    mechanism: number;
+}
+export interface AlterUserScramCredentialsRequestUpsertions {
+    name: string;
+    mechanism: number;
+    iterations: number;
+    salt: Buffer;
+    saltedPassword: Buffer;
+}
+export type AlterUserScramCredentialsRequest = Parameters<typeof createRequest>;
+export interface AlterUserScramCredentialsResponseResult {
+    user: string;
+    errorCode: number;
+    errorMessage: NullableString;
+}
+export interface AlterUserScramCredentialsResponse {
+    throttleTimeMs: number;
+    results: AlterUserScramCredentialsResponseResult[];
+}
+export declare function createRequest(deletions: AlterUserScramCredentialsRequestDeletions[], upsertions: AlterUserScramCredentialsRequestUpsertions[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): AlterUserScramCredentialsResponse;
+export declare const api: import("../definitions.ts").API<[deletions: AlterUserScramCredentialsRequestDeletions[], upsertions: AlterUserScramCredentialsRequestUpsertions[]], AlterUserScramCredentialsResponse>;

package/dist/apis/admin/alter-user-scram-credentials.js

@@ -0,0 +1,60 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  AlterUserScramCredentials Request (Version: 0) => [deletions] [upsertions] TAG_BUFFER
+    deletions => name mechanism TAG_BUFFER
+      name => COMPACT_STRING
+      mechanism => INT8
+    upsertions => name mechanism iterations salt salted_password TAG_BUFFER
+      name => COMPACT_STRING
+      mechanism => INT8
+      iterations => INT32
+      salt => COMPACT_BYTES
+      salted_password => COMPACT_BYTES
+*/
+export function createRequest(deletions, upsertions) {
+    return Writer.create()
+        .appendArray(deletions, (w, d) => {
+        w.appendString(d.name).appendInt8(d.mechanism);
+    })
+        .appendArray(upsertions, (w, u) => {
+        w.appendString(u.name)
+            .appendInt8(u.mechanism)
+            .appendInt32(u.iterations)
+            .appendBytes(u.salt)
+            .appendBytes(u.saltedPassword);
+    })
+        .appendTaggedFields()
+        .appendTaggedFields();
+}
+/*
+  AlterUserScramCredentials Response (Version: 0) => throttle_time_ms [results] TAG_BUFFER
+    throttle_time_ms => INT32
+    results => user error_code error_message TAG_BUFFER
+      user => COMPACT_STRING
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        results: reader.readArray((r, i) => {
+            const result = {
+                user: r.readString(),
+                errorCode: r.readInt16(),
+                errorMessage: r.readNullableString()
+            };
+            if (result.errorCode !== 0) {
+                errors.push([`/results/${i}`, result.errorCode]);
+            }
+            return result;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(51, 0, createRequest, parseResponse);

package/dist/apis/admin/consumer-group-describe.d.ts

@@ -0,0 +1,41 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export type ConsumerGroupDescribeRequest = Parameters<typeof createRequest>;
+export interface ConsumerGroupDescribeResponseMemberTopic {
+    topicId: string;
+    topicName: string;
+    partitions: number[];
+}
+export interface ConsumerGroupDescribeResponseMemberAssignment {
+    topicPartitions: ConsumerGroupDescribeResponseMemberTopic[];
+}
+export interface ConsumerGroupDescribeResponseMember {
+    memberId: string;
+    instanceId: NullableString;
+    rackId: NullableString;
+    memberEpoch: number;
+    clientId: string;
+    clientHost: string;
+    subscribedTopicNames: string;
+    subscribedTopicRegex: NullableString;
+    assignment: ConsumerGroupDescribeResponseMemberAssignment;
+    targetAssignment: ConsumerGroupDescribeResponseMemberAssignment;
+}
+export interface ConsumerGroupDescribeResponseGroup {
+    errorCode: number;
+    errorMessage: NullableString;
+    groupId: string;
+    groupState: string;
+    groupEpoch: number;
+    assignmentEpoch: number;
+    assignorName: string;
+    members: ConsumerGroupDescribeResponseMember[];
+}
+export interface ConsumerGroupDescribeResponse {
+    throttleTimeMs: number;
+    groups: ConsumerGroupDescribeResponseGroup[];
+}
+export declare function createRequest(groupIds: string[], includeAuthorizedOperations: boolean): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): ConsumerGroupDescribeResponse;
+export declare const api: import("../definitions.ts").API<[groupIds: string[], includeAuthorizedOperations: boolean], ConsumerGroupDescribeResponse>;

package/dist/apis/admin/consumer-group-describe.js

@@ -0,0 +1,103 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+ConsumerGroupDescribe Request (Version: 0) => [group_ids] include_authorized_operations TAG_BUFFER
+  group_ids => COMPACT_STRING
+  include_authorized_operations => BOOLEAN
+*/
+export function createRequest(groupIds, includeAuthorizedOperations) {
+    return Writer.create()
+        .appendArray(groupIds, (w, r) => w.appendString(r), true, false)
+        .appendBoolean(includeAuthorizedOperations)
+        .appendTaggedFields();
+}
+/*
+  ConsumerGroupDescribe Response (Version: 0) => throttle_time_ms [groups] TAG_BUFFER
+    throttle_time_ms => INT32
+    groups => error_code error_message group_id group_state group_epoch assignment_epoch assignor_name [members] authorized_operations TAG_BUFFER
+      error_code => INT16
+      error_message => COMPACT_NULLABLE_STRING
+      group_id => COMPACT_STRING
+      group_state => COMPACT_STRING
+      group_epoch => INT32
+      assignment_epoch => INT32
+      assignor_name => COMPACT_STRING
+      members => member_id instance_id rack_id member_epoch client_id client_host [subscribed_topic_names] subscribed_topic_regex assignment target_assignment TAG_BUFFER
+        member_id => COMPACT_STRING
+        instance_id => COMPACT_NULLABLE_STRING
+        rack_id => COMPACT_NULLABLE_STRING
+        member_epoch => INT32
+        client_id => COMPACT_STRING
+        client_host => COMPACT_STRING
+        subscribed_topic_names => COMPACT_STRING
+        subscribed_topic_regex => COMPACT_NULLABLE_STRING
+        assignment => [topic_partitions] TAG_BUFFER
+          topic_partitions => topic_id topic_name [partitions] TAG_BUFFER
+            topic_id => UUID
+            topic_name => COMPACT_STRING
+            partitions => INT32
+        target_assignment => [topic_partitions] TAG_BUFFER
+          topic_partitions => topic_id topic_name [partitions] TAG_BUFFER
+            topic_id => UUID
+            topic_name => COMPACT_STRING
+            partitions => INT32
+      authorized_operations => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        groups: reader.readArray((r, i) => {
+            const errorCode = r.readInt16();
+            if (errorCode !== 0) {
+                errors.push([`/groups/${i}`, errorCode]);
+            }
+            return {
+                errorCode,
+                errorMessage: r.readNullableString(),
+                groupId: r.readString(),
+                groupState: r.readString(),
+                groupEpoch: r.readInt32(),
+                assignmentEpoch: r.readInt32(),
+                assignorName: r.readString(),
+                members: r.readArray(r => {
+                    return {
+                        memberId: r.readString(),
+                        instanceId: r.readNullableString(),
+                        rackId: r.readNullableString(),
+                        memberEpoch: r.readInt32(),
+                        clientId: r.readString(),
+                        clientHost: r.readString(),
+                        subscribedTopicNames: r.readString(),
+                        subscribedTopicRegex: r.readNullableString(),
+                        assignment: {
+                            topicPartitions: r.readArray(r => {
+                                return {
+                                    topicId: r.readUUID(),
+                                    topicName: r.readString(),
+                                    partitions: r.readArray(() => r.readInt32())
+                                };
+                            })
+                        },
+                        targetAssignment: {
+                            topicPartitions: r.readArray(r => {
+                                return {
+                                    topicId: r.readUUID(),
+                                    topicName: r.readString(),
+                                    partitions: r.readArray(() => r.readInt32())
+                                };
+                            })
+                        }
+                    };
+                }),
+                authorizedOperations: r.readInt32()
+            };
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(69, 0, createRequest, parseResponse);

package/dist/apis/admin/create-acls.d.ts

@@ -0,0 +1,24 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface CreateAclsRequestCreation {
+    resourceType: number;
+    resourceName: string;
+    resourcePatternType: number;
+    principal: string;
+    host: string;
+    operation: number;
+    permissionType: number;
+}
+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: CreateAclsRequestCreation[]): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): CreateAclsResponse;
+export declare const api: import("../definitions.ts").API<[creations: CreateAclsRequestCreation[]], CreateAclsResponse>;

package/dist/apis/admin/create-acls.js

@@ -0,0 +1,55 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+CreateAcls Request (Version: 3) => [creations] TAG_BUFFER
+  creations => resource_type resource_name resource_pattern_type principal host operation permission_type TAG_BUFFER
+    resource_type => INT8
+    resource_name => COMPACT_STRING
+    resource_pattern_type => INT8
+    principal => COMPACT_STRING
+    host => COMPACT_STRING
+    operation => INT8
+    permission_type => INT8
+*/
+export function createRequest(creations) {
+    return Writer.create()
+        .appendArray(creations, (w, c) => {
+        w.appendInt8(c.resourceType)
+            .appendString(c.resourceName)
+            .appendInt8(c.resourcePatternType)
+            .appendString(c.principal)
+            .appendString(c.host)
+            .appendInt8(c.operation)
+            .appendInt8(c.permissionType);
+    })
+        .appendTaggedFields();
+}
+/*
+CreateAcls Response (Version: 3) => throttle_time_ms [results] TAG_BUFFER
+  throttle_time_ms => INT32
+  results => error_code error_message TAG_BUFFER
+    error_code => INT16
+    error_message => COMPACT_NULLABLE_STRING
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const errors = [];
+    const response = {
+        throttleTimeMs: reader.readInt32(),
+        results: reader.readArray((r, i) => {
+            const result = {
+                errorCode: r.readInt16(),
+                errorMessage: r.readNullableString()
+            };
+            if (result.errorCode !== 0) {
+                errors.push([`/results/${i}`, result.errorCode]);
+            }
+            return result;
+        })
+    };
+    if (errors.length) {
+        throw new ResponseError(apiKey, apiVersion, Object.fromEntries(errors), response);
+    }
+    return response;
+}
+export const api = createAPI(30, 3, createRequest, parseResponse);

package/dist/apis/admin/create-delegation-token.d.ts

@@ -0,0 +1,24 @@
+import { type NullableString } from '../../protocol/definitions.ts';
+import { type Reader } from '../../protocol/reader.ts';
+import { Writer } from '../../protocol/writer.ts';
+export interface CreateDelegationTokenRequestRenewer {
+    principalType: string;
+    principalName: string;
+}
+export type CreateDelegationTokenRequest = Parameters<typeof createRequest>;
+export interface CreateDelegationTokenResponse {
+    errorCode: number;
+    principalType: string;
+    principalName: string;
+    tokenRequesterPrincipalType: string;
+    tokenRequesterPrincipalName: string;
+    issueTimestampMs: bigint;
+    expiryTimestampMs: bigint;
+    maxTimestampMs: bigint;
+    tokenId: string;
+    hmac: Buffer;
+    throttleTimeMs: number;
+}
+export declare function createRequest(ownerPrincipalType: NullableString, ownerPrincipalName: NullableString, renewers: CreateDelegationTokenRequestRenewer[], maxLifetimeMs: bigint): Writer;
+export declare function parseResponse(_correlationId: number, apiKey: number, apiVersion: number, reader: Reader): CreateDelegationTokenResponse;
+export declare const api: import("../definitions.ts").API<[ownerPrincipalType: NullableString, ownerPrincipalName: NullableString, renewers: CreateDelegationTokenRequestRenewer[], maxLifetimeMs: bigint], CreateDelegationTokenResponse>;

package/dist/apis/admin/create-delegation-token.js

@@ -0,0 +1,54 @@
+import { ResponseError } from "../../errors.js";
+import { Writer } from "../../protocol/writer.js";
+import { createAPI } from "../definitions.js";
+/*
+  CreateDelegationToken Request (Version: 3) => owner_principal_type owner_principal_name [renewers] max_lifetime_ms TAG_BUFFER
+    owner_principal_type => COMPACT_NULLABLE_STRING
+    owner_principal_name => COMPACT_NULLABLE_STRING
+    renewers => principal_type principal_name TAG_BUFFER
+      principal_type => COMPACT_STRING
+      principal_name => COMPACT_STRING
+    max_lifetime_ms => INT64
+*/
+export function createRequest(ownerPrincipalType, ownerPrincipalName, renewers, maxLifetimeMs) {
+    return Writer.create()
+        .appendString(ownerPrincipalType)
+        .appendString(ownerPrincipalName)
+        .appendArray(renewers, (w, r) => w.appendString(r.principalType).appendString(r.principalName))
+        .appendInt64(maxLifetimeMs)
+        .appendTaggedFields();
+}
+/*
+  CreateDelegationToken Response (Version: 3) => error_code principal_type principal_name token_requester_principal_type token_requester_principal_name issue_timestamp_ms expiry_timestamp_ms max_timestamp_ms token_id hmac throttle_time_ms TAG_BUFFER
+    error_code => INT16
+    principal_type => COMPACT_STRING
+    principal_name => COMPACT_STRING
+    token_requester_principal_type => COMPACT_STRING
+    token_requester_principal_name => COMPACT_STRING
+    issue_timestamp_ms => INT64
+    expiry_timestamp_ms => INT64
+    max_timestamp_ms => INT64
+    token_id => COMPACT_STRING
+    hmac => COMPACT_BYTES
+    throttle_time_ms => INT32
+*/
+export function parseResponse(_correlationId, apiKey, apiVersion, reader) {
+    const response = {
+        errorCode: reader.readInt16(),
+        principalType: reader.readString(),
+        principalName: reader.readString(),
+        tokenRequesterPrincipalType: reader.readString(),
+        tokenRequesterPrincipalName: reader.readString(),
+        issueTimestampMs: reader.readInt64(),
+        expiryTimestampMs: reader.readInt64(),
+        maxTimestampMs: reader.readInt64(),
+        tokenId: reader.readString(),
+        hmac: reader.readBytes(),
+        throttleTimeMs: reader.readInt32()
+    };
+    if (response.errorCode !== 0) {
+        throw new ResponseError(apiKey, apiVersion, { '': response.errorCode }, response);
+    }
+    return response;
+}
+export const api = createAPI(38, 3, createRequest, parseResponse);