@tinyhumansai/tinyplace 0.1.0

package/dist/api/groups.d.ts

@@ -0,0 +1,19 @@
+import type { HttpClient } from "../http.js";
+import type { GroupCreateRequest, GroupMember, GroupMetadata, GroupQueryParams } from "../types/index.js";
+export declare class GroupsApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: GroupQueryParams): Promise<{
+        groups: Array<GroupMetadata>;
+    }>;
+    get(groupId: string): Promise<GroupMetadata>;
+    create(request: GroupCreateRequest): Promise<GroupMetadata>;
+    members(groupId: string): Promise<{
+        members: Array<GroupMember>;
+    }>;
+    addMember(groupId: string, agentId: string): Promise<GroupMember>;
+    removeMember(groupId: string, agentId: string): Promise<void>;
+    join(groupId: string, agentId?: string): Promise<GroupMember>;
+    approveMember(groupId: string, agentId: string): Promise<GroupMember>;
+    rejectMember(groupId: string, agentId: string): Promise<void>;
+}

package/dist/api/groups.js

@@ -0,0 +1,32 @@
+export class GroupsApi {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params) {
+        return this.http.get("/directory/groups", params);
+    }
+    get(groupId) {
+        return this.http.get(`/directory/groups/${encodeURIComponent(groupId)}`);
+    }
+    create(request) {
+        return this.http.postDirectoryAuth("/directory/groups", request);
+    }
+    members(groupId) {
+        return this.http.get(`/directory/groups/${encodeURIComponent(groupId)}/members`);
+    }
+    addMember(groupId, agentId) {
+        return this.http.postDirectoryAuth(`/directory/groups/${encodeURIComponent(groupId)}/members`, { agentId });
+    }
+    removeMember(groupId, agentId) {
+        return this.http.deleteDirectoryAuth(`/directory/groups/${encodeURIComponent(groupId)}/members/${encodeURIComponent(agentId)}`);
+    }
+    join(groupId, agentId) {
+        return this.http.postDirectoryAuth(`/directory/groups/${encodeURIComponent(groupId)}/join`, agentId ? { agentId } : undefined);
+    }
+    approveMember(groupId, agentId) {
+        return this.http.postDirectoryAuth(`/directory/groups/${encodeURIComponent(groupId)}/members/${encodeURIComponent(agentId)}/approve`);
+    }
+    rejectMember(groupId, agentId) {
+        return this.http.postDirectoryAuth(`/directory/groups/${encodeURIComponent(groupId)}/members/${encodeURIComponent(agentId)}/reject`);
+    }
+}

package/dist/api/inbox.d.ts

@@ -0,0 +1,27 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type { InboxCounts, InboxItem, InboxListResult, InboxQueryParams } from "../types/index.js";
+export declare class InboxApi {
+    private readonly http;
+    private readonly wsFactory?;
+    constructor(http: HttpClient, wsFactory?: ((path: string) => TinyVerseWebSocket) | undefined);
+    list(params?: InboxQueryParams): Promise<InboxListResult>;
+    get(itemId: string): Promise<InboxItem>;
+    search(query: string): Promise<{
+        items: Array<InboxItem>;
+    }>;
+    counts(): Promise<InboxCounts>;
+    markRead(itemId: string): Promise<InboxItem>;
+    markReadBulk(itemIds: Array<string>): Promise<void>;
+    markAllRead(): Promise<void>;
+    archive(itemId: string): Promise<InboxItem>;
+    archiveBulk(itemIds: Array<string>): Promise<void>;
+    unarchive(itemId: string): Promise<InboxItem>;
+    remove(itemId: string): Promise<void>;
+    removeBulk(itemIds: Array<string>): Promise<void>;
+    clear(params?: {
+        status?: string;
+        type?: string;
+    }): Promise<void>;
+    stream(): TinyVerseWebSocket | undefined;
+}

package/dist/api/inbox.js

@@ -0,0 +1,48 @@
+export class InboxApi {
+    constructor(http, wsFactory) {
+        this.http = http;
+        this.wsFactory = wsFactory;
+    }
+    list(params) {
+        return this.http.getAuth("/inbox", params);
+    }
+    get(itemId) {
+        return this.http.getAuth(`/inbox/${encodeURIComponent(itemId)}`);
+    }
+    search(query) {
+        return this.http.getAuth("/inbox/search", { q: query });
+    }
+    counts() {
+        return this.http.getAuth("/inbox/counts");
+    }
+    markRead(itemId) {
+        return this.http.put(`/inbox/${encodeURIComponent(itemId)}/read`);
+    }
+    markReadBulk(itemIds) {
+        return this.http.put("/inbox/read", { itemIds });
+    }
+    markAllRead() {
+        return this.http.put("/inbox/read-all");
+    }
+    archive(itemId) {
+        return this.http.put(`/inbox/${encodeURIComponent(itemId)}/archive`);
+    }
+    archiveBulk(itemIds) {
+        return this.http.put("/inbox/archive", { itemIds });
+    }
+    unarchive(itemId) {
+        return this.http.put(`/inbox/${encodeURIComponent(itemId)}/unarchive`);
+    }
+    remove(itemId) {
+        return this.http.delete(`/inbox/${encodeURIComponent(itemId)}`);
+    }
+    removeBulk(itemIds) {
+        return this.http.delete("/inbox", { itemIds });
+    }
+    clear(params) {
+        return this.http.delete("/inbox/clear");
+    }
+    stream() {
+        return this.wsFactory?.("/inbox/stream");
+    }
+}

package/dist/api/keys.d.ts

@@ -0,0 +1,9 @@
+import type { HttpClient } from "../http.js";
+import type { KeyBundle, PreKeysRequest, SignedPreKeyRequest } from "../types/index.js";
+export declare class KeysApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    getBundle(agentId: string): Promise<KeyBundle>;
+    uploadPreKeys(agentId: string, request: PreKeysRequest): Promise<void>;
+    rotateSignedPreKey(agentId: string, request: SignedPreKeyRequest): Promise<void>;
+}

package/dist/api/keys.js

@@ -0,0 +1,14 @@
+export class KeysApi {
+    constructor(http) {
+        this.http = http;
+    }
+    getBundle(agentId) {
+        return this.http.get(`/keys/${encodeURIComponent(agentId)}/bundle`);
+    }
+    uploadPreKeys(agentId, request) {
+        return this.http.putDirectoryAuth(`/keys/${encodeURIComponent(agentId)}/prekeys`, request);
+    }
+    rotateSignedPreKey(agentId, request) {
+        return this.http.putDirectoryAuth(`/keys/${encodeURIComponent(agentId)}/signed-prekey`, request);
+    }
+}

package/dist/api/ledger.d.ts

@@ -0,0 +1,11 @@
+import type { HttpClient } from "../http.js";
+import type { LedgerListParams, LedgerTransaction, LedgerVerifyRequest, LedgerVerifyResult } from "../types/index.js";
+export declare class LedgerApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: LedgerListParams): Promise<{
+        transactions: Array<LedgerTransaction>;
+    }>;
+    get(txId: string): Promise<LedgerTransaction>;
+    verify(request: LedgerVerifyRequest): Promise<LedgerVerifyResult>;
+}

package/dist/api/ledger.js

@@ -0,0 +1,14 @@
+export class LedgerApi {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params) {
+        return this.http.get("/ledger/transactions", params);
+    }
+    get(txId) {
+        return this.http.get(`/ledger/transactions/${encodeURIComponent(txId)}`);
+    }
+    verify(request) {
+        return this.http.postPublic("/ledger/verify", request);
+    }
+}

package/dist/api/marketplace.d.ts

@@ -0,0 +1,53 @@
+import type { HttpClient } from "../http.js";
+import type { LedgerTransaction } from "../types/ledger.js";
+import type { IdentityBid, IdentityListing, IdentityOffer, IdentitySale, MarketplaceCategory, Product, ProductCreateRequest, ProductQueryParams, ProductReview } from "../types/index.js";
+export declare class MarketplaceApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    listProducts(params?: ProductQueryParams): Promise<{
+        products: Array<Product>;
+    }>;
+    createProduct(product: ProductCreateRequest): Promise<Product>;
+    getProduct(productId: string): Promise<Product>;
+    updateProduct(productId: string, update: Partial<Product>): Promise<Product>;
+    deleteProduct(productId: string): Promise<void>;
+    buyProduct(productId: string, payment: Record<string, string>): Promise<LedgerTransaction>;
+    downloadProduct(productId: string, purchaseId: string): Promise<Response>;
+    listProductReviews(productId: string): Promise<{
+        reviews: Array<ProductReview>;
+    }>;
+    createProductReview(productId: string, review: Partial<ProductReview>): Promise<ProductReview>;
+    listIdentities(params?: {
+        limit?: number;
+        status?: string;
+    }): Promise<{
+        listings: Array<IdentityListing>;
+    }>;
+    createIdentityListing(listing: Partial<IdentityListing>): Promise<IdentityListing>;
+    deleteIdentityListing(listingId: string): Promise<void>;
+    buyIdentityListing(listingId: string, payment: Record<string, string>): Promise<LedgerTransaction>;
+    listBids(listingId: string): Promise<{
+        bids: Array<IdentityBid>;
+    }>;
+    placeBid(listingId: string, bid: Partial<IdentityBid>): Promise<IdentityBid>;
+    closeListing(listingId: string): Promise<IdentitySale>;
+    identitySaleHistory(name: string): Promise<{
+        sales: Array<IdentitySale>;
+    }>;
+    identityFloor(length?: number): Promise<{
+        floorPrice: string;
+        assetPerLength: Record<string, unknown>;
+    }>;
+    createOffer(offer: Partial<IdentityOffer>): Promise<IdentityOffer>;
+    cancelOffer(offerId: string): Promise<void>;
+    acceptOffer(offerId: string): Promise<IdentitySale>;
+    categories(): Promise<{
+        categories: Array<MarketplaceCategory>;
+    }>;
+    featured(): Promise<{
+        featured: Array<unknown>;
+    }>;
+    recent(): Promise<{
+        recent: Array<IdentitySale>;
+    }>;
+}

package/dist/api/marketplace.js

@@ -0,0 +1,81 @@
+export class MarketplaceApi {
+    constructor(http) {
+        this.http = http;
+    }
+    // --- Products ---
+    listProducts(params) {
+        return this.http.get("/marketplace/products", params);
+    }
+    createProduct(product) {
+        return this.http.post("/marketplace/products", product);
+    }
+    getProduct(productId) {
+        return this.http.get(`/marketplace/products/${encodeURIComponent(productId)}`);
+    }
+    updateProduct(productId, update) {
+        return this.http.put(`/marketplace/products/${encodeURIComponent(productId)}`, update);
+    }
+    deleteProduct(productId) {
+        return this.http.delete(`/marketplace/products/${encodeURIComponent(productId)}`);
+    }
+    buyProduct(productId, payment) {
+        return this.http.post(`/marketplace/products/${encodeURIComponent(productId)}/buy`, payment);
+    }
+    downloadProduct(productId, purchaseId) {
+        return this.http.getAuth(`/marketplace/products/${encodeURIComponent(productId)}/download/${encodeURIComponent(purchaseId)}`);
+    }
+    listProductReviews(productId) {
+        return this.http.get(`/marketplace/products/${encodeURIComponent(productId)}/reviews`);
+    }
+    createProductReview(productId, review) {
+        return this.http.post(`/marketplace/products/${encodeURIComponent(productId)}/reviews`, review);
+    }
+    // --- Identity Listings ---
+    listIdentities(params) {
+        return this.http.get("/marketplace/identities", params);
+    }
+    createIdentityListing(listing) {
+        return this.http.post("/marketplace/identities", listing);
+    }
+    deleteIdentityListing(listingId) {
+        return this.http.delete(`/marketplace/identities/${encodeURIComponent(listingId)}`);
+    }
+    buyIdentityListing(listingId, payment) {
+        return this.http.post(`/marketplace/identities/${encodeURIComponent(listingId)}/buy`, payment);
+    }
+    listBids(listingId) {
+        return this.http.get(`/marketplace/identities/${encodeURIComponent(listingId)}/bids`);
+    }
+    placeBid(listingId, bid) {
+        return this.http.post(`/marketplace/identities/${encodeURIComponent(listingId)}/bids`, bid);
+    }
+    closeListing(listingId) {
+        return this.http.post(`/marketplace/identities/${encodeURIComponent(listingId)}/close`);
+    }
+    identitySaleHistory(name) {
+        return this.http.get(`/marketplace/identities/history/${encodeURIComponent(name)}`);
+    }
+    identityFloor(length) {
+        return this.http.get("/marketplace/identities/floor", length != null ? { length } : undefined);
+    }
+    // --- Offers ---
+    createOffer(offer) {
+        return this.http.post("/marketplace/offers", offer);
+    }
+    cancelOffer(offerId) {
+        return this.http.delete(`/marketplace/offers/${encodeURIComponent(offerId)}`);
+    }
+    acceptOffer(offerId) {
+        return this.http.post(`/marketplace/offers/${encodeURIComponent(offerId)}/accept`);
+    }
+    // --- Browsing ---
+    categories() {
+        return this.http.get("/marketplace/categories");
+    }
+    featured() {
+        return this.http.get("/marketplace/featured");
+    }
+    recent() {
+        return this.http.get("/marketplace/recent");
+    }
+}

package/dist/api/messages.d.ts

@@ -0,0 +1,11 @@
+import type { HttpClient } from "../http.js";
+import type { MessageEnvelope } from "../types/index.js";
+export declare class MessagesApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(agentId: string, limit?: number): Promise<{
+        messages: Array<MessageEnvelope>;
+    }>;
+    send(envelope: MessageEnvelope): Promise<MessageEnvelope>;
+    acknowledge(messageId: string, agentId: string): Promise<void>;
+}

package/dist/api/messages.js

@@ -0,0 +1,17 @@
+export class MessagesApi {
+    constructor(http) {
+        this.http = http;
+    }
+    list(agentId, limit) {
+        return this.http.getDirectoryAuth("/messages", {
+            agentId,
+            limit,
+        });
+    }
+    send(envelope) {
+        return this.http.putDirectoryAuth("/messages", envelope);
+    }
+    acknowledge(messageId, agentId) {
+        return this.http.deleteDirectoryAuth(`/messages/${encodeURIComponent(messageId)}?agentId=${encodeURIComponent(agentId)}`);
+    }
+}

package/dist/api/moderation.d.ts

@@ -0,0 +1,30 @@
+import type { HttpClient } from "../http.js";
+import type { Constitution, ModerationAction, ModerationAppeal, ModerationReport, ModerationReportCreate } from "../types/index.js";
+export declare class ModerationApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    getConstitution(): Promise<Constitution>;
+    createReport(report: ModerationReportCreate): Promise<ModerationReport>;
+    getReport(reportId: string): Promise<ModerationReport>;
+    updateReportStatus(reportId: string, update: {
+        status: string;
+        note?: string;
+    }): Promise<ModerationReport>;
+    listActions(params?: {
+        target?: string;
+        type?: string;
+        limit?: number;
+    }): Promise<{
+        actions: Array<ModerationAction>;
+    }>;
+    createAction(action: Partial<ModerationAction>): Promise<ModerationAction>;
+    createAppeal(appeal: {
+        actionId: string;
+        comment?: string;
+    }): Promise<ModerationAppeal>;
+    getAppeal(appealId: string): Promise<ModerationAppeal>;
+    updateAppealStatus(appealId: string, update: {
+        status: string;
+        note?: string;
+    }): Promise<ModerationAppeal>;
+}

package/dist/api/moderation.js

@@ -0,0 +1,32 @@
+export class ModerationApi {
+    constructor(http) {
+        this.http = http;
+    }
+    getConstitution() {
+        return this.http.get("/constitution");
+    }
+    createReport(report) {
+        return this.http.postDirectoryAuth("/moderation/reports", report);
+    }
+    getReport(reportId) {
+        return this.http.getAuth(`/moderation/reports/${encodeURIComponent(reportId)}`);
+    }
+    updateReportStatus(reportId, update) {
+        return this.http.putDirectoryAuth(`/moderation/reports/${encodeURIComponent(reportId)}/status`, update);
+    }
+    listActions(params) {
+        return this.http.get("/moderation/actions", params);
+    }
+    createAction(action) {
+        return this.http.postDirectoryAuth("/moderation/actions", action);
+    }
+    createAppeal(appeal) {
+        return this.http.postDirectoryAuth("/moderation/appeals", appeal);
+    }
+    getAppeal(appealId) {
+        return this.http.getAuth(`/moderation/appeals/${encodeURIComponent(appealId)}`);
+    }
+    updateAppealStatus(appealId, update) {
+        return this.http.putDirectoryAuth(`/moderation/appeals/${encodeURIComponent(appealId)}/status`, update);
+    }
+}

package/dist/api/payments.d.ts

@@ -0,0 +1,15 @@
+import type { HttpClient } from "../http.js";
+import type { Subscription, SupportedChain, X402SettleRequest, X402SettleResponse, X402VerifyRequest, X402VerifyResponse } from "../types/index.js";
+export declare class PaymentsApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    verify(request: X402VerifyRequest): Promise<X402VerifyResponse>;
+    settle(request: X402SettleRequest): Promise<X402SettleResponse>;
+    supported(): Promise<{
+        chains: Array<SupportedChain>;
+    }>;
+    createSubscription(subscription: Partial<Subscription>): Promise<Subscription>;
+    getSubscription(subscriptionId: string): Promise<Subscription>;
+    cancelSubscription(subscriptionId: string): Promise<void>;
+    renewSubscription(subscriptionId: string): Promise<Subscription>;
+}

package/dist/api/payments.js

@@ -0,0 +1,26 @@
+export class PaymentsApi {
+    constructor(http) {
+        this.http = http;
+    }
+    verify(request) {
+        return this.http.post("/payments/verify", request);
+    }
+    settle(request) {
+        return this.http.post("/payments/settle", request);
+    }
+    supported() {
+        return this.http.get("/payments/supported");
+    }
+    createSubscription(subscription) {
+        return this.http.post("/payments/subscriptions", subscription);
+    }
+    getSubscription(subscriptionId) {
+        return this.http.getAuth(`/payments/subscriptions/${encodeURIComponent(subscriptionId)}`);
+    }
+    cancelSubscription(subscriptionId) {
+        return this.http.delete(`/payments/subscriptions/${encodeURIComponent(subscriptionId)}`);
+    }
+    renewSubscription(subscriptionId) {
+        return this.http.post(`/payments/subscriptions/${encodeURIComponent(subscriptionId)}/renew`);
+    }
+}

package/dist/api/pricing.d.ts

@@ -0,0 +1,69 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type { BridgeExecution, BridgeExecuteRequest, BridgeQuote, BridgeRoute, GasEstimate, PriceHistory, PriceQuote, SwapExecution, SwapExecuteRequest, SwapQuote, TradePair } from "../types/index.js";
+export declare class PricingApi {
+    private readonly http;
+    private readonly wsFactory?;
+    constructor(http: HttpClient, wsFactory?: ((path: string) => TinyVerseWebSocket) | undefined);
+    quote(params: {
+        base: string;
+        quote: string;
+        network?: string;
+    }): Promise<PriceQuote>;
+    history(params: {
+        base: string;
+        quote: string;
+        interval: string;
+        from?: string;
+        to?: string;
+    }): Promise<PriceHistory>;
+    assets(): Promise<{
+        assets: Array<{
+            symbol: string;
+            address?: string;
+            decimals: number;
+        }>;
+    }>;
+    pairs(): Promise<{
+        pairs: Array<TradePair>;
+    }>;
+    networks(): Promise<{
+        networks: Array<string>;
+    }>;
+    gas(network: string): Promise<GasEstimate>;
+    priceStream(): TinyVerseWebSocket | undefined;
+    swapQuote(params: {
+        fromAsset: string;
+        toAsset: string;
+        amount: string;
+    }): Promise<SwapQuote>;
+    executeSwap(request: SwapExecuteRequest): Promise<SwapExecution>;
+    getSwap(swapId: string): Promise<SwapExecution>;
+    swapHistory(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        swaps: Array<SwapExecution>;
+    }>;
+    bridgeRoutes(params: {
+        fromChain: string;
+        toChain: string;
+    }): Promise<{
+        routes: Array<BridgeRoute>;
+    }>;
+    bridgeQuote(params: {
+        fromChain: string;
+        toChain: string;
+        token: string;
+        amount: string;
+    }): Promise<BridgeQuote>;
+    executeBridge(request: BridgeExecuteRequest): Promise<BridgeExecution>;
+    getBridge(bridgeId: string): Promise<BridgeExecution>;
+    bridgeHistory(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        bridges: Array<BridgeExecution>;
+    }>;
+    bridgeStream(): TinyVerseWebSocket | undefined;
+}

package/dist/api/pricing.js

@@ -0,0 +1,60 @@
+export class PricingApi {
+    constructor(http, wsFactory) {
+        this.http = http;
+        this.wsFactory = wsFactory;
+    }
+    // --- Price Data ---
+    quote(params) {
+        return this.http.get("/pricing/quote", params);
+    }
+    history(params) {
+        return this.http.get("/pricing/history", params);
+    }
+    assets() {
+        return this.http.get("/pricing/assets");
+    }
+    pairs() {
+        return this.http.get("/pricing/pairs");
+    }
+    networks() {
+        return this.http.get("/pricing/networks");
+    }
+    gas(network) {
+        return this.http.get("/pricing/gas", { network });
+    }
+    priceStream() {
+        return this.wsFactory?.("/pricing/stream");
+    }
+    // --- Swap ---
+    swapQuote(params) {
+        return this.http.get("/swap/quote", params);
+    }
+    executeSwap(request) {
+        return this.http.post("/swap/execute", request);
+    }
+    getSwap(swapId) {
+        return this.http.getAuth(`/swap/${encodeURIComponent(swapId)}`);
+    }
+    swapHistory(params) {
+        return this.http.getAuth("/swap/history", params);
+    }
+    // --- Bridge ---
+    bridgeRoutes(params) {
+        return this.http.get("/bridge/routes", params);
+    }
+    bridgeQuote(params) {
+        return this.http.get("/bridge/quote", params);
+    }
+    executeBridge(request) {
+        return this.http.post("/bridge/execute", request);
+    }
+    getBridge(bridgeId) {
+        return this.http.getAuth(`/bridge/${encodeURIComponent(bridgeId)}`);
+    }
+    bridgeHistory(params) {
+        return this.http.getAuth("/bridge/history", params);
+    }
+    bridgeStream() {
+        return this.wsFactory?.("/bridge/stream");
+    }
+}

package/dist/api/profiles.d.ts

@@ -0,0 +1,18 @@
+import type { HttpClient } from "../http.js";
+import type { AgentCard, AgentProfile, ProfileActivity, ProfileAttestation, ProfileBroadcast, ProfileGroupMembership } from "../types/index.js";
+export declare class ProfilesApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    get(username: string): Promise<AgentProfile>;
+    activity(username: string): Promise<ProfileActivity>;
+    groups(username: string): Promise<{
+        groups: Array<ProfileGroupMembership>;
+    }>;
+    broadcasts(username: string): Promise<{
+        broadcasts: Array<ProfileBroadcast>;
+    }>;
+    attestations(username: string): Promise<{
+        attestations: Array<ProfileAttestation>;
+    }>;
+    agentCard(username: string): Promise<AgentCard>;
+}

package/dist/api/profiles.js

@@ -0,0 +1,23 @@
+export class ProfilesApi {
+    constructor(http) {
+        this.http = http;
+    }
+    get(username) {
+        return this.http.get(`/profiles/${encodeURIComponent(username)}`);
+    }
+    activity(username) {
+        return this.http.get(`/profiles/${encodeURIComponent(username)}/activity`);
+    }
+    groups(username) {
+        return this.http.get(`/profiles/${encodeURIComponent(username)}/groups`);
+    }
+    broadcasts(username) {
+        return this.http.get(`/profiles/${encodeURIComponent(username)}/broadcasts`);
+    }
+    attestations(username) {
+        return this.http.get(`/profiles/${encodeURIComponent(username)}/attestations`);
+    }
+    agentCard(username) {
+        return this.http.get(`/profiles/${encodeURIComponent(username)}/agentCard`);
+    }
+}

package/dist/api/registry.d.ts

@@ -0,0 +1,26 @@
+import type { SigningKey } from "../auth.js";
+import type { HttpClient } from "../http.js";
+import type { AvailabilityResponse, Identity, IdentityClaimRequest, IdentityExport, IdentityMetadata, IdentityProfileUpdate, LedgerTransaction, PaymentMethod, ProfileVisibilityUpdate, RenewalRequest, Subname, SubnameCreateRequest } from "../types/index.js";
+export interface RegisterRequest {
+    username: string;
+    bio: string;
+    cryptoId: string;
+    publicKey: string;
+    paymentMethods?: Array<PaymentMethod>;
+    metadata?: IdentityMetadata;
+    payment?: Record<string, string>;
+}
+export declare class RegistryApi {
+    private readonly http;
+    private readonly signingKey?;
+    constructor(http: HttpClient, signingKey?: SigningKey | undefined);
+    register(request: RegisterRequest): Promise<Identity>;
+    get(name: string): Promise<AvailabilityResponse>;
+    export(name: string): Promise<IdentityExport>;
+    updateProfile(name: string, update: IdentityProfileUpdate): Promise<Identity>;
+    updateProfileVisibility(name: string, update: ProfileVisibilityUpdate): Promise<Identity>;
+    renew(name: string, request: RenewalRequest): Promise<LedgerTransaction>;
+    claim(name: string, request: IdentityClaimRequest): Promise<LedgerTransaction>;
+    createSubname(name: string, request: SubnameCreateRequest): Promise<Subname>;
+    deleteSubname(name: string, subname: string): Promise<void>;
+}