@trust-ethos/cli 0.0.5

package/dist/lib/api/echo-client.js

@@ -0,0 +1,408 @@
+import { APIError, NetworkError, NotFoundError } from '../errors/cli-error.js';
+import { parseIdentifier } from '../validation/userkey.js';
+import { loadConfig } from '../config/index.js';
+export class EchoClient {
+    baseUrl;
+    debug;
+    constructor() {
+        const config = loadConfig();
+        this.baseUrl = config.apiUrl;
+        this.debug = process.env.DEBUG === 'ethos:*';
+    }
+    log(message, data) {
+        if (this.debug) {
+            console.error(`[DEBUG] ${message}`, data || '');
+        }
+    }
+    async request(path, resourceType, options) {
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000);
+        this.log(`Fetching ${url}`);
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'Accept': 'application/json',
+                    'X-Ethos-Client': 'ethos-cli',
+                    ...(options?.body ? { 'Content-Type': 'application/json' } : {}),
+                },
+                signal: controller.signal,
+                ...options,
+            });
+            this.log(`Response status: ${response.status}`);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    const identifier = path.split('/').pop() || 'unknown';
+                    throw new NotFoundError(resourceType || 'Resource', decodeURIComponent(identifier));
+                }
+                let errorMessage = `API request failed with status ${response.status}`;
+                let errorBody;
+                const responseText = await response.text();
+                try {
+                    errorBody = JSON.parse(responseText);
+                    errorMessage = errorBody.message || errorBody.error || errorMessage;
+                }
+                catch {
+                    if (responseText)
+                        errorMessage = responseText;
+                }
+                this.log('API Error', { status: response.status, body: errorBody });
+                throw new APIError(errorMessage, response.status, errorBody);
+            }
+            const data = await response.json();
+            this.log('Response data', data);
+            return data;
+        }
+        catch (error) {
+            if (error instanceof NotFoundError || error instanceof APIError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                this.log('Network error', error.message);
+                if (error.name === 'AbortError') {
+                    throw new NetworkError('Request timed out after 10 seconds', url);
+                }
+                if (error.message.includes('fetch failed') ||
+                    error.message.includes('ECONNREFUSED') ||
+                    error.message.includes('ENOTFOUND')) {
+                    throw new NetworkError(`Cannot connect to API at ${this.baseUrl}`, url);
+                }
+                throw new NetworkError(error.message, url);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async getUserByTwitter(username) {
+        return this.request(`/api/v2/user/by/x/${encodeURIComponent(username)}`, 'User');
+    }
+    async getUserByAddress(address) {
+        return this.request(`/api/v2/user/by/address/${encodeURIComponent(address)}`, 'User');
+    }
+    async getUserByProfileId(profileId) {
+        return this.request(`/api/v2/user/by/profile-id/${encodeURIComponent(profileId)}`, 'User');
+    }
+    async searchUsers(query, limit = 10) {
+        const params = new URLSearchParams({ query, limit: String(limit) });
+        return this.request(`/api/v2/users/search?${params}`, 'Users');
+    }
+    async resolveUser(identifier) {
+        const parsed = parseIdentifier(identifier);
+        return this.resolveUserFromParsed(parsed);
+    }
+    async resolveUserFromParsed(parsed) {
+        switch (parsed.type) {
+            case 'address':
+                return this.getUserByAddress(parsed.value);
+            case 'ens':
+                return this.resolveEnsUser(parsed.value);
+            case 'profileId':
+                return this.getUserByProfileId(parsed.value);
+            case 'twitter':
+            default:
+                return this.getUserByTwitter(parsed.value);
+        }
+    }
+    async resolveEnsUser(ensName) {
+        const searchResult = await this.searchUsers(ensName, 5);
+        const exactMatch = searchResult.values.find(u => u.displayName?.toLowerCase() === ensName.toLowerCase() ||
+            u.username?.toLowerCase() === ensName.toLowerCase());
+        if (exactMatch)
+            return exactMatch;
+        const addressMatch = searchResult.values.find(u => u.userkeys?.some(uk => uk.startsWith('address:')));
+        if (addressMatch)
+            return addressMatch;
+        if (searchResult.values.length > 0) {
+            return searchResult.values[0];
+        }
+        throw new NotFoundError('User', ensName);
+    }
+    async getXpTotal(userkey) {
+        return this.request(`/api/v2/xp/user/${encodeURIComponent(userkey)}`, 'XP Balance');
+    }
+    async getSeasons() {
+        return this.request('/api/v2/xp/seasons', 'XP Seasons');
+    }
+    async getLeaderboardRank(userkey) {
+        return this.request(`/api/v2/xp/user/${encodeURIComponent(userkey)}/leaderboard-rank`, 'Leaderboard Rank');
+    }
+    async getXpBySeason(userkey, seasonId) {
+        return this.request(`/api/v2/xp/user/${encodeURIComponent(userkey)}/season/${seasonId}`, 'XP for Season');
+    }
+    async getActivities(userkey, types = ['review', 'vouch'], limit = 10) {
+        const params = new URLSearchParams({ userkey, limit: String(limit) });
+        for (const type of types) {
+            params.append('activityType', type);
+        }
+        return this.request(`/api/v2/activities/userkey?${params}`, 'Activities');
+    }
+    getPrimaryUserkey(user) {
+        if (user.profileId) {
+            return `profileId:${user.profileId}`;
+        }
+        const addressKey = user.userkeys?.find(uk => uk.startsWith('address:'));
+        if (addressKey)
+            return addressKey;
+        return user.userkeys?.[0] || null;
+    }
+    /** @deprecated Use resolveUser instead */
+    async getUserByUsername(username) {
+        return this.getUserByTwitter(username);
+    }
+    /** @deprecated Use getXpTotal instead */
+    async getTotalXp(userkey) {
+        return this.getXpTotal(userkey);
+    }
+    async getSlashes(params = {}) {
+        const query = new URLSearchParams();
+        if (params.author)
+            query.set('author', params.author);
+        if (params.subject)
+            query.set('subject', params.subject);
+        if (params.status)
+            query.set('status', params.status);
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        const path = `/api/v1/slashes${query.toString() ? '?' + query.toString() : ''}`;
+        return this.request(path, 'Slashes');
+    }
+    async getSlashRoles(slashId, profileIds) {
+        const query = new URLSearchParams();
+        profileIds.forEach(id => query.append('profileId', String(id)));
+        return this.request(`/api/v1/slashes/${slashId}/roles?${query.toString()}`, 'Slash Roles');
+    }
+    async getBrokerPosts(params = {}) {
+        const query = new URLSearchParams();
+        if (params.type)
+            query.set('type', params.type);
+        if (params.search)
+            query.set('search', params.search);
+        if (params.sortBy)
+            query.set('sortBy', params.sortBy);
+        if (params.minScore)
+            query.set('minScore', String(params.minScore));
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        const path = `/api/v2/broker/posts${query.toString() ? '?' + query.toString() : ''}`;
+        return this.request(path, 'Broker Posts');
+    }
+    async getBrokerPost(id) {
+        return this.request(`/api/v2/broker/posts/${id}`, 'Broker Post');
+    }
+    async getBrokerPostsByAuthor(profileId, params = {}) {
+        const query = new URLSearchParams();
+        if (params.type)
+            query.set('type', params.type);
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        const path = `/api/v2/broker/author/${profileId}/posts${query.toString() ? '?' + query.toString() : ''}`;
+        return this.request(path, 'Author Posts');
+    }
+    async getProjects(params = {}) {
+        const query = new URLSearchParams();
+        if (params.status)
+            params.status.forEach(s => query.append('status[]', s));
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        return this.request(`/api/v2/projects${query.toString() ? '?' + query.toString() : ''}`, 'Projects');
+    }
+    async getProjectDetails(projectId) {
+        return this.request(`/api/v2/projects/${projectId}/details`, 'Project');
+    }
+    async getProjectByUsername(username) {
+        return this.request(`/api/v2/projects/username/${encodeURIComponent(username)}`, 'Project');
+    }
+    async getProjectVoters(projectId, params = {}) {
+        const query = new URLSearchParams();
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        if (params.sentiment)
+            query.set('sentiment', params.sentiment);
+        return this.request(`/api/v2/projects/${projectId}/voters${query.toString() ? '?' + query.toString() : ''}`, 'Voters');
+    }
+    async getProjectTeam(projectId) {
+        return this.request(`/api/v2/projects/${projectId}/team`, 'Team');
+    }
+    async getNftsForUser(userkey, params = {}) {
+        const query = new URLSearchParams();
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        const path = `/api/v2/nfts/user/${encodeURIComponent(userkey)}${query.toString() ? '?' + query.toString() : ''}`;
+        return this.request(path, 'User NFTs');
+    }
+    async checkValidatorOwnership(userkey) {
+        return this.request(`/api/v2/nfts/user/${encodeURIComponent(userkey)}/owns-validator`, 'Validator Check');
+    }
+    async getValidatorListings(params = {}) {
+        const query = new URLSearchParams();
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        const path = `/api/v2/nfts/validators/listings${query.toString() ? '?' + query.toString() : ''}`;
+        return this.request(path, 'Validator Listings');
+    }
+    async getAuctions(params = {}) {
+        const query = new URLSearchParams();
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        if (params.status)
+            query.set('status', params.status);
+        const path = `/api/v2/auctions${query.toString() ? '?' + query.toString() : ''}`;
+        return this.request(path, 'Auctions');
+    }
+    async getActiveAuction() {
+        return this.request('/api/v2/auctions/active', 'Active Auction');
+    }
+    async getAuction(auctionId) {
+        return this.request(`/api/v2/auctions/${auctionId}`, 'Auction');
+    }
+    async getMarkets(params = {}) {
+        const query = new URLSearchParams();
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        if (params.orderBy)
+            query.set('orderBy', params.orderBy);
+        if (params.orderDirection)
+            query.set('orderDirection', params.orderDirection);
+        if (params.filterQuery)
+            query.set('filterQuery', params.filterQuery);
+        return this.request(`/api/v2/markets${query.toString() ? '?' + query.toString() : ''}`, 'Markets');
+    }
+    async getFeaturedMarkets() {
+        return this.request('/api/v2/markets/featured', 'Featured Markets');
+    }
+    async getMarketInfo(profileId) {
+        return this.request(`/api/v2/markets/${profileId}/info`, 'Market Info', {
+            method: 'POST',
+            body: JSON.stringify({ profileId, includeTopHolders: true, includeMarketChange: true }),
+        });
+    }
+    async getMarketHolders(profileId, params = {}) {
+        const query = new URLSearchParams();
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        return this.request(`/api/v2/markets/${profileId}/holders${query.toString() ? '?' + query.toString() : ''}`, 'Market Holders');
+    }
+    async getMarketByTwitter(username) {
+        return this.request(`/api/v2/markets/users/by/x/${encodeURIComponent(username)}`, 'Market User');
+    }
+    async getScoreBreakdownByUserkey(userkey) {
+        const params = new URLSearchParams({ userkey });
+        return this.request(`/api/v1/score/userkey?${params}`, 'Score');
+    }
+    async getScoreBreakdownByAddress(address) {
+        const params = new URLSearchParams({ address });
+        return this.request(`/api/v1/score/address?${params}`, 'Score');
+    }
+    convertScoreToLevel(score) {
+        if (score < 800)
+            return 'untrusted';
+        if (score < 1200)
+            return 'questionable';
+        if (score < 1600)
+            return 'neutral';
+        if (score < 2000)
+            return 'reputable';
+        return 'exemplary';
+    }
+    async getScoreStatus(userkey) {
+        const params = new URLSearchParams({ userkey });
+        return this.request(`/api/v2/score/status?${params}`, 'Score Status');
+    }
+    async getVouches(params = {}) {
+        const body = {};
+        if (params.ids)
+            body.ids = params.ids;
+        if (params.subjectUserkeys)
+            body.subjectUserkeys = params.subjectUserkeys;
+        if (params.authorProfileIds)
+            body.authorProfileIds = params.authorProfileIds;
+        if (params.subjectProfileIds)
+            body.subjectProfileIds = params.subjectProfileIds;
+        if (params.archived !== undefined)
+            body.archived = params.archived;
+        if (params.limit)
+            body.limit = params.limit;
+        if (params.offset)
+            body.offset = params.offset;
+        const response = await this.request('/api/v1/vouches', 'Vouches', {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+        return response.data;
+    }
+    async getMutualVouchers(viewerProfileId, targetProfileId, params = {}) {
+        const query = new URLSearchParams();
+        query.set('viewerProfileId', String(viewerProfileId));
+        query.set('targetProfileId', String(targetProfileId));
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        return this.request(`/api/v2/vouches/mutual-vouchers?${query}`, 'Mutual Vouchers');
+    }
+    async getVotes(activityId, type, params = {}) {
+        const query = new URLSearchParams();
+        query.set('activityId', String(activityId));
+        query.set('type', type);
+        if (params.isUpvote !== undefined)
+            query.set('isUpvote', String(params.isUpvote));
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        return this.request(`/api/v2/votes?${query}`, 'Votes');
+    }
+    async getVoteStats(activityId, type) {
+        const query = new URLSearchParams();
+        query.set('activityId', String(activityId));
+        query.set('type', type);
+        return this.request(`/api/v2/votes/stats?${query}`, 'Vote Stats');
+    }
+    async getValidators() {
+        return this.request('/api/v2/xp/validators', 'Validators');
+    }
+    async getValidatorByTokenId(tokenId) {
+        const validators = await this.getValidators();
+        return validators.find(v => v.tokenId === tokenId) || null;
+    }
+    async getReview(reviewId) {
+        return this.request(`/api/v2/activities/review/${reviewId}`, 'Review');
+    }
+    async getReviewsForUser(userkey, params = {}) {
+        const query = new URLSearchParams({ userkey });
+        query.append('activityType', 'review');
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        return this.request(`/api/v2/activities/userkey?${query}`, 'Reviews');
+    }
+    async getInvitations(params = {}) {
+        const query = new URLSearchParams();
+        if (params.senderProfileId)
+            query.set('senderProfileId', String(params.senderProfileId));
+        if (params.status)
+            query.set('status', params.status);
+        if (params.limit)
+            query.set('limit', String(params.limit));
+        if (params.offset)
+            query.set('offset', String(params.offset));
+        return this.request(`/api/v2/invitations${query.toString() ? '?' + query.toString() : ''}`, 'Invitations');
+    }
+}

package/dist/lib/config/index.d.ts

@@ -0,0 +1,6 @@
+export interface EthosConfig {
+    apiUrl: string;
+}
+export declare function loadConfig(): EthosConfig;
+export declare function saveConfig(config: Partial<EthosConfig>): void;
+export declare function getConfigPath(): string;

package/dist/lib/config/index.js

@@ -0,0 +1,32 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+const DEFAULT_API_URL = 'https://api.ethos.network';
+const CONFIG_PATH = join(homedir(), '.config', 'ethos', 'config.json');
+export function loadConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return { apiUrl: DEFAULT_API_URL };
+    }
+    try {
+        const content = readFileSync(CONFIG_PATH, 'utf-8');
+        const parsed = JSON.parse(content);
+        return {
+            apiUrl: parsed.apiUrl || DEFAULT_API_URL,
+        };
+    }
+    catch {
+        return { apiUrl: DEFAULT_API_URL };
+    }
+}
+export function saveConfig(config) {
+    const current = loadConfig();
+    const updated = { ...current, ...config };
+    const dir = dirname(CONFIG_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(CONFIG_PATH, JSON.stringify(updated, null, 2) + '\n');
+}
+export function getConfigPath() {
+    return CONFIG_PATH;
+}

package/dist/lib/errors/cli-error.d.ts

@@ -0,0 +1,23 @@
+export declare class CLIError extends Error {
+    readonly code: string;
+    readonly suggestions: string[];
+    constructor(message: string, code: string, suggestions?: string[]);
+}
+export declare class NetworkError extends CLIError {
+    readonly url?: string | undefined;
+    readonly statusCode?: number | undefined;
+    constructor(message: string, url?: string | undefined, statusCode?: number | undefined);
+}
+export declare class NotFoundError extends CLIError {
+    readonly identifier: string;
+    constructor(resourceType: string, identifier: string);
+}
+export declare class ValidationError extends CLIError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class APIError extends CLIError {
+    readonly statusCode?: number | undefined;
+    readonly response?: unknown | undefined;
+    constructor(message: string, statusCode?: number | undefined, response?: unknown | undefined);
+}

package/dist/lib/errors/cli-error.js

@@ -0,0 +1,57 @@
+export class CLIError extends Error {
+    code;
+    suggestions;
+    constructor(message, code, suggestions = []) {
+        super(message);
+        this.code = code;
+        this.suggestions = suggestions;
+        this.name = 'CLIError';
+    }
+}
+export class NetworkError extends CLIError {
+    url;
+    statusCode;
+    constructor(message, url, statusCode) {
+        super(message, 'NETWORK_ERROR', [
+            'Check your internet connection',
+            'Verify the API is accessible',
+            'Try again in a few moments',
+        ]);
+        this.url = url;
+        this.statusCode = statusCode;
+        this.name = 'NetworkError';
+    }
+}
+export class NotFoundError extends CLIError {
+    identifier;
+    constructor(resourceType, identifier) {
+        super(`${resourceType} not found: ${identifier}`, 'NOT_FOUND', [
+            `Try: ethos user search "${identifier}"`,
+            'For Twitter users, use their Twitter username (e.g., @username)',
+            'For ETH addresses, use the full 0x... address',
+        ]);
+        this.name = 'NotFoundError';
+        this.identifier = identifier;
+    }
+}
+export class ValidationError extends CLIError {
+    field;
+    constructor(message, field) {
+        super(message, 'VALIDATION_ERROR', ['Check your input and try again']);
+        this.field = field;
+        this.name = 'ValidationError';
+    }
+}
+export class APIError extends CLIError {
+    statusCode;
+    response;
+    constructor(message, statusCode, response) {
+        super(message, 'API_ERROR', [
+            'The API returned an error',
+            'Try again or contact support if the issue persists',
+        ]);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = 'APIError';
+    }
+}

package/dist/lib/formatting/colors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Custom color utilities for Ethos CLI branding
+ * Uses ANSI true color (24-bit) escape codes for precise colors
+ */
+/**
+ * Apply Ethos brand gray color (#C1C0B6) to text
+ * Uses ANSI true color escape codes (supported by most modern terminals)
+ */
+export declare function ethosGray(text: string): string;
+/**
+ * Apply Ethos brand gray as bold
+ */
+export declare function ethosGrayBold(text: string): string;

package/dist/lib/formatting/colors.js

@@ -0,0 +1,22 @@
+/**
+ * Custom color utilities for Ethos CLI branding
+ * Uses ANSI true color (24-bit) escape codes for precise colors
+ */
+// Ethos brand color: #C1C0B6 (warm gray/beige)
+// RGB: 193, 192, 182
+const ETHOS_GRAY_RGB = [193, 192, 182];
+/**
+ * Apply Ethos brand gray color (#C1C0B6) to text
+ * Uses ANSI true color escape codes (supported by most modern terminals)
+ */
+export function ethosGray(text) {
+    const [r, g, b] = ETHOS_GRAY_RGB;
+    return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+/**
+ * Apply Ethos brand gray as bold
+ */
+export function ethosGrayBold(text) {
+    const [r, g, b] = ETHOS_GRAY_RGB;
+    return `\x1b[1m\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}

package/dist/lib/formatting/error.d.ts

@@ -0,0 +1 @@
+export declare function formatError(error: Error, verbose?: boolean): string;

package/dist/lib/formatting/error.js

@@ -0,0 +1,64 @@
+import pc from 'picocolors';
+import { APIError, CLIError, NetworkError, NotFoundError, ValidationError } from '../errors/cli-error.js';
+export function formatError(error, verbose = false) {
+    const lines = [];
+    if (error instanceof NotFoundError) {
+        lines.push(pc.yellow('⚠ ') + pc.bold(error.message));
+    }
+    else if (error instanceof NetworkError) {
+        lines.push(pc.red('✖ ') + pc.bold('Network Error'));
+        lines.push('  ' + error.message);
+    }
+    else if (error instanceof ValidationError) {
+        lines.push(pc.yellow('⚠ ') + pc.bold('Validation Error'));
+        lines.push('  ' + error.message);
+    }
+    else if (error instanceof APIError) {
+        lines.push(pc.red('✖ ') + pc.bold('API Error'));
+        lines.push('  ' + error.message);
+        if (error.statusCode) {
+            lines.push('  ' + pc.dim(`Status: ${error.statusCode}`));
+        }
+    }
+    else {
+        lines.push(pc.red('✖ ') + pc.bold('Error'));
+        lines.push('  ' + error.message);
+    }
+    if (error instanceof CLIError && error.suggestions.length > 0) {
+        lines.push('');
+        for (const suggestion of error.suggestions) {
+            if (suggestion.startsWith('Try:')) {
+                lines.push(pc.cyan('💡 ' + suggestion));
+            }
+            else {
+                lines.push(pc.dim('• ' + suggestion));
+            }
+        }
+    }
+    if (verbose) {
+        lines.push('');
+        lines.push(pc.dim('Debug Information:'));
+        if (error instanceof NetworkError) {
+            if (error.url)
+                lines.push(pc.dim(`  URL: ${error.url}`));
+            if (error.statusCode)
+                lines.push(pc.dim(`  Status Code: ${error.statusCode}`));
+        }
+        if (error instanceof APIError && error.response) {
+            lines.push(pc.dim('  Response:'));
+            lines.push(pc.dim('  ' + JSON.stringify(error.response, null, 2).replace(/\n/g, '\n  ')));
+        }
+        if (error.stack) {
+            lines.push(pc.dim('  Stack Trace:'));
+            const stackLines = error.stack.split('\n').slice(1);
+            for (const line of stackLines) {
+                lines.push(pc.dim('  ' + line.trim()));
+            }
+        }
+    }
+    if (!verbose && !(error instanceof NotFoundError)) {
+        lines.push('');
+        lines.push(pc.dim('Run with --verbose for more details'));
+    }
+    return lines.join('\n');
+}

package/dist/lib/formatting/output.d.ts

@@ -0,0 +1,45 @@
+import type { Activity, Auction, BrokerPost, EthosUser, FeaturedMarketsResponse, InvitationWithUser, Market, MarketHolder, Project, ProjectVoter, ProjectVotersTotals, Review, ScoreResponse, ScoreStatus, Season, Slash, Validator, Vote, VoteStats, Vouch, VouchUser } from '../api/echo-client.js';
+export declare function output<T>(data: T): string;
+export declare function formatUser(user: EthosUser): string;
+export declare function formatInvitations(invitations: InvitationWithUser[], total: number): string;
+export declare function formatSeasons(seasons: Season[], currentSeason?: Season): string;
+export declare function formatRank(data: {
+    rank: number;
+    totalXp?: number;
+    userkey?: string;
+    username?: string;
+    seasonXp?: number;
+    season?: number;
+}): string;
+export declare function formatSearchResults(results: EthosUser[]): string;
+export declare function formatActivities(activities: Activity[], username?: string): string;
+export declare function formatSlash(slash: Slash): string;
+export declare function formatSlashes(slashes: Slash[], total: number): string;
+export declare function formatReview(review: Review): string;
+export declare function formatReviews(activities: Activity[], total?: number): string;
+export declare function formatBrokerPost(post: BrokerPost): string;
+export declare function formatBrokerPosts(posts: BrokerPost[], total: number): string;
+export declare function formatListing(project: Project): string;
+export declare function formatListings(projects: Project[], total: number): string;
+export declare function formatListingVoters(voters: ProjectVoter[], totals: ProjectVotersTotals): string;
+export declare function formatNfts(nfts: any[], total: number): string;
+export declare function formatValidatorListings(listings: any[], total: number): string;
+export declare function formatAuction(auction: Auction): string;
+export declare function formatAuctions(auctions: Auction[], total: number): string;
+export declare function formatMarket(market: Market): string;
+export declare function formatMarkets(markets: Market[], total: number): string;
+export declare function formatMarketHolders(holders: MarketHolder[], total: number): string;
+export declare function formatFeaturedMarkets(response: FeaturedMarketsResponse): string;
+export declare function formatScore(data: ScoreResponse & {
+    identifier?: string;
+}): string;
+export declare function formatScoreStatus(data: ScoreStatus & {
+    identifier?: string;
+}): string;
+export declare function formatVouch(vouch: Vouch): string;
+export declare function formatVouches(vouches: Vouch[], total: number): string;
+export declare function formatMutualVouchers(users: VouchUser[], total: number): string;
+export declare function formatVotes(votes: Vote[], total: number, activityType?: string): string;
+export declare function formatVoteStats(stats: VoteStats, activityType?: string, activityId?: number): string;
+export declare function formatValidator(validator: Validator): string;
+export declare function formatValidators(validators: Validator[], total: number): string;