apache-iggy 0.6.0 → 0.7.0

package/dist/wire/topic/create-topic.command.js

@@ -20,6 +20,10 @@ import { serializeIdentifier } from '../identifier.utils.js';
 import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { isValidCompressionAlgorithm, CompressionAlgorithm, deserializeTopic } from './topic.utils.js';
+/**
+ * Create topic command definition.
+ * Creates a new topic within a stream.
+ */
 export const CREATE_TOPIC = {
     code: COMMAND_CODE.CreateTopic,
     serialize: ({ streamId, name, partitionCount, compressionAlgorithm = CompressionAlgorithm.None, messageExpiry = 0n, maxTopicSize = 0n, replicationFactor = 1 }) => {
@@ -49,5 +53,8 @@ export const CREATE_TOPIC = {
         return deserializeTopic(r.data).data;
     }
 };
+/**
+ * Executable create topic command function.
+ */
 export const createTopic = wrapCommand(CREATE_TOPIC);
 //# sourceMappingURL=create-topic.command.js.map

package/dist/wire/topic/delete-topic.command.d.ts

@@ -17,16 +17,28 @@
  * under the License.
  */
 import { type Id } from '../identifier.utils.js';
-type DeleteTopic = {
+/**
+ * Parameters for the delete topic command.
+ */
+export type DeleteTopic = {
+    /** Stream identifier (ID or name) */
     streamId: Id;
+    /** Topic identifier (ID or name) */
     topicId: Id;
+    /** Number of partitions in the topic */
     partitionsCount: number;
 };
+/**
+ * Delete topic command definition.
+ * Permanently removes a topic and all its data from a stream.
+ */
 export declare const DELETE_TOPIC: {
     code: number;
     serialize: ({ streamId, topicId, partitionsCount }: DeleteTopic) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
+/**
+ * Executable delete topic command function.
+ */
 export declare const deleteTopic: (getClient: import("../../index.js").ClientProvider) => (arg: DeleteTopic) => Promise<boolean>;
-export {};
 //# sourceMappingURL=delete-topic.command.d.ts.map

package/dist/wire/topic/delete-topic.command.js

@@ -21,6 +21,10 @@ import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { serializeIdentifier } from '../identifier.utils.js';
 import { uint32ToBuf } from '../number.utils.js';
+/**
+ * Delete topic command definition.
+ * Permanently removes a topic and all its data from a stream.
+ */
 export const DELETE_TOPIC = {
     code: COMMAND_CODE.DeleteTopic,
     serialize: ({ streamId, topicId, partitionsCount }) => {
@@ -32,5 +36,8 @@ export const DELETE_TOPIC = {
     },
     deserialize: deserializeVoidResponse
 };
+/**
+ * Executable delete topic command function.
+ */
 export const deleteTopic = wrapCommand(DELETE_TOPIC);
 //# sourceMappingURL=delete-topic.command.js.map

package/dist/wire/topic/ensure-topic.virtual.command.d.ts

@@ -16,7 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { Id } from '../identifier.utils.js';
-import { ClientProvider } from '../../client/index.js';
+import type { Id } from '../identifier.utils.js';
+import type { ClientProvider } from '../../client/index.js';
+/**
+ * Creates a virtual command that ensures a topic exists.
+ * If the topic does not exist, it will be created with default settings.
+ *
+ * @param c - Client provider function
+ * @returns Function that ensures a topic exists by name
+ */
 export declare const ensureTopic: (c: ClientProvider) => (streamId: Id, topicName: string, partitionCount?: number, compressionAlgorithm?: number) => Promise<import("./topic.utils.js").Topic>;
 //# sourceMappingURL=ensure-topic.virtual.command.d.ts.map

package/dist/wire/topic/ensure-topic.virtual.command.js

@@ -18,6 +18,13 @@
  */
 import { createTopic } from './create-topic.command.js';
 import { getTopic } from './get-topic.command.js';
+/**
+ * Creates a virtual command that ensures a topic exists.
+ * If the topic does not exist, it will be created with default settings.
+ *
+ * @param c - Client provider function
+ * @returns Function that ensures a topic exists by name
+ */
 export const ensureTopic = (c) => async function ensureTopic(streamId, topicName, partitionCount = 1, compressionAlgorithm = 1) {
     const topic = await getTopic(c)({ streamId, topicId: topicName });
     return topic === null ?

package/dist/wire/topic/get-topic.command.d.ts

@@ -19,15 +19,26 @@
 import type { CommandResponse } from '../../client/client.type.js';
 import { type Id } from '../identifier.utils.js';
 import { type Topic } from './topic.utils.js';
-type GetTopic = {
+/**
+ * Parameters for the get topic command.
+ */
+export type GetTopic = {
+    /** Stream identifier (ID or name) */
     streamId: Id;
+    /** Topic identifier (ID or name) */
     topicId: Id;
 };
+/**
+ * Get topic command definition.
+ * Retrieves detailed information about a specific topic.
+ */
 export declare const GET_TOPIC: {
     code: number;
     serialize: ({ streamId, topicId }: GetTopic) => Buffer<ArrayBuffer>;
     deserialize: (r: CommandResponse) => Topic | null;
 };
+/**
+ * Executable get topic command function.
+ */
 export declare const getTopic: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: GetTopic) => Promise<Topic | null>;
-export {};
 //# sourceMappingURL=get-topic.command.d.ts.map

package/dist/wire/topic/get-topic.command.js

@@ -20,6 +20,10 @@ import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { serializeIdentifier } from '../identifier.utils.js';
 import { deserializeTopic } from './topic.utils.js';
+/**
+ * Get topic command definition.
+ * Retrieves detailed information about a specific topic.
+ */
 export const GET_TOPIC = {
     code: COMMAND_CODE.GetTopic,
     serialize: ({ streamId, topicId }) => {
@@ -34,5 +38,8 @@ export const GET_TOPIC = {
         return deserializeTopic(r.data).data;
     }
 };
+/**
+ * Executable get topic command function.
+ */
 export const getTopic = wrapCommand(GET_TOPIC);
 //# sourceMappingURL=get-topic.command.js.map

package/dist/wire/topic/get-topics.command.d.ts

@@ -19,13 +19,24 @@
 import type { CommandResponse } from '../../client/client.type.js';
 import { type Id } from '../identifier.utils.js';
 import { type Topic } from './topic.utils.js';
+/**
+ * Parameters for the get topics command.
+ */
 export type GetTopics = {
+    /** Stream identifier (ID or name) */
     streamId: Id;
 };
+/**
+ * Get topics command definition.
+ * Retrieves all topics within a stream.
+ */
 export declare const GET_TOPICS: {
     code: number;
     serialize: ({ streamId }: GetTopics) => Buffer<ArrayBufferLike>;
     deserialize: (r: CommandResponse) => Topic[];
 };
+/**
+ * Executable get topics command function.
+ */
 export declare const getTopics: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: GetTopics) => Promise<Topic[]>;
 //# sourceMappingURL=get-topics.command.d.ts.map

package/dist/wire/topic/get-topics.command.js

@@ -20,6 +20,10 @@ import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { serializeIdentifier } from '../identifier.utils.js';
 import { deserializeTopics } from './topic.utils.js';
+/**
+ * Get topics command definition.
+ * Retrieves all topics within a stream.
+ */
 export const GET_TOPICS = {
     code: COMMAND_CODE.GetTopics,
     serialize: ({ streamId }) => {
@@ -29,5 +33,8 @@ export const GET_TOPICS = {
         return deserializeTopics(r.data);
     }
 };
+/**
+ * Executable get topics command function.
+ */
 export const getTopics = wrapCommand(GET_TOPICS);
 //# sourceMappingURL=get-topics.command.js.map

package/dist/wire/topic/purge-topic.command.d.ts

@@ -17,14 +17,26 @@
  * under the License.
  */
 import { type Id } from '../identifier.utils.js';
+/**
+ * Parameters for the purge topic command.
+ */
 export type PurgeTopic = {
+    /** Stream identifier (ID or name) */
     streamId: Id;
+    /** Topic identifier (ID or name) */
     topicId: Id;
 };
+/**
+ * Purge topic command definition.
+ * Deletes all messages from a topic while keeping the topic itself.
+ */
 export declare const PURGE_TOPIC: {
     code: number;
     serialize: ({ streamId, topicId }: PurgeTopic) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
+/**
+ * Executable purge topic command function.
+ */
 export declare const purgeTopic: (getClient: import("../../index.js").ClientProvider) => (arg: PurgeTopic) => Promise<boolean>;
 //# sourceMappingURL=purge-topic.command.d.ts.map

package/dist/wire/topic/purge-topic.command.js

@@ -20,6 +20,10 @@ import { serializeIdentifier } from '../identifier.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { deserializeVoidResponse } from '../../client/client.utils.js';
 import { wrapCommand } from '../command.utils.js';
+/**
+ * Purge topic command definition.
+ * Deletes all messages from a topic while keeping the topic itself.
+ */
 export const PURGE_TOPIC = {
     code: COMMAND_CODE.PurgeTopic,
     serialize: ({ streamId, topicId }) => {
@@ -30,5 +34,8 @@ export const PURGE_TOPIC = {
     },
     deserialize: deserializeVoidResponse
 };
+/**
+ * Executable purge topic command function.
+ */
 export const purgeTopic = wrapCommand(PURGE_TOPIC);
 //# sourceMappingURL=purge-topic.command.js.map

package/dist/wire/topic/topic.utils.d.ts

@@ -17,55 +17,128 @@
  * under the License.
  */
 import type { ValueOf } from '../../type.utils.js';
+/**
+ * Basic topic information without partition details.
+ */
 export type BaseTopic = {
+    /** Topic ID */
     id: number;
+    /** Topic name */
     name: string;
+    /** Topic creation timestamp */
     createdAt: Date;
+    /** Number of partitions */
     partitionsCount: number;
+    /** Compression algorithm used */
     compressionAlgorithm: number;
+    /** Message expiry time in microseconds (0 = unlimited) */
     messageExpiry: bigint;
+    /** Maximum topic size in bytes (0 = unlimited) */
     maxTopicSize: bigint;
+    /** Replication factor */
     replicationFactor: number;
+    /** Total size of the topic in bytes */
     sizeBytes: bigint;
+    /** Total number of messages in the topic */
     messagesCount: bigint;
 };
+/**
+ * Partition information within a topic.
+ */
 export type Partition = {
+    /** Partition ID */
     id: number;
+    /** Partition creation timestamp */
     createdAt: Date;
+    /** Number of segments in the partition */
     segmentsCount: number;
+    /** Current offset in the partition */
     currentOffset: bigint;
+    /** Total size of the partition in bytes */
     sizeBytes: bigint;
+    /** Total number of messages in the partition */
     messagesCount: bigint;
 };
+/** Topic with partition details */
 export type Topic = BaseTopic & {
     partitions: Partition[];
 };
+/** Base serialization result */
 type Serialized = {
     bytesRead: number;
 };
+/** Result of deserializing a partition */
 type PartitionSerialized = {
     data: Partition;
 } & Serialized;
+/** Result of deserializing a base topic */
 type BaseTopicSerialized = {
     data: BaseTopic;
 } & Serialized;
+/** Result of deserializing a topic */
 type TopicSerialized = {
     data: Topic;
 } & Serialized;
+/**
+ * Compression algorithm options.
+ */
 export declare const CompressionAlgorithm: {
+    /** No compression */
     None: number;
+    /** Gzip compression */
     Gzip: number;
 };
+/** Type alias for the CompressionAlgorithm object */
 export type CompressionAlgorithmKind = typeof CompressionAlgorithm;
+/** String literal type of compression algorithm names */
 export type CompressionAlgorithmKindId = keyof CompressionAlgorithm;
+/** Numeric values of compression algorithms */
 export type CompressionAlgorithmKindValue = ValueOf<CompressionAlgorithm>;
+/** No compression type */
 export type CompressionAlgorithmNone = CompressionAlgorithmKind['None'];
+/** Gzip compression type */
 export type CompressionAlgorithmGzip = CompressionAlgorithmKind['Gzip'];
+/** Union of compression algorithm types */
 export type CompressionAlgorithm = CompressionAlgorithmNone | CompressionAlgorithmGzip;
+/**
+ * Type guard for valid compression algorithms.
+ *
+ * @param ca - Compression algorithm value to check
+ * @returns True if the value is a valid compression algorithm
+ */
 export declare const isValidCompressionAlgorithm: (ca: number) => ca is CompressionAlgorithm;
+/**
+ * Deserializes a base topic from a buffer.
+ *
+ * @param p - Buffer containing serialized topic data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized topic data
+ */
 export declare const deserializeBaseTopic: (p: Buffer, pos?: number) => BaseTopicSerialized;
+/**
+ * Deserializes a partition from a buffer.
+ *
+ * @param p - Buffer containing serialized partition data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized partition data
+ */
 export declare const deserializePartition: (p: Buffer, pos?: number) => PartitionSerialized;
+/**
+ * Deserializes a topic with partitions from a buffer.
+ *
+ * @param p - Buffer containing serialized topic data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized topic with partitions
+ * @throws Error if the buffer is empty (topic does not exist)
+ */
 export declare const deserializeTopic: (p: Buffer, pos?: number) => TopicSerialized;
+/**
+ * Deserializes multiple topics from a buffer.
+ *
+ * @param p - Buffer containing serialized topics data
+ * @param pos - Starting position in the buffer
+ * @returns Array of deserialized topics
+ */
 export declare const deserializeTopics: (p: Buffer, pos?: number) => Topic[];
 export {};
 //# sourceMappingURL=topic.utils.d.ts.map

package/dist/wire/topic/topic.utils.js

@@ -17,11 +17,29 @@
  * under the License.
  */
 import { toDate } from '../serialize.utils.js';
+/**
+ * Compression algorithm options.
+ */
 export const CompressionAlgorithm = {
+    /** No compression */
     None: 1,
+    /** Gzip compression */
     Gzip: 2
 };
+/**
+ * Type guard for valid compression algorithms.
+ *
+ * @param ca - Compression algorithm value to check
+ * @returns True if the value is a valid compression algorithm
+ */
 export const isValidCompressionAlgorithm = (ca) => Object.values(CompressionAlgorithm).includes(ca);
+/**
+ * Deserializes a base topic from a buffer.
+ *
+ * @param p - Buffer containing serialized topic data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized topic data
+ */
 export const deserializeBaseTopic = (p, pos = 0) => {
     const id = p.readUInt32LE(pos);
     const createdAt = toDate(p.readBigUint64LE(pos + 4));
@@ -50,6 +68,13 @@ export const deserializeBaseTopic = (p, pos = 0) => {
         }
     };
 };
+/**
+ * Deserializes a partition from a buffer.
+ *
+ * @param p - Buffer containing serialized partition data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized partition data
+ */
 export const deserializePartition = (p, pos = 0) => {
     return {
         bytesRead: 4 + 8 + 4 + 8 + 8 + 8,
@@ -63,6 +88,14 @@ export const deserializePartition = (p, pos = 0) => {
         }
     };
 };
+/**
+ * Deserializes a topic with partitions from a buffer.
+ *
+ * @param p - Buffer containing serialized topic data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized topic with partitions
+ * @throws Error if the buffer is empty (topic does not exist)
+ */
 export const deserializeTopic = (p, pos = 0) => {
     if (p.length === 0)
         throw new Error('Topic does not exist');
@@ -78,6 +111,13 @@ export const deserializeTopic = (p, pos = 0) => {
     }
     return { bytesRead: pos - start, data: { ...data, partitions } };
 };
+/**
+ * Deserializes multiple topics from a buffer.
+ *
+ * @param p - Buffer containing serialized topics data
+ * @param pos - Starting position in the buffer
+ * @returns Array of deserialized topics
+ */
 export const deserializeTopics = (p, pos = 0) => {
     const topics = [];
     const len = p.length;

package/dist/wire/topic/update-topic.command.d.ts

@@ -18,19 +18,36 @@
  */
 import { type Id } from '../identifier.utils.js';
 import { type CompressionAlgorithm as CompressionAlgorithmT } from './topic.utils.js';
+/**
+ * Parameters for the update topic command.
+ */
 export type UpdateTopic = {
+    /** Stream identifier (ID or name) */
     streamId: Id;
+    /** Topic identifier (ID or name) */
     topicId: Id;
+    /** New topic name (1-255 bytes) */
     name: string;
+    /** Compression algorithm (None or Gzip) */
     compressionAlgorithm?: CompressionAlgorithmT;
+    /** Message expiry time in microseconds (0 = unlimited) */
     messageExpiry?: bigint;
+    /** Maximum topic size in bytes (0 = unlimited) */
     maxTopicSize?: bigint;
+    /** Replication factor (1-255) */
     replicationFactor?: number;
 };
+/**
+ * Update topic command definition.
+ * Updates a topic's configuration.
+ */
 export declare const UPDATE_TOPIC: {
     code: number;
     serialize: ({ streamId, topicId, name, compressionAlgorithm, messageExpiry, maxTopicSize, replicationFactor, }: UpdateTopic) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
+/**
+ * Executable update topic command function.
+ */
 export declare const updateTopic: (getClient: import("../../index.js").ClientProvider) => (arg: UpdateTopic) => Promise<boolean>;
 //# sourceMappingURL=update-topic.command.d.ts.map

package/dist/wire/topic/update-topic.command.js

@@ -21,6 +21,10 @@ import { deserializeVoidResponse } from '../../client/client.utils.js';
 import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { CompressionAlgorithm, isValidCompressionAlgorithm } from './topic.utils.js';
+/**
+ * Update topic command definition.
+ * Updates a topic's configuration.
+ */
 export const UPDATE_TOPIC = {
     code: COMMAND_CODE.UpdateTopic,
     serialize: ({ streamId, topicId, name, compressionAlgorithm = CompressionAlgorithm.None, messageExpiry = 0n, maxTopicSize = 0n, replicationFactor = 1, }) => {
@@ -46,5 +50,8 @@ export const UPDATE_TOPIC = {
     },
     deserialize: deserializeVoidResponse
 };
+/**
+ * Executable update topic command function.
+ */
 export const updateTopic = wrapCommand(UPDATE_TOPIC);
 //# sourceMappingURL=update-topic.command.js.map

package/dist/wire/user/change-password.command.d.ts

@@ -16,15 +16,28 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+/**
+ * Parameters for the change password command.
+ */
 export type ChangePassword = {
+    /** User ID */
     userId: number;
+    /** Current password (1-255 bytes) */
     currentPassword: string;
+    /** New password (1-255 bytes) */
     newPassword: string;
 };
+/**
+ * Change password command definition.
+ * Changes a user's password.
+ */
 export declare const CHANGE_PASSWORD: {
     code: number;
     serialize: ({ userId, currentPassword, newPassword }: ChangePassword) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
+/**
+ * Executable change password command function.
+ */
 export declare const changePassword: (getClient: import("../../index.js").ClientProvider) => (arg: ChangePassword) => Promise<boolean>;
 //# sourceMappingURL=change-password.command.d.ts.map

package/dist/wire/user/change-password.command.js

@@ -21,6 +21,10 @@ import { serializeIdentifier } from '../identifier.utils.js';
 import { deserializeVoidResponse } from '../../client/client.utils.js';
 import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
+/**
+ * Change password command definition.
+ * Changes a user's password.
+ */
 export const CHANGE_PASSWORD = {
     code: COMMAND_CODE.ChangePassword,
     serialize: ({ userId, currentPassword, newPassword }) => {
@@ -41,5 +45,8 @@ export const CHANGE_PASSWORD = {
     },
     deserialize: deserializeVoidResponse
 };
+/**
+ * Executable change password command function.
+ */
 export const changePassword = wrapCommand(CHANGE_PASSWORD);
 //# sourceMappingURL=change-password.command.js.map

package/dist/wire/user/create-user.command.d.ts

@@ -19,16 +19,30 @@
 import type { CommandResponse } from '../../client/client.type.js';
 import { type User, type UserStatus } from './user.utils.js';
 import { type UserPermissions } from './permissions.utils.js';
+/**
+ * Parameters for the create user command.
+ */
 export type CreateUser = {
+    /** Username (1-255 bytes) */
     username: string;
+    /** Password (1-255 bytes) */
     password: string;
+    /** User status (Active or Inactive) */
     status: UserStatus;
+    /** Optional user permissions */
     permissions?: UserPermissions;
 };
+/**
+ * Create user command definition.
+ * Creates a new user with the specified credentials and permissions.
+ */
 export declare const CREATE_USER: {
     code: number;
     serialize: ({ username, password, status, permissions }: CreateUser) => Buffer<ArrayBuffer>;
     deserialize: (r: CommandResponse) => User;
 };
+/**
+ * Executable create user command function.
+ */
 export declare const createUser: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: CreateUser) => Promise<User>;
 //# sourceMappingURL=create-user.command.d.ts.map

package/dist/wire/user/create-user.command.js

@@ -21,6 +21,10 @@ import { COMMAND_CODE } from '../command.code.js';
 import { deserializeUser } from './user.utils.js';
 import { uint8ToBuf, uint32ToBuf, boolToBuf } from '../number.utils.js';
 import { serializePermissions } from './permissions.utils.js';
+/**
+ * Create user command definition.
+ * Creates a new user with the specified credentials and permissions.
+ */
 export const CREATE_USER = {
     code: COMMAND_CODE.CreateUser,
     serialize: ({ username, password, status, permissions }) => {
@@ -44,5 +48,8 @@ export const CREATE_USER = {
     },
     deserialize: (r) => deserializeUser(r.data)
 };
+/**
+ * Executable create user command function.
+ */
 export const createUser = wrapCommand(CREATE_USER);
 //# sourceMappingURL=create-user.command.js.map

package/dist/wire/user/delete-user.command.d.ts

@@ -17,13 +17,24 @@
  * under the License.
  */
 import { type Id } from '../identifier.utils.js';
+/**
+ * Parameters for the delete user command.
+ */
 export type DeleteUser = {
+    /** User identifier (ID or username) */
     userId: Id;
 };
+/**
+ * Delete user command definition.
+ * Removes a user from the system.
+ */
 export declare const DELETE_USER: {
     code: number;
     serialize: ({ userId }: DeleteUser) => Buffer<ArrayBufferLike>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
+/**
+ * Executable delete user command function.
+ */
 export declare const deleteUser: (getClient: import("../../index.js").ClientProvider) => (arg: DeleteUser) => Promise<boolean>;
 //# sourceMappingURL=delete-user.command.d.ts.map

package/dist/wire/user/delete-user.command.js

@@ -20,6 +20,10 @@ import { deserializeVoidResponse } from '../../client/client.utils.js';
 import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { serializeIdentifier } from '../identifier.utils.js';
+/**
+ * Delete user command definition.
+ * Removes a user from the system.
+ */
 export const DELETE_USER = {
     code: COMMAND_CODE.DeleteUser,
     serialize: ({ userId }) => {
@@ -27,5 +31,8 @@ export const DELETE_USER = {
     },
     deserialize: deserializeVoidResponse
 };
+/**
+ * Executable delete user command function.
+ */
 export const deleteUser = wrapCommand(DELETE_USER);
 //# sourceMappingURL=delete-user.command.js.map