hive-stream 3.0.3 → 3.0.5

package/dist/builders.js

@@ -0,0 +1,1609 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HiveCommunityOperationBuilder = exports.HiveEngineDelegateBuilder = exports.HiveEngineCancelOrderBuilder = exports.HiveEngineMarketOrderBuilder = exports.HiveEngineUnstakeBuilder = exports.HiveEngineStakeBuilder = exports.HiveBatchBuilder = exports.HivePostBuilder = exports.HiveCommentOptionsBuilder = exports.HiveWithdrawRouteBuilder = exports.HiveCancelOrderBuilder = exports.HiveLimitOrderBuilder = exports.HiveDeleteCommentBuilder = exports.HiveCollateralizedConvertBuilder = exports.HiveConvertBuilder = exports.HiveSavingsTransferBuilder = exports.HiveUpdateProfileBuilder = exports.HiveSetProxyBuilder = exports.HiveWitnessVoteBuilder = exports.HiveClaimRewardsBuilder = exports.HiveDelegateBuilder = exports.HivePowerDownBuilder = exports.HivePowerUpBuilder = exports.HiveReblogBuilder = exports.HiveFollowBuilder = exports.HiveVoteBuilder = exports.HiveRemoveProposalsBuilder = exports.HiveProposalVotesBuilder = exports.HiveEngineTokenIssueBuilder = exports.HiveEngineTokenBurnBuilder = exports.HiveEngineTokenTransferBuilder = exports.HiveProposalBuilder = exports.HiveRecurrentTransferBuilder = exports.HiveEscrowTransferBuilder = exports.HiveBurnBuilder = exports.HiveTransferBuilder = exports.IncomingTransfersBuilder = void 0;
+const utils_1 = require("./utils");
+function normalizeAllocationInput(input, context) {
+    if (typeof input === 'number') {
+        return { percentage: input };
+    }
+    if (typeof input === 'string') {
+        const value = input.trim();
+        if (!/^-?\d+(\.\d+)?$/.test(value)) {
+            throw new Error(`${context} allocation string must be numeric`);
+        }
+        return { percentage: value };
+    }
+    if (!input || typeof input !== 'object') {
+        throw new Error(`${context} allocation is required`);
+    }
+    const percentage = input.percentage ?? input.percent;
+    const basisPoints = input.basisPoints;
+    if (percentage !== undefined && basisPoints !== undefined) {
+        throw new Error(`${context} accepts either percentage or basisPoints, not both`);
+    }
+    if (percentage === undefined && basisPoints === undefined) {
+        throw new Error(`${context} allocation is required`);
+    }
+    return {
+        percentage: input.percentage,
+        percent: input.percent,
+        basisPoints: input.basisPoints
+    };
+}
+function resolveRouteMemo(stepMemo, defaultMemo) {
+    return stepMemo !== undefined ? stepMemo : defaultMemo;
+}
+function normalizeGroupRecipients(recipients, context) {
+    if (!Array.isArray(recipients) || recipients.length === 0) {
+        throw new Error(`${context} requires at least one group recipient`);
+    }
+    return recipients.map((recipient, index) => {
+        if (!recipient || typeof recipient !== 'object') {
+            throw new Error(`${context} recipient ${index + 1} is invalid`);
+        }
+        if (typeof recipient.account === 'string') {
+            const account = recipient.account.trim();
+            if (!account) {
+                throw new Error(`${context} recipient ${index + 1} account is required`);
+            }
+            return {
+                account,
+                weight: recipient.weight
+            };
+        }
+        if (typeof recipient.account !== 'function') {
+            throw new Error(`${context} recipient ${index + 1} account is required`);
+        }
+        return recipient;
+    });
+}
+function parseAssetInput(amount, symbol) {
+    if (symbol) {
+        return {
+            amount: utils_1.Utils.formatAmount(amount),
+            symbol: symbol.trim()
+        };
+    }
+    if (typeof amount === 'string' && amount.includes(' ')) {
+        const parsed = utils_1.Utils.parseAssetAmount(amount);
+        return {
+            amount: utils_1.Utils.formatAmount(parsed.amount),
+            symbol: parsed.asset
+        };
+    }
+    throw new Error('Provide a symbol or an asset amount string like "1.000 HIVE"');
+}
+function buildAssetAmount(amount, symbol) {
+    const parsed = parseAssetInput(amount, symbol);
+    return utils_1.Utils.formatAssetAmount(parsed.amount, parsed.symbol);
+}
+function normalizeEngineQuantity(quantity) {
+    const normalized = String(quantity).trim();
+    if (!normalized) {
+        throw new Error('Quantity is required');
+    }
+    return normalized;
+}
+class IncomingTransfersBuilder {
+    streamer;
+    account;
+    allowedSymbols;
+    dedupeStore;
+    ignoreZeroAmountValue;
+    errorHandler;
+    defaultMemo;
+    steps = [];
+    constructor(streamer, account) {
+        this.streamer = streamer;
+        this.account = account;
+    }
+    forAccount(account) {
+        this.account = account;
+        return this;
+    }
+    allowSymbols(...symbols) {
+        this.allowedSymbols = symbols.map((symbol) => symbol.trim()).filter(Boolean);
+        return this;
+    }
+    memo(memo) {
+        this.defaultMemo = memo;
+        return this;
+    }
+    dedupeWith(store) {
+        this.dedupeStore = store;
+        return this;
+    }
+    ignoreZeroAmount(ignore = true) {
+        this.ignoreZeroAmountValue = ignore;
+        return this;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    burn(allocation, memo) {
+        this.steps.push({
+            type: 'burn',
+            ...normalizeAllocationInput(allocation, 'burn()'),
+            memo
+        });
+        return this;
+    }
+    burnOnTop(allocation, memo) {
+        this.steps.push({
+            type: 'burn',
+            mode: 'onTop',
+            ...normalizeAllocationInput(allocation, 'burnOnTop()'),
+            memo
+        });
+        return this;
+    }
+    forwardTo(to, allocation, memo) {
+        if (typeof to !== 'string' || to.trim().length === 0) {
+            throw new Error('forwardTo() requires a destination account');
+        }
+        this.steps.push({
+            type: 'transfer',
+            to: to.trim(),
+            ...(allocation === undefined ? {} : normalizeAllocationInput(allocation, 'forwardTo()')),
+            memo
+        });
+        return this;
+    }
+    forwardOnTop(to, allocation, memo) {
+        if (typeof to !== 'string' || to.trim().length === 0) {
+            throw new Error('forwardOnTop() requires a destination account');
+        }
+        this.steps.push({
+            type: 'transfer',
+            mode: 'onTop',
+            to: to.trim(),
+            ...normalizeAllocationInput(allocation, 'forwardOnTop()'),
+            memo
+        });
+        return this;
+    }
+    donateOnTop(to, allocation, memo) {
+        return this.forwardOnTop(to, allocation, memo);
+    }
+    forwardGroup(recipients, allocation, options = {}) {
+        this.steps.push({
+            type: 'transfer',
+            group: normalizeGroupRecipients(recipients, 'forwardGroup()'),
+            split: options.split,
+            ...normalizeAllocationInput(allocation, 'forwardGroup()'),
+            memo: options.memo
+        });
+        return this;
+    }
+    forwardGroupOnTop(recipients, allocation, options = {}) {
+        this.steps.push({
+            type: 'transfer',
+            mode: 'onTop',
+            group: normalizeGroupRecipients(recipients, 'forwardGroupOnTop()'),
+            split: options.split,
+            ...normalizeAllocationInput(allocation, 'forwardGroupOnTop()'),
+            memo: options.memo
+        });
+        return this;
+    }
+    remainderTo(to, memo) {
+        return this.forwardTo(to, undefined, memo);
+    }
+    remainderToGroup(recipients, options = {}) {
+        this.steps.push({
+            type: 'transfer',
+            group: normalizeGroupRecipients(recipients, 'remainderToGroup()'),
+            split: options.split,
+            memo: options.memo
+        });
+        return this;
+    }
+    refund(memo) {
+        this.steps.push({
+            type: 'refund',
+            memo
+        });
+        return this;
+    }
+    refundPortion(allocation, memo) {
+        this.steps.push({
+            type: 'refund',
+            ...normalizeAllocationInput(allocation, 'refundPortion()'),
+            memo
+        });
+        return this;
+    }
+    remainderToSender(memo) {
+        return this.refund(memo);
+    }
+    plan(transfer) {
+        const commonOptions = {
+            routes: this.buildRoutes(),
+            allowedSymbols: this.allowedSymbols
+        };
+        return this.streamer.planIncomingTransferRoutes(transfer, commonOptions);
+    }
+    start() {
+        if (this.steps.length === 0) {
+            throw new Error('Add at least one builder step before calling start()');
+        }
+        const commonOptions = {
+            account: this.account,
+            allowedSymbols: this.allowedSymbols,
+            dedupeStore: this.dedupeStore,
+            ignoreZeroAmount: this.ignoreZeroAmountValue,
+            onError: this.errorHandler
+        };
+        if (this.steps.length === 1 && !this.steps[0].group && this.steps[0].mode !== 'onTop') {
+            const step = this.steps[0];
+            const memo = resolveRouteMemo(step.memo, this.defaultMemo);
+            if (step.type === 'burn') {
+                return this.streamer.autoBurnIncomingTransfers({
+                    ...commonOptions,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                });
+            }
+            if (step.type === 'refund') {
+                return this.streamer.autoRefundIncomingTransfers({
+                    ...commonOptions,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                });
+            }
+            return this.streamer.autoForwardIncomingTransfers({
+                ...commonOptions,
+                to: step.to,
+                percentage: step.percentage,
+                percent: step.percent,
+                basisPoints: step.basisPoints,
+                memo
+            });
+        }
+        const options = {
+            ...commonOptions,
+            routes: this.buildRoutes()
+        };
+        return this.streamer.autoRouteIncomingTransfers(options);
+    }
+    buildRoutes() {
+        if (this.steps.length === 0) {
+            throw new Error('Add at least one builder step before planning or starting a flow');
+        }
+        return this.steps.map((step) => {
+            const memo = resolveRouteMemo(step.memo, this.defaultMemo);
+            if (step.type === 'burn') {
+                return {
+                    type: 'burn',
+                    mode: step.mode,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                };
+            }
+            if (step.type === 'refund') {
+                return {
+                    mode: step.mode,
+                    to: (event) => event.transfer.from,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                };
+            }
+            if (step.group) {
+                return {
+                    mode: step.mode,
+                    group: step.group,
+                    split: step.split,
+                    percentage: step.percentage,
+                    percent: step.percent,
+                    basisPoints: step.basisPoints,
+                    memo
+                };
+            }
+            return {
+                mode: step.mode,
+                to: step.to,
+                percentage: step.percentage,
+                percent: step.percent,
+                basisPoints: step.basisPoints,
+                memo
+            };
+        });
+    }
+}
+exports.IncomingTransfersBuilder = IncomingTransfersBuilder;
+class HiveTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        const parsed = parseAssetInput(amount, symbol);
+        this.state.amount = parsed.amount;
+        this.state.symbol = parsed.symbol;
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.to || !this.state.amount || !this.state.symbol) {
+            throw new Error('transfer() builder requires from, to, and amount before send()');
+        }
+        return this.streamer.transferHiveTokens(this.state.from, this.state.to, this.state.amount, this.state.symbol, this.state.memo || '');
+    }
+}
+exports.HiveTransferBuilder = HiveTransferBuilder;
+class HiveBurnBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        const parsed = parseAssetInput(amount, symbol);
+        this.state.amount = parsed.amount;
+        this.state.symbol = parsed.symbol;
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount || !this.state.symbol) {
+            throw new Error('burn() builder requires from and amount before send()');
+        }
+        return this.streamer.burnHiveTokens(this.state.from, this.state.amount, this.state.symbol, this.state.memo || '');
+    }
+}
+exports.HiveBurnBuilder = HiveBurnBuilder;
+class HiveEscrowTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    agent(account) {
+        this.state.agent = account;
+        return this;
+    }
+    id(escrowId) {
+        this.state.escrow_id = escrowId;
+        return this;
+    }
+    hive(amount) {
+        this.state.hive_amount = buildAssetAmount(amount, 'HIVE');
+        return this;
+    }
+    hbd(amount) {
+        this.state.hbd_amount = buildAssetAmount(amount, 'HBD');
+        return this;
+    }
+    fee(amount, symbol) {
+        this.state.fee = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    ratificationDeadline(value) {
+        this.state.ratification_deadline = value;
+        return this;
+    }
+    expiration(value) {
+        this.state.escrow_expiration = value;
+        return this;
+    }
+    jsonMeta(meta) {
+        this.state.json_meta = meta;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.escrowTransfer({
+            from: this.state.from,
+            to: this.state.to,
+            agent: this.state.agent,
+            escrow_id: this.state.escrow_id,
+            hive_amount: this.state.hive_amount,
+            hbd_amount: this.state.hbd_amount,
+            fee: this.state.fee,
+            ratification_deadline: this.state.ratification_deadline,
+            escrow_expiration: this.state.escrow_expiration,
+            json_meta: this.state.json_meta
+        }, signingKeys);
+    }
+}
+exports.HiveEscrowTransferBuilder = HiveEscrowTransferBuilder;
+class HiveRecurrentTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        this.state.amount = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    recurrence(value) {
+        this.state.recurrence = value;
+        return this;
+    }
+    executions(value) {
+        this.state.executions = value;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.recurrentTransfer({
+            from: this.state.from,
+            to: this.state.to,
+            amount: this.state.amount,
+            memo: this.state.memo,
+            recurrence: this.state.recurrence,
+            executions: this.state.executions
+        }, signingKeys);
+    }
+}
+exports.HiveRecurrentTransferBuilder = HiveRecurrentTransferBuilder;
+class HiveProposalBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    creator(account) {
+        this.state.creator = account;
+        return this;
+    }
+    receiver(account) {
+        this.state.receiver = account;
+        return this;
+    }
+    startDate(value) {
+        this.state.start_date = value;
+        return this;
+    }
+    endDate(value) {
+        this.state.end_date = value;
+        return this;
+    }
+    dailyPay(amount, symbol) {
+        this.state.daily_pay = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    dailyHive(amount) {
+        return this.dailyPay(amount, 'HIVE');
+    }
+    dailyHbd(amount) {
+        return this.dailyPay(amount, 'HBD');
+    }
+    subject(value) {
+        this.state.subject = value;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.createProposal({
+            creator: this.state.creator,
+            receiver: this.state.receiver,
+            start_date: this.state.start_date,
+            end_date: this.state.end_date,
+            daily_pay: this.state.daily_pay,
+            subject: this.state.subject,
+            permlink: this.state.permlink
+        }, signingKeys);
+    }
+}
+exports.HiveProposalBuilder = HiveProposalBuilder;
+class HiveEngineTokenTransferBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    symbol(symbol) {
+        this.state.symbol = symbol.trim();
+        return this;
+    }
+    quantity(quantity) {
+        this.state.quantity = normalizeEngineQuantity(quantity);
+        return this;
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        return this.streamer.transferHiveEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity, this.state.memo || '');
+    }
+}
+exports.HiveEngineTokenTransferBuilder = HiveEngineTokenTransferBuilder;
+class HiveEngineTokenBurnBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    symbol(symbol) {
+        this.state.symbol = symbol.trim();
+        return this;
+    }
+    quantity(quantity) {
+        this.state.quantity = normalizeEngineQuantity(quantity);
+        return this;
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        return this.streamer.burnHiveEngineTokens(this.state.from, this.state.symbol, this.state.quantity, this.state.memo || '');
+    }
+}
+exports.HiveEngineTokenBurnBuilder = HiveEngineTokenBurnBuilder;
+class HiveEngineTokenIssueBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    symbol(symbol) {
+        this.state.symbol = symbol.trim();
+        return this;
+    }
+    quantity(quantity) {
+        this.state.quantity = normalizeEngineQuantity(quantity);
+        return this;
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    send() {
+        return this.streamer.issueHiveEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity, this.state.memo || '');
+    }
+}
+exports.HiveEngineTokenIssueBuilder = HiveEngineTokenIssueBuilder;
+class HiveProposalVotesBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    voter(account) {
+        this.state.voter = account;
+        return this;
+    }
+    ids(...proposalIds) {
+        this.state.proposal_ids = proposalIds;
+        return this;
+    }
+    approve(value = true) {
+        this.state.approve = value;
+        return this;
+    }
+    reject() {
+        return this.approve(false);
+    }
+    send(signingKeys) {
+        return this.streamer.updateProposalVotes({
+            voter: this.state.voter,
+            proposal_ids: this.state.proposal_ids,
+            approve: this.state.approve
+        }, signingKeys);
+    }
+}
+exports.HiveProposalVotesBuilder = HiveProposalVotesBuilder;
+class HiveRemoveProposalsBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    owner(account) {
+        this.state.proposal_owner = account;
+        return this;
+    }
+    ids(...proposalIds) {
+        this.state.proposal_ids = proposalIds;
+        return this;
+    }
+    send(signingKeys) {
+        return this.streamer.removeProposals({
+            proposal_owner: this.state.proposal_owner,
+            proposal_ids: this.state.proposal_ids
+        }, signingKeys);
+    }
+}
+exports.HiveRemoveProposalsBuilder = HiveRemoveProposalsBuilder;
+class HiveVoteBuilder {
+    streamer;
+    direction;
+    state = {};
+    constructor(streamer, direction) {
+        this.streamer = streamer;
+        this.direction = direction;
+    }
+    author(account) {
+        this.state.username = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    weight(value) {
+        this.state.weight = String(value);
+        return this;
+    }
+    send() {
+        if (this.direction === 'upvote') {
+            return this.streamer.upvote(this.state.weight || '100.0', this.state.username, this.state.permlink);
+        }
+        return this.streamer.downvote(this.state.weight || '100.0', this.state.username, this.state.permlink);
+    }
+}
+exports.HiveVoteBuilder = HiveVoteBuilder;
+class HiveFollowBuilder {
+    streamer;
+    mode;
+    state = {};
+    constructor(streamer, mode) {
+        this.streamer = streamer;
+        this.mode = mode;
+    }
+    follower(account) {
+        this.state.follower = account;
+        return this;
+    }
+    following(account) {
+        this.state.following = account;
+        return this;
+    }
+    send() {
+        if (!this.state.follower || !this.state.following) {
+            throw new Error(`${this.mode}() builder requires follower and following before send()`);
+        }
+        if (this.mode === 'follow') {
+            return this.streamer.follow(this.state.follower, this.state.following);
+        }
+        if (this.mode === 'mute') {
+            return this.streamer.mute(this.state.follower, this.state.following);
+        }
+        return this.streamer.unfollow(this.state.follower, this.state.following);
+    }
+}
+exports.HiveFollowBuilder = HiveFollowBuilder;
+class HiveReblogBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    send() {
+        if (!this.state.account || !this.state.author || !this.state.permlink) {
+            throw new Error('reblog() builder requires account, author, and permlink before send()');
+        }
+        return this.streamer.reblog(this.state.account, this.state.author, this.state.permlink);
+    }
+}
+exports.HiveReblogBuilder = HiveReblogBuilder;
+class HivePowerUpBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    amount(amount) {
+        this.state.amount = utils_1.Utils.formatAmount(amount);
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount) {
+            throw new Error('powerUp() builder requires from and amount before send()');
+        }
+        return this.streamer.powerUp(this.state.from, this.state.to || this.state.from, this.state.amount);
+    }
+}
+exports.HivePowerUpBuilder = HivePowerUpBuilder;
+class HivePowerDownBuilder {
+    streamer;
+    cancel;
+    state = {};
+    constructor(streamer, cancel = false) {
+        this.streamer = streamer;
+        this.cancel = cancel;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    vestingShares(amount) {
+        this.state.vestingShares = amount;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('powerDown() builder requires account before send()');
+        }
+        if (this.cancel) {
+            return this.streamer.cancelPowerDown(this.state.account);
+        }
+        if (!this.state.vestingShares) {
+            throw new Error('powerDown() builder requires vestingShares before send()');
+        }
+        return this.streamer.powerDown(this.state.account, this.state.vestingShares);
+    }
+}
+exports.HivePowerDownBuilder = HivePowerDownBuilder;
+class HiveDelegateBuilder {
+    streamer;
+    undelegate;
+    state = {};
+    constructor(streamer, undelegate = false) {
+        this.streamer = streamer;
+        this.undelegate = undelegate;
+    }
+    delegator(account) {
+        this.state.delegator = account;
+        return this;
+    }
+    delegatee(account) {
+        this.state.delegatee = account;
+        return this;
+    }
+    vestingShares(amount) {
+        this.state.vestingShares = amount;
+        return this;
+    }
+    send() {
+        if (!this.state.delegator || !this.state.delegatee) {
+            throw new Error('delegate() builder requires delegator and delegatee before send()');
+        }
+        if (this.undelegate) {
+            return this.streamer.undelegateVestingShares(this.state.delegator, this.state.delegatee);
+        }
+        if (!this.state.vestingShares) {
+            throw new Error('delegate() builder requires vestingShares before send()');
+        }
+        return this.streamer.delegateVestingShares(this.state.delegator, this.state.delegatee, this.state.vestingShares);
+    }
+}
+exports.HiveDelegateBuilder = HiveDelegateBuilder;
+class HiveClaimRewardsBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    rewardHive(amount) {
+        this.state.rewardHive = amount;
+        return this;
+    }
+    rewardHbd(amount) {
+        this.state.rewardHbd = amount;
+        return this;
+    }
+    rewardVests(amount) {
+        this.state.rewardVests = amount;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('claimRewards() builder requires account before send()');
+        }
+        return this.streamer.claimRewards(this.state.account, this.state.rewardHive || '0.000 HIVE', this.state.rewardHbd || '0.000 HBD', this.state.rewardVests || '0.000000 VESTS');
+    }
+}
+exports.HiveClaimRewardsBuilder = HiveClaimRewardsBuilder;
+class HiveWitnessVoteBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    witness(account) {
+        this.state.witness = account;
+        return this;
+    }
+    approve(value = true) {
+        this.state.approve = value;
+        return this;
+    }
+    unapprove() {
+        return this.approve(false);
+    }
+    send() {
+        if (!this.state.account || !this.state.witness) {
+            throw new Error('witnessVote() builder requires account and witness before send()');
+        }
+        return this.streamer.witnessVote(this.state.account, this.state.witness, this.state.approve !== false);
+    }
+}
+exports.HiveWitnessVoteBuilder = HiveWitnessVoteBuilder;
+class HiveSetProxyBuilder {
+    streamer;
+    clear;
+    state = {};
+    constructor(streamer, clear = false) {
+        this.streamer = streamer;
+        this.clear = clear;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    proxy(account) {
+        this.state.proxy = account;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('setProxy() builder requires account before send()');
+        }
+        if (this.clear) {
+            return this.streamer.clearProxy(this.state.account);
+        }
+        if (!this.state.proxy) {
+            throw new Error('setProxy() builder requires proxy before send()');
+        }
+        return this.streamer.setProxy(this.state.account, this.state.proxy);
+    }
+}
+exports.HiveSetProxyBuilder = HiveSetProxyBuilder;
+class HiveUpdateProfileBuilder {
+    streamer;
+    state = { profile: {} };
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    account(account) {
+        this.state.account = account;
+        return this;
+    }
+    name(value) {
+        this.state.profile.name = value;
+        return this;
+    }
+    about(value) {
+        this.state.profile.about = value;
+        return this;
+    }
+    location(value) {
+        this.state.profile.location = value;
+        return this;
+    }
+    website(value) {
+        this.state.profile.website = value;
+        return this;
+    }
+    profileImage(url) {
+        this.state.profile.profile_image = url;
+        return this;
+    }
+    coverImage(url) {
+        this.state.profile.cover_image = url;
+        return this;
+    }
+    set(key, value) {
+        this.state.profile[key] = value;
+        return this;
+    }
+    send() {
+        if (!this.state.account) {
+            throw new Error('updateProfile() builder requires account before send()');
+        }
+        if (Object.keys(this.state.profile).length === 0) {
+            throw new Error('updateProfile() builder requires at least one profile field before send()');
+        }
+        return this.streamer.updateProfile(this.state.account, this.state.profile);
+    }
+}
+exports.HiveUpdateProfileBuilder = HiveUpdateProfileBuilder;
+class HiveSavingsTransferBuilder {
+    streamer;
+    direction;
+    state = {};
+    constructor(streamer, direction) {
+        this.streamer = streamer;
+        this.direction = direction;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        const parsed = parseAssetInput(amount, symbol);
+        this.state.amount = parsed.amount;
+        this.state.symbol = parsed.symbol;
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    memo(memo) {
+        this.state.memo = memo;
+        return this;
+    }
+    requestId(id) {
+        this.state.requestId = id;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount || !this.state.symbol) {
+            throw new Error(`${this.direction === 'to' ? 'transferToSavings' : 'transferFromSavings'}() builder requires from and amount before send()`);
+        }
+        const to = this.state.to || this.state.from;
+        if (this.direction === 'to') {
+            return this.streamer.transferToSavings(this.state.from, to, this.state.amount, this.state.symbol, this.state.memo || '');
+        }
+        return this.streamer.transferFromSavings(this.state.from, to, this.state.amount, this.state.symbol, this.state.requestId || 0, this.state.memo || '');
+    }
+}
+exports.HiveSavingsTransferBuilder = HiveSavingsTransferBuilder;
+class HiveConvertBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        this.state.amount = buildAssetAmount(amount, symbol || 'HBD');
+        return this;
+    }
+    hbd(amount) {
+        return this.amount(amount, 'HBD');
+    }
+    requestId(id) {
+        this.state.requestId = id;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount) {
+            throw new Error('convert() builder requires from and amount before send()');
+        }
+        return this.streamer.convert(this.state.from, this.state.amount, this.state.requestId || 0);
+    }
+}
+exports.HiveConvertBuilder = HiveConvertBuilder;
+class HiveCollateralizedConvertBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    amount(amount, symbol) {
+        this.state.amount = buildAssetAmount(amount, symbol || 'HIVE');
+        return this;
+    }
+    hive(amount) {
+        return this.amount(amount, 'HIVE');
+    }
+    requestId(id) {
+        this.state.requestId = id;
+        return this;
+    }
+    send() {
+        if (!this.state.from || !this.state.amount) {
+            throw new Error('collateralizedConvert() builder requires from and amount before send()');
+        }
+        return this.streamer.collateralizedConvert(this.state.from, this.state.amount, this.state.requestId || 0);
+    }
+}
+exports.HiveCollateralizedConvertBuilder = HiveCollateralizedConvertBuilder;
+class HiveDeleteCommentBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    send() {
+        if (!this.state.author || !this.state.permlink) {
+            throw new Error('deleteComment() builder requires author and permlink before send()');
+        }
+        return this.streamer.deleteComment(this.state.author, this.state.permlink);
+    }
+}
+exports.HiveDeleteCommentBuilder = HiveDeleteCommentBuilder;
+class HiveLimitOrderBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    owner(account) {
+        this.state.owner = account;
+        return this;
+    }
+    orderId(id) {
+        this.state.orderId = id;
+        return this;
+    }
+    amountToSell(amount, symbol) {
+        this.state.amountToSell = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    minToReceive(amount, symbol) {
+        this.state.minToReceive = buildAssetAmount(amount, symbol);
+        return this;
+    }
+    fillOrKill(value = true) {
+        this.state.fillOrKill = value;
+        return this;
+    }
+    expiration(value) {
+        this.state.expiration = value;
+        return this;
+    }
+    send(signingKeys) {
+        if (!this.state.owner || !this.state.amountToSell || !this.state.minToReceive) {
+            throw new Error('limitOrder() builder requires owner, amountToSell, and minToReceive before send()');
+        }
+        return this.streamer.limitOrderCreate(this.state.owner, this.state.orderId || Math.floor(Date.now() / 1000), this.state.amountToSell, this.state.minToReceive, this.state.fillOrKill || false, this.state.expiration, signingKeys);
+    }
+}
+exports.HiveLimitOrderBuilder = HiveLimitOrderBuilder;
+class HiveCancelOrderBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    owner(account) {
+        this.state.owner = account;
+        return this;
+    }
+    orderId(id) {
+        this.state.orderId = id;
+        return this;
+    }
+    send(signingKeys) {
+        if (!this.state.owner || this.state.orderId === undefined) {
+            throw new Error('cancelOrder() builder requires owner and orderId before send()');
+        }
+        return this.streamer.limitOrderCancel(this.state.owner, this.state.orderId, signingKeys);
+    }
+}
+exports.HiveCancelOrderBuilder = HiveCancelOrderBuilder;
+class HiveWithdrawRouteBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) {
+        this.state.from = account;
+        return this;
+    }
+    to(account) {
+        this.state.to = account;
+        return this;
+    }
+    percent(value) {
+        this.state.percent = value;
+        return this;
+    }
+    autoVest(value = true) {
+        this.state.autoVest = value;
+        return this;
+    }
+    send(signingKeys) {
+        if (!this.state.from || !this.state.to || this.state.percent === undefined) {
+            throw new Error('withdrawRoute() builder requires from, to, and percent before send()');
+        }
+        return this.streamer.setWithdrawVestingRoute(this.state.from, this.state.to, this.state.percent, this.state.autoVest || false, signingKeys);
+    }
+}
+exports.HiveWithdrawRouteBuilder = HiveWithdrawRouteBuilder;
+class HiveCommentOptionsBuilder {
+    streamer;
+    state = { beneficiaries: [] };
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    maxAcceptedPayout(amount, symbol) {
+        this.state.maxAcceptedPayout = buildAssetAmount(amount, symbol || 'HBD');
+        return this;
+    }
+    percentHbd(value) {
+        this.state.percentHbd = value;
+        return this;
+    }
+    allowVotes(value = true) {
+        this.state.allowVotes = value;
+        return this;
+    }
+    allowCurationRewards(value = true) {
+        this.state.allowCurationRewards = value;
+        return this;
+    }
+    beneficiary(account, weight) {
+        this.state.beneficiaries.push({ account, weight });
+        return this;
+    }
+    send() {
+        if (!this.state.author || !this.state.permlink) {
+            throw new Error('commentOptions() builder requires author and permlink before send()');
+        }
+        const extensions = [];
+        if (this.state.beneficiaries.length > 0) {
+            extensions.push([0, { beneficiaries: this.state.beneficiaries }]);
+        }
+        return this.streamer.commentOptions(this.state.author, this.state.permlink, {
+            max_accepted_payout: this.state.maxAcceptedPayout,
+            percent_hbd: this.state.percentHbd,
+            allow_votes: this.state.allowVotes,
+            allow_curation_rewards: this.state.allowCurationRewards,
+            extensions
+        });
+    }
+}
+exports.HiveCommentOptionsBuilder = HiveCommentOptionsBuilder;
+class HivePostBuilder {
+    streamer;
+    state = {
+        tags: [],
+        parentAuthor: '',
+        parentPermlink: '',
+        beneficiaries: [],
+        appName: 'hive-stream',
+        formatType: 'markdown',
+        images: [],
+        extraMetadata: {}
+    };
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    author(account) {
+        this.state.author = account;
+        return this;
+    }
+    title(value) {
+        this.state.title = value;
+        return this;
+    }
+    body(value) {
+        this.state.body = value;
+        return this;
+    }
+    permlink(value) {
+        this.state.permlink = value;
+        return this;
+    }
+    tags(...tags) {
+        this.state.tags = tags.map(t => t.trim().toLowerCase()).filter(Boolean);
+        return this;
+    }
+    community(name) {
+        this.state.communityName = name;
+        return this;
+    }
+    parentAuthor(account) {
+        this.state.parentAuthor = account;
+        return this;
+    }
+    parentPermlink(value) {
+        this.state.parentPermlink = value;
+        return this;
+    }
+    beneficiary(account, weight) {
+        this.state.beneficiaries.push({ account, weight });
+        return this;
+    }
+    maxAcceptedPayout(amount, symbol) {
+        this.state.maxAcceptedPayout = buildAssetAmount(amount, symbol || 'HBD');
+        return this;
+    }
+    percentHbd(value) {
+        this.state.percentHbd = value;
+        return this;
+    }
+    allowVotes(value = true) {
+        this.state.allowVotes = value;
+        return this;
+    }
+    allowCurationRewards(value = true) {
+        this.state.allowCurationRewards = value;
+        return this;
+    }
+    app(name) {
+        this.state.appName = name;
+        return this;
+    }
+    format(value) {
+        this.state.formatType = value;
+        return this;
+    }
+    description(value) {
+        this.state.descriptionText = value;
+        return this;
+    }
+    image(...urls) {
+        this.state.images.push(...urls);
+        return this;
+    }
+    metadata(key, value) {
+        this.state.extraMetadata[key] = value;
+        return this;
+    }
+    send() {
+        if (!this.state.author) {
+            throw new Error('post() builder requires author before send()');
+        }
+        if (!this.state.body) {
+            throw new Error('post() builder requires body before send()');
+        }
+        const isReply = !!this.state.parentAuthor;
+        // Generate permlink if not provided
+        const permlink = this.state.permlink
+            || (isReply
+                ? utils_1.Utils.generateReplyPermlink(this.state.parentPermlink)
+                : utils_1.Utils.generatePermlink(this.state.title || 'untitled'));
+        // Determine parent_permlink for top-level posts
+        let parentPermlink = this.state.parentPermlink;
+        if (!isReply) {
+            if (this.state.communityName) {
+                parentPermlink = this.state.communityName;
+            }
+            else if (this.state.tags.length > 0) {
+                parentPermlink = this.state.tags[0];
+            }
+            else {
+                parentPermlink = 'hive-stream';
+            }
+        }
+        // Build json_metadata
+        const jsonMetadata = utils_1.Utils.createPostMetadata({
+            tags: this.state.tags,
+            image: this.state.images.length > 0 ? this.state.images : utils_1.Utils.extractImagesFromBody(this.state.body),
+            app: this.state.appName,
+            format: this.state.formatType,
+            description: this.state.descriptionText,
+            ...this.state.extraMetadata
+        });
+        // Build the comment operation
+        const commentOp = ['comment', {
+                parent_author: this.state.parentAuthor,
+                parent_permlink: parentPermlink,
+                author: this.state.author,
+                permlink,
+                title: this.state.title || '',
+                body: this.state.body,
+                json_metadata: jsonMetadata
+            }];
+        // Check if we need comment_options
+        const needsOptions = this.state.beneficiaries.length > 0
+            || this.state.maxAcceptedPayout !== undefined
+            || this.state.percentHbd !== undefined
+            || this.state.allowVotes !== undefined
+            || this.state.allowCurationRewards !== undefined;
+        if (!needsOptions) {
+            return this.streamer.broadcastOperations([commentOp]);
+        }
+        // Build comment_options operation
+        const extensions = [];
+        if (this.state.beneficiaries.length > 0) {
+            const sorted = [...this.state.beneficiaries].sort((a, b) => a.account.localeCompare(b.account));
+            extensions.push([0, { beneficiaries: sorted }]);
+        }
+        const commentOptionsOp = ['comment_options', {
+                author: this.state.author,
+                permlink,
+                max_accepted_payout: this.state.maxAcceptedPayout || '1000000.000 HBD',
+                percent_hbd: this.state.percentHbd !== undefined ? this.state.percentHbd : 10000,
+                allow_votes: this.state.allowVotes !== false,
+                allow_curation_rewards: this.state.allowCurationRewards !== false,
+                extensions
+            }];
+        // Broadcast both atomically
+        return this.streamer.broadcastOperations([commentOp, commentOptionsOp]);
+    }
+}
+exports.HivePostBuilder = HivePostBuilder;
+class HiveBatchBuilder {
+    streamer;
+    operations = [];
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    add(operation) {
+        this.operations.push(operation);
+        return this;
+    }
+    transfer(from, to, amount, memo = '') {
+        this.operations.push(['transfer', { from, to, amount, memo }]);
+        return this;
+    }
+    vote(voter, author, permlink, weight) {
+        this.operations.push(['vote', { voter, author, permlink, weight }]);
+        return this;
+    }
+    customJson(id, json, postingAuth, activeAuth) {
+        const jsonStr = typeof json === 'string' ? json : JSON.stringify(json);
+        this.operations.push(['custom_json', {
+                required_auths: activeAuth ? [activeAuth] : [],
+                required_posting_auths: postingAuth ? [postingAuth] : [],
+                id,
+                json: jsonStr
+            }]);
+        return this;
+    }
+    comment(author, permlink, parentAuthor, parentPermlink, title, body, jsonMetadata = '{}') {
+        this.operations.push(['comment', {
+                parent_author: parentAuthor,
+                parent_permlink: parentPermlink,
+                author,
+                permlink,
+                title,
+                body,
+                json_metadata: jsonMetadata
+            }]);
+        return this;
+    }
+    send(signingKeys) {
+        if (this.operations.length === 0) {
+            throw new Error('batch() builder requires at least one operation before send()');
+        }
+        return this.streamer.broadcastOperations(this.operations, signingKeys);
+    }
+}
+exports.HiveBatchBuilder = HiveBatchBuilder;
+class HiveEngineStakeBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) { this.state.from = account; return this; }
+    to(account) { this.state.to = account; return this; }
+    symbol(symbol) { this.state.symbol = symbol; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    send() {
+        if (!this.state.from || !this.state.symbol || !this.state.quantity) {
+            throw new Error('stakeEngine() builder requires from, symbol, and quantity before send()');
+        }
+        return this.streamer.stakeEngineTokens(this.state.from, this.state.to || this.state.from, this.state.symbol, this.state.quantity);
+    }
+}
+exports.HiveEngineStakeBuilder = HiveEngineStakeBuilder;
+class HiveEngineUnstakeBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) { this.state.from = account; return this; }
+    symbol(symbol) { this.state.symbol = symbol; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    send() {
+        if (!this.state.from || !this.state.symbol || !this.state.quantity) {
+            throw new Error('unstakeEngine() builder requires from, symbol, and quantity before send()');
+        }
+        return this.streamer.unstakeEngineTokens(this.state.from, this.state.symbol, this.state.quantity);
+    }
+}
+exports.HiveEngineUnstakeBuilder = HiveEngineUnstakeBuilder;
+class HiveEngineMarketOrderBuilder {
+    streamer;
+    side;
+    state = {};
+    constructor(streamer, side) {
+        this.streamer = streamer;
+        this.side = side;
+    }
+    from(account) { this.state.from = account; return this; }
+    symbol(symbol) { this.state.symbol = symbol; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    price(price) { this.state.price = String(price); return this; }
+    send() {
+        if (!this.state.from || !this.state.symbol || !this.state.quantity || !this.state.price) {
+            throw new Error(`${this.side}Engine() builder requires from, symbol, quantity, and price before send()`);
+        }
+        if (this.side === 'buy') {
+            return this.streamer.buyEngineTokens(this.state.from, this.state.symbol, this.state.quantity, this.state.price);
+        }
+        return this.streamer.sellEngineTokens(this.state.from, this.state.symbol, this.state.quantity, this.state.price);
+    }
+}
+exports.HiveEngineMarketOrderBuilder = HiveEngineMarketOrderBuilder;
+class HiveEngineCancelOrderBuilder {
+    streamer;
+    state = {};
+    constructor(streamer) {
+        this.streamer = streamer;
+    }
+    from(account) { this.state.from = account; return this; }
+    type(type) { this.state.type = type; return this; }
+    orderId(id) { this.state.orderId = id; return this; }
+    send() {
+        if (!this.state.from || !this.state.type || !this.state.orderId) {
+            throw new Error('cancelEngineOrder() builder requires from, type, and orderId before send()');
+        }
+        return this.streamer.cancelEngineOrder(this.state.from, this.state.type, this.state.orderId);
+    }
+}
+exports.HiveEngineCancelOrderBuilder = HiveEngineCancelOrderBuilder;
+class HiveEngineDelegateBuilder {
+    streamer;
+    undelegate;
+    state = {};
+    constructor(streamer, undelegate = false) {
+        this.streamer = streamer;
+        this.undelegate = undelegate;
+    }
+    from(account) { this.state.from = account; return this; }
+    to(account) { this.state.to = account; return this; }
+    symbol(symbol) { this.state.symbol = symbol; return this; }
+    quantity(quantity) { this.state.quantity = String(quantity); return this; }
+    send() {
+        if (!this.state.from || !this.state.to || !this.state.symbol || !this.state.quantity) {
+            throw new Error(`${this.undelegate ? 'undelegateEngine' : 'delegateEngine'}() builder requires from, to, symbol, and quantity before send()`);
+        }
+        if (this.undelegate) {
+            return this.streamer.undelegateEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity);
+        }
+        return this.streamer.delegateEngineTokens(this.state.from, this.state.to, this.state.symbol, this.state.quantity);
+    }
+}
+exports.HiveEngineDelegateBuilder = HiveEngineDelegateBuilder;
+class HiveCommunityOperationBuilder {
+    streamer;
+    action;
+    state = {};
+    constructor(streamer, action) {
+        this.streamer = streamer;
+        this.action = action;
+    }
+    account(account) { this.state.account = account; return this; }
+    community(name) { this.state.community = name; return this; }
+    send() {
+        if (!this.state.account || !this.state.community) {
+            throw new Error(`${this.action}Community() builder requires account and community before send()`);
+        }
+        if (this.action === 'subscribe') {
+            return this.streamer.subscribeCommunity(this.state.account, this.state.community);
+        }
+        return this.streamer.unsubscribeCommunity(this.state.account, this.state.community);
+    }
+}
+exports.HiveCommunityOperationBuilder = HiveCommunityOperationBuilder;
+//# sourceMappingURL=builders.js.map