import type { ClientProvider } from '../client/client.type.js';
declare const userAPI: (c: ClientProvider) => {
    get: (arg: import("./user/get-user.command.js").GetUser) => Promise<import("./user/user.utils.js").User | null>;
    list: (arg: void) => Promise<import("./user/user.utils.js").BaseUser[]>;
    create: (arg: import("./user/create-user.command.js").CreateUser) => Promise<import("./user/user.utils.js").User>;
    update: (arg: import("./user/update-user.command.js").UpdateUser) => Promise<boolean>;
    updatePermissions: (arg: import("./user/update-permissions.command.js").UpdatePermissions) => Promise<boolean>;
    changePassword: (arg: import("./user/change-password.command.js").ChangePassword) => Promise<boolean>;
    delete: (arg: import("./user/delete-user.command.js").DeleteUser) => Promise<boolean>;
};
type UserAPI = ReturnType<typeof userAPI>;
declare const sessionAPI: (c: ClientProvider) => {
    login: (arg: import("./index.js").LoginCredentials) => Promise<import("./index.js").LoginResponse>;
    loginWithToken: (arg: import("./session/login-with-token.command.js").LoginWithTokenParam) => Promise<import("./index.js").LoginResponse>;
    logout: (arg: void) => Promise<boolean>;
};
type SessionAPI = ReturnType<typeof sessionAPI>;
declare const clientAPI: (c: ClientProvider) => {
    get: (arg: import("./client/get-client.command.js").GetClient) => Promise<import("./client/client.utils.js").Client | null>;
    getMe: (arg: void) => Promise<import("./client/client.utils.js").Client>;
    list: (arg: void) => Promise<import("./client/client.utils.js").Client[]>;
};
type ClientAPI = ReturnType<typeof clientAPI>;
declare const tokenAPI: (c: ClientProvider) => {
    list: (arg: void) => Promise<import("./token/token.utils.js").Token[]>;
    create: (arg: import("./token/create-token.command.js").CreateToken) => Promise<import("./token/token.utils.js").CreateTokenResponse>;
    delete: (arg: import("./token/delete-token.command.js").DeleteToken) => Promise<boolean>;
};
type TokenAPI = ReturnType<typeof tokenAPI>;
declare const streamAPI: (c: ClientProvider) => {
    get: (arg: import("./stream/get-stream.command.js").GetStream) => Promise<import("./stream/stream.utils.js").Stream | null>;
    list: (arg: void) => Promise<import("./stream/stream.utils.js").Stream[]>;
    create: (arg: import("./stream/create-stream.command.js").CreateStream) => Promise<import("./stream/stream.utils.js").Stream>;
    update: (arg: import("./stream/update-stream.command.js").UpdateStream) => Promise<boolean>;
    delete: (arg: import("./stream/delete-stream.command.js").DeleteStream) => Promise<boolean>;
    purge: (arg: import("./stream/purge-stream.command.js").PurgeStream) => Promise<boolean>;
    ensure: (streamName: string) => Promise<import("./stream/stream.utils.js").Stream>;
};
type StreamAPI = ReturnType<typeof streamAPI>;
declare const topicAPI: (c: ClientProvider) => {
    get: (arg: import("./topic/get-topic.command.js").GetTopic) => Promise<import("./topic/topic.utils.js").Topic | null>;
    list: (arg: import("./topic/get-topics.command.js").GetTopics) => Promise<import("./topic/topic.utils.js").Topic[]>;
    create: (arg: import("./topic/create-topic.command.js").CreateTopic) => Promise<import("./topic/topic.utils.js").Topic>;
    update: (arg: import("./topic/update-topic.command.js").UpdateTopic) => Promise<boolean>;
    delete: (arg: import("./topic/delete-topic.command.js").DeleteTopic) => Promise<boolean>;
    purge: (arg: import("./topic/purge-topic.command.js").PurgeTopic) => Promise<boolean>;
    ensure: (streamId: import("./identifier.utils.js").Id, topicName: string, partitionCount?: number, compressionAlgorithm?: number) => Promise<import("./topic/topic.utils.js").Topic>;
};
type TopicAPI = ReturnType<typeof topicAPI>;
declare const partitionAPI: (c: ClientProvider) => {
    create: (arg: import("./partition/create-partition.command.js").CreatePartition) => Promise<boolean>;
    delete: (arg: import("./partition/delete-partition.command.js").DeletePartition) => Promise<boolean>;
};
type PartitionAPI = ReturnType<typeof partitionAPI>;
declare const segmentAPI: (c: ClientProvider) => {
    delete: (arg: import("./segment/delete-segments.command.js").DeleteSegments) => Promise<boolean>;
};
type SegmentAPI = ReturnType<typeof segmentAPI>;
declare const groupAPI: (c: ClientProvider) => {
    get: (arg: import("./consumer-group/group.utils.js").TargetGroup) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup | null>;
    list: (arg: import("./consumer-group/get-groups.command.js").GetGroups) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup[]>;
    create: (arg: import("./consumer-group/create-group.command.js").CreateGroup) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup>;
    join: (arg: import("./consumer-group/group.utils.js").TargetGroup) => Promise<boolean>;
    leave: (arg: import("./consumer-group/group.utils.js").TargetGroup) => Promise<boolean>;
    delete: (arg: import("./consumer-group/group.utils.js").TargetGroup) => Promise<boolean>;
    ensure: (streamId: import("./identifier.utils.js").Id, topicId: import("./identifier.utils.js").Id, groupName: string) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup>;
    ensureAndJoin: (streamId: import("./identifier.utils.js").Id, topicId: import("./identifier.utils.js").Id, groupName: string) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup>;
};
type GroupAPI = ReturnType<typeof groupAPI>;
declare const offsetAPI: (c: ClientProvider) => {
    get: (arg: import("./offset/get-offset.command.js").GetOffset) => Promise<import("./offset/offset.utils.js").OffsetResponse | null>;
    store: (arg: import("./offset/store-offset.command.js").StoreOffset) => Promise<boolean>;
    delete: (arg: import("./offset/get-offset.command.js").GetOffset) => Promise<boolean>;
};
type OffsetAPI = ReturnType<typeof offsetAPI>;
declare const messageAPI: (c: ClientProvider) => {
    poll: (request: import("./message/poll-messages.command.js").PollMessages) => Promise<import("./index.js").PollMessagesResponse>;
    send: (arg: import("./message/send-messages.command.js").SendMessages) => Promise<import("./message/send-messages.command.js").SendMessagesResponse>;
    flushUnsavedBuffers: (arg: import("./message/flush-unsaved-buffers.command.js").FlushUnsavedBuffer) => Promise<boolean>;
};
type MessageAPI = ReturnType<typeof messageAPI>;
declare const systemAPI: (c: ClientProvider) => {
    ping: (arg: void) => Promise<boolean>;
    getStats: (arg: void) => Promise<import("./system/get-stats.command.js").Stats>;
    describeOptions: (arg: import("./system/describe-options.command.js").DescribeOptions) => Promise<import("./system/describe-options.command.js").OptionSpec[]>;
};
type SystemAPI = ReturnType<typeof systemAPI>;
declare const clusterAPI: (c: ClientProvider) => {
    getClusterMetadata: (arg: void) => Promise<import("./cluster/cluster.utils.js").ClusterMetadata>;
};
type ClusterAPI = ReturnType<typeof clusterAPI>;
export declare abstract class AbstractAPI {
    clientProvider: ClientProvider;
    constructor(getClient: ClientProvider);
}
export declare abstract class CommandAPI extends AbstractAPI {
    user: UserAPI;
    session: SessionAPI;
    client: ClientAPI;
    token: TokenAPI;
    stream: StreamAPI;
    topic: TopicAPI;
    partition: PartitionAPI;
    segment: SegmentAPI;
    group: GroupAPI;
    offset: OffsetAPI;
    message: MessageAPI;
    system: SystemAPI;
    cluster: ClusterAPI;
    constructor(c: ClientProvider);
    /**
     * Sends a command code with a payload and returns the raw response payload.
     * Session-control codes are rejected with an invalid-command error.
     *
     * @param code - Command code to send
     * @param payload - Raw command payload
     * @returns Raw response payload
     */
    sendBinaryRequest(code: number, payload: Buffer): Promise<Buffer>;
}
export {};
//# sourceMappingURL=command-set.d.ts.map