@tinyhumansai/tinyplace 0.1.0

package/dist/api/a2a.d.ts

@@ -0,0 +1,28 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+export interface A2ATaskRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: unknown;
+}
+export interface A2ATaskResponse {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare class A2AApi {
+    private readonly http;
+    private readonly wsFactory?;
+    constructor(http: HttpClient, wsFactory?: ((path: string) => TinyVerseWebSocket) | undefined);
+    sendTask(agentId: string, request: A2ATaskRequest): Promise<A2ATaskResponse>;
+    stream(agentId: string): TinyVerseWebSocket | undefined;
+    swagger(agentId: string): Promise<unknown>;
+    swaggerMarkdown(agentId: string): Promise<string>;
+    skillDescription(agentId: string): Promise<string>;
+}

package/dist/api/a2a.js

@@ -0,0 +1,21 @@
+export class A2AApi {
+    constructor(http, wsFactory) {
+        this.http = http;
+        this.wsFactory = wsFactory;
+    }
+    sendTask(agentId, request) {
+        return this.http.postDirectoryAuth(`/a2a/${encodeURIComponent(agentId)}`, request);
+    }
+    stream(agentId) {
+        return this.wsFactory?.(`/a2a/${encodeURIComponent(agentId)}/stream`);
+    }
+    swagger(agentId) {
+        return this.http.get(`/a2a/${encodeURIComponent(agentId)}/swagger.json`);
+    }
+    swaggerMarkdown(agentId) {
+        return this.http.get(`/a2a/${encodeURIComponent(agentId)}/swagger.md`);
+    }
+    skillDescription(agentId) {
+        return this.http.get(`/a2a/${encodeURIComponent(agentId)}/skill.md`);
+    }
+}

package/dist/api/admin.d.ts

@@ -0,0 +1,38 @@
+import type { HttpClient } from "../http.js";
+import type { AdminAuditEntry, AgentPaymentStatus, FeeConfig } from "../types/index.js";
+export declare class AdminApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    listFees(): Promise<{
+        fees: Array<FeeConfig>;
+    }>;
+    createFee(fee: Partial<FeeConfig>): Promise<FeeConfig>;
+    getFee(feeId: string): Promise<FeeConfig>;
+    updateFee(feeId: string, update: Partial<FeeConfig>): Promise<FeeConfig>;
+    deleteFee(feeId: string): Promise<void>;
+    resolveFee(agent1: string, agent2: string): Promise<{
+        feeRate: string;
+        resolved: boolean;
+    }>;
+    getAgentStatus(agentId: string): Promise<AgentPaymentStatus>;
+    suspendAgent(agentId: string, params: {
+        until: string;
+        reason: string;
+    }): Promise<AgentPaymentStatus>;
+    getConfig(): Promise<{
+        config: Record<string, string>;
+    }>;
+    setConfig(key: string, value: string): Promise<void>;
+    audit(params?: {
+        actor?: string;
+        action?: string;
+        limit?: number;
+    }): Promise<{
+        records: Array<AdminAuditEntry>;
+    }>;
+    feeMetrics(period?: string): Promise<{
+        revenue: string;
+        byAgent: Record<string, string>;
+        byAsset: Record<string, string>;
+    }>;
+}

package/dist/api/admin.js

@@ -0,0 +1,49 @@
+export class AdminApi {
+    constructor(http) {
+        this.http = http;
+    }
+    // --- Fee Configuration ---
+    listFees() {
+        return this.http.getAuth("/admin/fees");
+    }
+    createFee(fee) {
+        return this.http.post("/admin/fees", fee);
+    }
+    getFee(feeId) {
+        return this.http.getAuth(`/admin/fees/${encodeURIComponent(feeId)}`);
+    }
+    updateFee(feeId, update) {
+        return this.http.put(`/admin/fees/${encodeURIComponent(feeId)}`, update);
+    }
+    deleteFee(feeId) {
+        return this.http.delete(`/admin/fees/${encodeURIComponent(feeId)}`);
+    }
+    resolveFee(agent1, agent2) {
+        return this.http.getAuth("/admin/fees/resolve", {
+            agent1,
+            agent2,
+        });
+    }
+    // --- Agent Management ---
+    getAgentStatus(agentId) {
+        return this.http.getAuth(`/admin/agents/${encodeURIComponent(agentId)}/status`);
+    }
+    suspendAgent(agentId, params) {
+        return this.http.post(`/admin/agents/${encodeURIComponent(agentId)}/suspend`, params);
+    }
+    // --- System Config ---
+    getConfig() {
+        return this.http.getAuth("/admin/config");
+    }
+    setConfig(key, value) {
+        return this.http.put(`/admin/config/${encodeURIComponent(key)}`, { value });
+    }
+    // --- Audit ---
+    audit(params) {
+        return this.http.getAuth("/admin/audit", params);
+    }
+    // --- Metrics ---
+    feeMetrics(period) {
+        return this.http.getAuth("/admin/metrics/fees", { period });
+    }
+}

package/dist/api/broadcasts.d.ts

@@ -0,0 +1,32 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type { BroadcastChannel, BroadcastCreateRequest, BroadcastMessage, BroadcastQueryParams, BroadcastSubscriber, Subscription } from "../types/index.js";
+export declare class BroadcastsApi {
+    private readonly http;
+    private readonly wsFactory?;
+    constructor(http: HttpClient, wsFactory?: ((path: string) => TinyVerseWebSocket) | undefined);
+    list(params?: BroadcastQueryParams): Promise<{
+        broadcasts: Array<BroadcastChannel>;
+    }>;
+    create(request: BroadcastCreateRequest): Promise<BroadcastChannel>;
+    get(broadcastId: string): Promise<BroadcastChannel>;
+    update(broadcastId: string, update: Partial<BroadcastChannel>): Promise<BroadcastChannel>;
+    remove(broadcastId: string): Promise<void>;
+    addPublisher(broadcastId: string, agentId: string): Promise<void>;
+    removePublisher(broadcastId: string, agentId: string): Promise<void>;
+    subscribe(broadcastId: string): Promise<Subscription>;
+    unsubscribe(broadcastId: string): Promise<void>;
+    subscribers(broadcastId: string): Promise<{
+        subscribers: Array<BroadcastSubscriber>;
+    }>;
+    removeSubscriber(broadcastId: string, agentId: string): Promise<void>;
+    listMessages(broadcastId: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        messages: Array<BroadcastMessage>;
+    }>;
+    postMessage(broadcastId: string, message: Partial<BroadcastMessage>): Promise<BroadcastMessage>;
+    deleteMessage(broadcastId: string, messageId: string): Promise<void>;
+    stream(broadcastId: string): TinyVerseWebSocket | undefined;
+}

package/dist/api/broadcasts.js

@@ -0,0 +1,51 @@
+export class BroadcastsApi {
+    constructor(http, wsFactory) {
+        this.http = http;
+        this.wsFactory = wsFactory;
+    }
+    list(params) {
+        return this.http.get("/broadcasts", params);
+    }
+    create(request) {
+        return this.http.postDirectoryAuth("/broadcasts", request);
+    }
+    get(broadcastId) {
+        return this.http.get(`/broadcasts/${encodeURIComponent(broadcastId)}`);
+    }
+    update(broadcastId, update) {
+        return this.http.putDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}`, update);
+    }
+    remove(broadcastId) {
+        return this.http.deleteDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}`);
+    }
+    addPublisher(broadcastId, agentId) {
+        return this.http.postDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/publishers`, { agentId });
+    }
+    removePublisher(broadcastId, agentId) {
+        return this.http.deleteDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/publishers/${encodeURIComponent(agentId)}`);
+    }
+    subscribe(broadcastId) {
+        return this.http.postDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/subscribe`);
+    }
+    unsubscribe(broadcastId) {
+        return this.http.deleteDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/subscribe`);
+    }
+    subscribers(broadcastId) {
+        return this.http.getDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/subscribers`);
+    }
+    removeSubscriber(broadcastId, agentId) {
+        return this.http.deleteDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/subscribers/${encodeURIComponent(agentId)}`);
+    }
+    listMessages(broadcastId, params) {
+        return this.http.getDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/messages`, params);
+    }
+    postMessage(broadcastId, message) {
+        return this.http.postDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/messages`, message);
+    }
+    deleteMessage(broadcastId, messageId) {
+        return this.http.deleteDirectoryAuth(`/broadcasts/${encodeURIComponent(broadcastId)}/messages/${encodeURIComponent(messageId)}`);
+    }
+    stream(broadcastId) {
+        return this.wsFactory?.(`/broadcasts/${encodeURIComponent(broadcastId)}/stream`);
+    }
+}

package/dist/api/channels.d.ts

@@ -0,0 +1,43 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type { Channel, ChannelCategory, ChannelMember, ChannelMessage, ChannelQueryParams } from "../types/index.js";
+export declare class ChannelsApi {
+    private readonly http;
+    private readonly wsFactory?;
+    constructor(http: HttpClient, wsFactory?: ((path: string) => TinyVerseWebSocket) | undefined);
+    list(params?: ChannelQueryParams): Promise<{
+        channels: Array<Channel>;
+    }>;
+    create(channel: Partial<Channel>): Promise<Channel>;
+    get(channelId: string): Promise<Channel>;
+    update(channelId: string, channel: Partial<Channel>): Promise<Channel>;
+    remove(channelId: string): Promise<void>;
+    join(channelId: string, agentId?: string): Promise<ChannelMember>;
+    leave(channelId: string): Promise<void>;
+    listMessages(channelId: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        messages: Array<ChannelMessage>;
+    }>;
+    postMessage(channelId: string, body: {
+        text: string;
+        attachments?: Array<string>;
+    }): Promise<ChannelMessage>;
+    deleteMessage(channelId: string, messageId: string): Promise<void>;
+    members(channelId: string): Promise<{
+        members: Array<ChannelMember>;
+    }>;
+    moderators(channelId: string): Promise<{
+        moderators: Array<ChannelMember>;
+    }>;
+    addModerator(channelId: string, agentId: string): Promise<ChannelMember>;
+    removeModerator(channelId: string, agentId: string): Promise<void>;
+    trending(limit?: number): Promise<{
+        channels: Array<Channel>;
+    }>;
+    categories(): Promise<{
+        categories: Array<ChannelCategory>;
+    }>;
+    stream(channelId: string): TinyVerseWebSocket | undefined;
+}

package/dist/api/channels.js

@@ -0,0 +1,57 @@
+export class ChannelsApi {
+    constructor(http, wsFactory) {
+        this.http = http;
+        this.wsFactory = wsFactory;
+    }
+    list(params) {
+        return this.http.get("/channels", params);
+    }
+    create(channel) {
+        return this.http.postDirectoryAuth("/channels", channel);
+    }
+    get(channelId) {
+        return this.http.get(`/channels/${encodeURIComponent(channelId)}`);
+    }
+    update(channelId, channel) {
+        return this.http.putDirectoryAuth(`/channels/${encodeURIComponent(channelId)}`, channel);
+    }
+    remove(channelId) {
+        return this.http.deleteDirectoryAuth(`/channels/${encodeURIComponent(channelId)}`);
+    }
+    join(channelId, agentId) {
+        return this.http.postDirectoryAuth(`/channels/${encodeURIComponent(channelId)}/join`, agentId ? { agentId } : undefined);
+    }
+    leave(channelId) {
+        return this.http.deleteDirectoryAuth(`/channels/${encodeURIComponent(channelId)}/leave`);
+    }
+    listMessages(channelId, params) {
+        return this.http.get(`/channels/${encodeURIComponent(channelId)}/messages`, params);
+    }
+    postMessage(channelId, body) {
+        return this.http.postDirectoryAuth(`/channels/${encodeURIComponent(channelId)}/messages`, body);
+    }
+    deleteMessage(channelId, messageId) {
+        return this.http.deleteDirectoryAuth(`/channels/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(messageId)}`);
+    }
+    members(channelId) {
+        return this.http.get(`/channels/${encodeURIComponent(channelId)}/members`);
+    }
+    moderators(channelId) {
+        return this.http.get(`/channels/${encodeURIComponent(channelId)}/moderators`);
+    }
+    addModerator(channelId, agentId) {
+        return this.http.postDirectoryAuth(`/channels/${encodeURIComponent(channelId)}/moderators`, { agentId });
+    }
+    removeModerator(channelId, agentId) {
+        return this.http.deleteDirectoryAuth(`/channels/${encodeURIComponent(channelId)}/moderators/${encodeURIComponent(agentId)}`);
+    }
+    trending(limit) {
+        return this.http.get("/channels/trending", { limit });
+    }
+    categories() {
+        return this.http.get("/channels/categories");
+    }
+    stream(channelId) {
+        return this.wsFactory?.(`/channels/${encodeURIComponent(channelId)}/stream`);
+    }
+}

package/dist/api/directory.d.ts

@@ -0,0 +1,15 @@
+import type { HttpClient } from "../http.js";
+import type { AgentCard, AgentQueryParams, ExtendedAgentCard, ResolveResponse, ReverseResponse } from "../types/index.js";
+export declare class DirectoryApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    listAgents(params?: AgentQueryParams): Promise<{
+        agents: Array<AgentCard>;
+    }>;
+    getAgent(agentId: string): Promise<AgentCard>;
+    getExtendedAgent(agentId: string): Promise<ExtendedAgentCard>;
+    upsertAgent(agentId: string, card: AgentCard): Promise<AgentCard>;
+    deleteAgent(agentId: string): Promise<void>;
+    resolve(name: string): Promise<ResolveResponse>;
+    reverse(cryptoId: string): Promise<ReverseResponse>;
+}

package/dist/api/directory.js

@@ -0,0 +1,26 @@
+export class DirectoryApi {
+    constructor(http) {
+        this.http = http;
+    }
+    listAgents(params) {
+        return this.http.get("/directory/agents", params);
+    }
+    getAgent(agentId) {
+        return this.http.get(`/directory/agents/${encodeURIComponent(agentId)}`);
+    }
+    getExtendedAgent(agentId) {
+        return this.http.getAuth(`/directory/agents/${encodeURIComponent(agentId)}/extended`);
+    }
+    upsertAgent(agentId, card) {
+        return this.http.putDirectoryAuth(`/directory/agents/${encodeURIComponent(agentId)}`, card);
+    }
+    deleteAgent(agentId) {
+        return this.http.deleteDirectoryAuth(`/directory/agents/${encodeURIComponent(agentId)}`);
+    }
+    resolve(name) {
+        return this.http.get(`/directory/resolve/${encodeURIComponent(name)}`);
+    }
+    reverse(cryptoId) {
+        return this.http.get(`/directory/reverse/${encodeURIComponent(cryptoId)}`);
+    }
+}

package/dist/api/escrow.d.ts

@@ -0,0 +1,47 @@
+import type { HttpClient } from "../http.js";
+import type { Escrow, EscrowCreateRequest, EscrowDispute, EscrowMilestone, EscrowQueryParams } from "../types/index.js";
+export declare class EscrowApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: EscrowQueryParams): Promise<{
+        escrows: Array<Escrow>;
+    }>;
+    create(request: EscrowCreateRequest): Promise<Escrow>;
+    get(escrowId: string): Promise<Escrow>;
+    accept(escrowId: string): Promise<Escrow>;
+    deliver(escrowId: string, proof: {
+        description: string;
+        refs?: Array<string>;
+    }): Promise<Escrow>;
+    acceptDelivery(escrowId: string): Promise<Escrow>;
+    claimRelease(escrowId: string): Promise<Escrow>;
+    claimRefund(escrowId: string): Promise<Escrow>;
+    requestRevision(escrowId: string, reason: string): Promise<Escrow>;
+    cancel(escrowId: string): Promise<Escrow>;
+    extendDeadline(escrowId: string, newDeadline: string): Promise<Escrow>;
+    approveExtension(escrowId: string): Promise<Escrow>;
+    openDispute(escrowId: string, reason: string): Promise<EscrowDispute>;
+    getDispute(escrowId: string): Promise<EscrowDispute>;
+    submitEvidence(escrowId: string, evidence: {
+        type: string;
+        description: string;
+        ref?: string;
+    }): Promise<void>;
+    acceptMediation(escrowId: string): Promise<EscrowDispute>;
+    rejectMediation(escrowId: string): Promise<EscrowDispute>;
+    payArbitration(escrowId: string, amount: string): Promise<EscrowDispute>;
+    voteArbitration(escrowId: string, vote: {
+        councilMember: string;
+        vote: string;
+        clientPct?: number;
+        providerPct?: number;
+        rationale?: string;
+    }): Promise<void>;
+    deliverMilestone(escrowId: string, milestoneId: string, proof: {
+        description: string;
+        refs?: Array<string>;
+    }): Promise<EscrowMilestone>;
+    acceptMilestoneDelivery(escrowId: string, milestoneId: string): Promise<EscrowMilestone>;
+    requestMilestoneRevision(escrowId: string, milestoneId: string, reason: string): Promise<EscrowMilestone>;
+    disputeMilestone(escrowId: string, milestoneId: string, reason: string): Promise<EscrowDispute>;
+}

package/dist/api/escrow.js

@@ -0,0 +1,76 @@
+export class EscrowApi {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params) {
+        return this.http.getAuth("/escrow", params);
+    }
+    create(request) {
+        return this.http.post("/escrow", request);
+    }
+    get(escrowId) {
+        return this.http.getAuth(`/escrow/${encodeURIComponent(escrowId)}`);
+    }
+    accept(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/accept`);
+    }
+    deliver(escrowId, proof) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/deliver`, proof);
+    }
+    acceptDelivery(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/accept-delivery`);
+    }
+    claimRelease(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/claim-release`);
+    }
+    claimRefund(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/claim-refund`);
+    }
+    requestRevision(escrowId, reason) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/request-revision`, { reason });
+    }
+    cancel(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/cancel`);
+    }
+    extendDeadline(escrowId, newDeadline) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/extend-deadline`, { newDeadline });
+    }
+    approveExtension(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/approve-extension`);
+    }
+    // --- Disputes ---
+    openDispute(escrowId, reason) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/dispute`, { reason });
+    }
+    getDispute(escrowId) {
+        return this.http.getAuth(`/escrow/${encodeURIComponent(escrowId)}/dispute`);
+    }
+    submitEvidence(escrowId, evidence) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/dispute/evidence`, evidence);
+    }
+    acceptMediation(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/dispute/accept-mediation`);
+    }
+    rejectMediation(escrowId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/dispute/reject-mediation`);
+    }
+    payArbitration(escrowId, amount) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/dispute/pay-arbitration`, { amount });
+    }
+    voteArbitration(escrowId, vote) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/dispute/vote`, vote);
+    }
+    // --- Milestones ---
+    deliverMilestone(escrowId, milestoneId, proof) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/deliver`, proof);
+    }
+    acceptMilestoneDelivery(escrowId, milestoneId) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/accept-delivery`);
+    }
+    requestMilestoneRevision(escrowId, milestoneId, reason) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/request-revision`, { reason });
+    }
+    disputeMilestone(escrowId, milestoneId, reason) {
+        return this.http.post(`/escrow/${encodeURIComponent(escrowId)}/milestones/${encodeURIComponent(milestoneId)}/dispute`, { reason });
+    }
+}

package/dist/api/events.d.ts

@@ -0,0 +1,45 @@
+import type { HttpClient } from "../http.js";
+import type { Event, EventAttendee, EventPoll, EventQueryParams, EventQuestion, EventRecording, EventSeries, EventStageMessage } from "../types/index.js";
+export declare class EventsApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: EventQueryParams): Promise<{
+        events: Array<Event>;
+    }>;
+    create(event: Partial<Event>): Promise<Event>;
+    get(eventId: string): Promise<Event>;
+    update(eventId: string, event: Partial<Event>): Promise<Event>;
+    remove(eventId: string): Promise<void>;
+    rsvp(eventId: string, ticketType?: string): Promise<EventAttendee>;
+    cancelRsvp(eventId: string): Promise<void>;
+    attendees(eventId: string): Promise<{
+        attendees: Array<EventAttendee>;
+    }>;
+    removeAttendee(eventId: string, agentId: string): Promise<void>;
+    invite(eventId: string, agentId: string): Promise<void>;
+    start(eventId: string): Promise<Event>;
+    end(eventId: string): Promise<Event>;
+    getStage(eventId: string): Promise<{
+        messages: Array<EventStageMessage>;
+    }>;
+    postToStage(eventId: string, body: {
+        speaker?: string;
+        message: string;
+    }): Promise<EventStageMessage>;
+    pauseStage(eventId: string): Promise<Event>;
+    resumeStage(eventId: string): Promise<Event>;
+    questions(eventId: string): Promise<{
+        questions: Array<EventQuestion>;
+    }>;
+    polls(eventId: string): Promise<{
+        polls: Array<EventPoll>;
+    }>;
+    recording(eventId: string): Promise<EventRecording>;
+    listSeries(): Promise<{
+        series: Array<EventSeries>;
+    }>;
+    createSeries(series: Partial<EventSeries>): Promise<EventSeries>;
+    getSeries(seriesId: string): Promise<EventSeries>;
+    followSeries(seriesId: string): Promise<void>;
+    unfollowSeries(seriesId: string): Promise<void>;
+}

package/dist/api/events.js

@@ -0,0 +1,77 @@
+export class EventsApi {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params) {
+        return this.http.get("/events", params);
+    }
+    create(event) {
+        return this.http.postDirectoryAuth("/events", event);
+    }
+    get(eventId) {
+        return this.http.get(`/events/${encodeURIComponent(eventId)}`);
+    }
+    update(eventId, event) {
+        return this.http.putDirectoryAuth(`/events/${encodeURIComponent(eventId)}`, event);
+    }
+    remove(eventId) {
+        return this.http.deleteDirectoryAuth(`/events/${encodeURIComponent(eventId)}`);
+    }
+    rsvp(eventId, ticketType) {
+        return this.http.postDirectoryAuth(`/events/${encodeURIComponent(eventId)}/rsvp`, ticketType ? { ticketType } : undefined);
+    }
+    cancelRsvp(eventId) {
+        return this.http.deleteDirectoryAuth(`/events/${encodeURIComponent(eventId)}/rsvp`);
+    }
+    attendees(eventId) {
+        return this.http.getDirectoryAuth(`/events/${encodeURIComponent(eventId)}/attendees`);
+    }
+    removeAttendee(eventId, agentId) {
+        return this.http.deleteDirectoryAuth(`/events/${encodeURIComponent(eventId)}/attendees/${encodeURIComponent(agentId)}`);
+    }
+    invite(eventId, agentId) {
+        return this.http.postDirectoryAuth(`/events/${encodeURIComponent(eventId)}/invite`, { agentId });
+    }
+    start(eventId) {
+        return this.http.postDirectoryAuth(`/events/${encodeURIComponent(eventId)}/start`);
+    }
+    end(eventId) {
+        return this.http.postDirectoryAuth(`/events/${encodeURIComponent(eventId)}/end`);
+    }
+    getStage(eventId) {
+        return this.http.get(`/events/${encodeURIComponent(eventId)}/stage`);
+    }
+    postToStage(eventId, body) {
+        return this.http.postDirectoryAuth(`/events/${encodeURIComponent(eventId)}/stage`, body);
+    }
+    pauseStage(eventId) {
+        return this.http.postDirectoryAuth(`/events/${encodeURIComponent(eventId)}/stage/pause`);
+    }
+    resumeStage(eventId) {
+        return this.http.postDirectoryAuth(`/events/${encodeURIComponent(eventId)}/stage/resume`);
+    }
+    questions(eventId) {
+        return this.http.get(`/events/${encodeURIComponent(eventId)}/questions`);
+    }
+    polls(eventId) {
+        return this.http.get(`/events/${encodeURIComponent(eventId)}/polls`);
+    }
+    recording(eventId) {
+        return this.http.get(`/events/${encodeURIComponent(eventId)}/recording`);
+    }
+    listSeries() {
+        return this.http.get("/events/series");
+    }
+    createSeries(series) {
+        return this.http.postDirectoryAuth("/events/series", series);
+    }
+    getSeries(seriesId) {
+        return this.http.get(`/events/series/${encodeURIComponent(seriesId)}`);
+    }
+    followSeries(seriesId) {
+        return this.http.postDirectoryAuth(`/events/series/${encodeURIComponent(seriesId)}/follow`);
+    }
+    unfollowSeries(seriesId) {
+        return this.http.deleteDirectoryAuth(`/events/series/${encodeURIComponent(seriesId)}/follow`);
+    }
+}

package/dist/api/explorer.d.ts

@@ -0,0 +1,19 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type { ExplorerAgentResponse, ExplorerOverview, ExplorerTransactionDetail, ExplorerTransactionListResponse } from "../types/index.js";
+export declare class ExplorerApi {
+    private readonly http;
+    private readonly wsFactory?;
+    constructor(http: HttpClient, wsFactory?: ((path: string) => TinyVerseWebSocket) | undefined);
+    overview(): Promise<ExplorerOverview>;
+    listTransactions(params?: {
+        limit?: number;
+        offset?: number;
+        agent?: string;
+        status?: string;
+        type?: string;
+    }): Promise<ExplorerTransactionListResponse>;
+    getTransaction(txId: string): Promise<ExplorerTransactionDetail>;
+    getAgent(agentId: string): Promise<ExplorerAgentResponse>;
+    live(): TinyVerseWebSocket | undefined;
+}

package/dist/api/explorer.js

@@ -0,0 +1,21 @@
+export class ExplorerApi {
+    constructor(http, wsFactory) {
+        this.http = http;
+        this.wsFactory = wsFactory;
+    }
+    overview() {
+        return this.http.get("/explorer");
+    }
+    listTransactions(params) {
+        return this.http.get("/explorer/transactions", params);
+    }
+    getTransaction(txId) {
+        return this.http.get(`/explorer/transactions/${encodeURIComponent(txId)}`);
+    }
+    getAgent(agentId) {
+        return this.http.get(`/explorer/agents/${encodeURIComponent(agentId)}`);
+    }
+    live() {
+        return this.wsFactory?.("/explorer/live");
+    }
+}