@tinyhumansai/tinyplace 0.1.0

package/src/api/events.ts

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

package/src/api/explorer.ts

@@ -0,0 +1,48 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket } from "../websocket.js";
+import type {
+  ExplorerAgentResponse,
+  ExplorerOverview,
+  ExplorerTransactionDetail,
+  ExplorerTransactionListResponse,
+} from "../types/index.js";
+
+export class ExplorerApi {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly wsFactory?: (path: string) => TinyVerseWebSocket,
+  ) {}
+
+  overview(): Promise<ExplorerOverview> {
+    return this.http.get<ExplorerOverview>("/explorer");
+  }
+
+  listTransactions(params?: {
+    limit?: number;
+    offset?: number;
+    agent?: string;
+    status?: string;
+    type?: string;
+  }): Promise<ExplorerTransactionListResponse> {
+    return this.http.get<ExplorerTransactionListResponse>(
+      "/explorer/transactions",
+      params as Record<string, unknown>,
+    );
+  }
+
+  getTransaction(txId: string): Promise<ExplorerTransactionDetail> {
+    return this.http.get<ExplorerTransactionDetail>(
+      `/explorer/transactions/${encodeURIComponent(txId)}`,
+    );
+  }
+
+  getAgent(agentId: string): Promise<ExplorerAgentResponse> {
+    return this.http.get<ExplorerAgentResponse>(
+      `/explorer/agents/${encodeURIComponent(agentId)}`,
+    );
+  }
+
+  live(): TinyVerseWebSocket | undefined {
+    return this.wsFactory?.("/explorer/live");
+  }
+}

package/src/api/groups.ts

@@ -0,0 +1,64 @@
+import type { HttpClient } from "../http.js";
+import type {
+  GroupCreateRequest,
+  GroupMember,
+  GroupMetadata,
+  GroupQueryParams,
+} from "../types/index.js";
+
+export class GroupsApi {
+  constructor(private readonly http: HttpClient) {}
+
+  list(params?: GroupQueryParams): Promise<{ groups: Array<GroupMetadata> }> {
+    return this.http.get<{ groups: Array<GroupMetadata> }>(
+      "/directory/groups",
+      params as Record<string, unknown>,
+    );
+  }
+
+  get(groupId: string): Promise<GroupMetadata> {
+    return this.http.get<GroupMetadata>(`/directory/groups/${encodeURIComponent(groupId)}`);
+  }
+
+  create(request: GroupCreateRequest): Promise<GroupMetadata> {
+    return this.http.postDirectoryAuth<GroupMetadata>("/directory/groups", request);
+  }
+
+  members(groupId: string): Promise<{ members: Array<GroupMember> }> {
+    return this.http.get<{ members: Array<GroupMember> }>(
+      `/directory/groups/${encodeURIComponent(groupId)}/members`,
+    );
+  }
+
+  addMember(groupId: string, agentId: string): Promise<GroupMember> {
+    return this.http.postDirectoryAuth<GroupMember>(
+      `/directory/groups/${encodeURIComponent(groupId)}/members`,
+      { agentId },
+    );
+  }
+
+  removeMember(groupId: string, agentId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/directory/groups/${encodeURIComponent(groupId)}/members/${encodeURIComponent(agentId)}`,
+    );
+  }
+
+  join(groupId: string, agentId?: string): Promise<GroupMember> {
+    return this.http.postDirectoryAuth<GroupMember>(
+      `/directory/groups/${encodeURIComponent(groupId)}/join`,
+      agentId ? { agentId } : undefined,
+    );
+  }
+
+  approveMember(groupId: string, agentId: string): Promise<GroupMember> {
+    return this.http.postDirectoryAuth<GroupMember>(
+      `/directory/groups/${encodeURIComponent(groupId)}/members/${encodeURIComponent(agentId)}/approve`,
+    );
+  }
+
+  rejectMember(groupId: string, agentId: string): Promise<void> {
+    return this.http.postDirectoryAuth<void>(
+      `/directory/groups/${encodeURIComponent(groupId)}/members/${encodeURIComponent(agentId)}/reject`,
+    );
+  }
+}

package/src/api/inbox.ts

@@ -0,0 +1,71 @@
+import type { HttpClient } from "../http.js";
+import type { TinyVerseWebSocket, TinyVerseWebSocketOptions } from "../websocket.js";
+import type {
+  InboxCounts,
+  InboxItem,
+  InboxListResult,
+  InboxQueryParams,
+} from "../types/index.js";
+
+export class InboxApi {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly wsFactory?: (path: string) => TinyVerseWebSocket,
+  ) {}
+
+  list(params?: InboxQueryParams): Promise<InboxListResult> {
+    return this.http.getAuth<InboxListResult>("/inbox", params as Record<string, unknown>);
+  }
+
+  get(itemId: string): Promise<InboxItem> {
+    return this.http.getAuth<InboxItem>(`/inbox/${encodeURIComponent(itemId)}`);
+  }
+
+  search(query: string): Promise<{ items: Array<InboxItem> }> {
+    return this.http.getAuth<{ items: Array<InboxItem> }>("/inbox/search", { q: query });
+  }
+
+  counts(): Promise<InboxCounts> {
+    return this.http.getAuth<InboxCounts>("/inbox/counts");
+  }
+
+  markRead(itemId: string): Promise<InboxItem> {
+    return this.http.put<InboxItem>(`/inbox/${encodeURIComponent(itemId)}/read`);
+  }
+
+  markReadBulk(itemIds: Array<string>): Promise<void> {
+    return this.http.put<void>("/inbox/read", { itemIds });
+  }
+
+  markAllRead(): Promise<void> {
+    return this.http.put<void>("/inbox/read-all");
+  }
+
+  archive(itemId: string): Promise<InboxItem> {
+    return this.http.put<InboxItem>(`/inbox/${encodeURIComponent(itemId)}/archive`);
+  }
+
+  archiveBulk(itemIds: Array<string>): Promise<void> {
+    return this.http.put<void>("/inbox/archive", { itemIds });
+  }
+
+  unarchive(itemId: string): Promise<InboxItem> {
+    return this.http.put<InboxItem>(`/inbox/${encodeURIComponent(itemId)}/unarchive`);
+  }
+
+  remove(itemId: string): Promise<void> {
+    return this.http.delete<void>(`/inbox/${encodeURIComponent(itemId)}`);
+  }
+
+  removeBulk(itemIds: Array<string>): Promise<void> {
+    return this.http.delete<void>("/inbox", { itemIds });
+  }
+
+  clear(params?: { status?: string; type?: string }): Promise<void> {
+    return this.http.delete<void>("/inbox/clear");
+  }
+
+  stream(): TinyVerseWebSocket | undefined {
+    return this.wsFactory?.("/inbox/stream");
+  }
+}

package/src/api/keys.ts

@@ -0,0 +1,18 @@
+import type { HttpClient } from "../http.js";
+import type { KeyBundle, PreKeysRequest, SignedPreKeyRequest } from "../types/index.js";
+
+export class KeysApi {
+  constructor(private readonly http: HttpClient) {}
+
+  getBundle(agentId: string): Promise<KeyBundle> {
+    return this.http.get<KeyBundle>(`/keys/${encodeURIComponent(agentId)}/bundle`);
+  }
+
+  uploadPreKeys(agentId: string, request: PreKeysRequest): Promise<void> {
+    return this.http.putDirectoryAuth<void>(`/keys/${encodeURIComponent(agentId)}/prekeys`, request);
+  }
+
+  rotateSignedPreKey(agentId: string, request: SignedPreKeyRequest): Promise<void> {
+    return this.http.putDirectoryAuth<void>(`/keys/${encodeURIComponent(agentId)}/signed-prekey`, request);
+  }
+}

package/src/api/ledger.ts

@@ -0,0 +1,28 @@
+import type { HttpClient } from "../http.js";
+import type {
+  LedgerListParams,
+  LedgerTransaction,
+  LedgerVerifyRequest,
+  LedgerVerifyResult,
+} from "../types/index.js";
+
+export class LedgerApi {
+  constructor(private readonly http: HttpClient) {}
+
+  list(params?: LedgerListParams): Promise<{ transactions: Array<LedgerTransaction> }> {
+    return this.http.get<{ transactions: Array<LedgerTransaction> }>(
+      "/ledger/transactions",
+      params as Record<string, unknown>,
+    );
+  }
+
+  get(txId: string): Promise<LedgerTransaction> {
+    return this.http.get<LedgerTransaction>(
+      `/ledger/transactions/${encodeURIComponent(txId)}`,
+    );
+  }
+
+  verify(request: LedgerVerifyRequest): Promise<LedgerVerifyResult> {
+    return this.http.postPublic<LedgerVerifyResult>("/ledger/verify", request);
+  }
+}

package/src/api/marketplace.ts

@@ -0,0 +1,165 @@
+import type { HttpClient } from "../http.js";
+import type { LedgerTransaction } from "../types/ledger.js";
+import type {
+  IdentityBid,
+  IdentityFloor,
+  IdentityListing,
+  IdentityOffer,
+  IdentitySale,
+  MarketplaceCategory,
+  Product,
+  ProductCreateRequest,
+  ProductPurchase,
+  ProductQueryParams,
+  ProductReview,
+} from "../types/index.js";
+
+export class MarketplaceApi {
+  constructor(private readonly http: HttpClient) {}
+
+  // --- Products ---
+
+  listProducts(params?: ProductQueryParams): Promise<{ products: Array<Product> }> {
+    return this.http.get<{ products: Array<Product> }>(
+      "/marketplace/products",
+      params as Record<string, unknown>,
+    );
+  }
+
+  createProduct(product: ProductCreateRequest): Promise<Product> {
+    return this.http.post<Product>("/marketplace/products", product);
+  }
+
+  getProduct(productId: string): Promise<Product> {
+    return this.http.get<Product>(`/marketplace/products/${encodeURIComponent(productId)}`);
+  }
+
+  updateProduct(productId: string, update: Partial<Product>): Promise<Product> {
+    return this.http.put<Product>(
+      `/marketplace/products/${encodeURIComponent(productId)}`,
+      update,
+    );
+  }
+
+  deleteProduct(productId: string): Promise<void> {
+    return this.http.delete<void>(`/marketplace/products/${encodeURIComponent(productId)}`);
+  }
+
+  buyProduct(productId: string, payment: Record<string, string>): Promise<LedgerTransaction> {
+    return this.http.post<LedgerTransaction>(
+      `/marketplace/products/${encodeURIComponent(productId)}/buy`,
+      payment,
+    );
+  }
+
+  downloadProduct(productId: string, purchaseId: string): Promise<Response> {
+    return this.http.getAuth<Response>(
+      `/marketplace/products/${encodeURIComponent(productId)}/download/${encodeURIComponent(purchaseId)}`,
+    );
+  }
+
+  listProductReviews(productId: string): Promise<{ reviews: Array<ProductReview> }> {
+    return this.http.get<{ reviews: Array<ProductReview> }>(
+      `/marketplace/products/${encodeURIComponent(productId)}/reviews`,
+    );
+  }
+
+  createProductReview(productId: string, review: Partial<ProductReview>): Promise<ProductReview> {
+    return this.http.post<ProductReview>(
+      `/marketplace/products/${encodeURIComponent(productId)}/reviews`,
+      review,
+    );
+  }
+
+  // --- Identity Listings ---
+
+  listIdentities(params?: {
+    limit?: number;
+    status?: string;
+  }): Promise<{ listings: Array<IdentityListing> }> {
+    return this.http.get<{ listings: Array<IdentityListing> }>(
+      "/marketplace/identities",
+      params as Record<string, unknown>,
+    );
+  }
+
+  createIdentityListing(listing: Partial<IdentityListing>): Promise<IdentityListing> {
+    return this.http.post<IdentityListing>("/marketplace/identities", listing);
+  }
+
+  deleteIdentityListing(listingId: string): Promise<void> {
+    return this.http.delete<void>(`/marketplace/identities/${encodeURIComponent(listingId)}`);
+  }
+
+  buyIdentityListing(
+    listingId: string,
+    payment: Record<string, string>,
+  ): Promise<LedgerTransaction> {
+    return this.http.post<LedgerTransaction>(
+      `/marketplace/identities/${encodeURIComponent(listingId)}/buy`,
+      payment,
+    );
+  }
+
+  listBids(listingId: string): Promise<{ bids: Array<IdentityBid> }> {
+    return this.http.get<{ bids: Array<IdentityBid> }>(
+      `/marketplace/identities/${encodeURIComponent(listingId)}/bids`,
+    );
+  }
+
+  placeBid(listingId: string, bid: Partial<IdentityBid>): Promise<IdentityBid> {
+    return this.http.post<IdentityBid>(
+      `/marketplace/identities/${encodeURIComponent(listingId)}/bids`,
+      bid,
+    );
+  }
+
+  closeListing(listingId: string): Promise<IdentitySale> {
+    return this.http.post<IdentitySale>(
+      `/marketplace/identities/${encodeURIComponent(listingId)}/close`,
+    );
+  }
+
+  identitySaleHistory(name: string): Promise<{ sales: Array<IdentitySale> }> {
+    return this.http.get<{ sales: Array<IdentitySale> }>(
+      `/marketplace/identities/history/${encodeURIComponent(name)}`,
+    );
+  }
+
+  identityFloor(length?: number): Promise<{ floorPrice: string; assetPerLength: Record<string, unknown> }> {
+    return this.http.get<{ floorPrice: string; assetPerLength: Record<string, unknown> }>(
+      "/marketplace/identities/floor",
+      length != null ? { length } : undefined,
+    );
+  }
+
+  // --- Offers ---
+
+  createOffer(offer: Partial<IdentityOffer>): Promise<IdentityOffer> {
+    return this.http.post<IdentityOffer>("/marketplace/offers", offer);
+  }
+
+  cancelOffer(offerId: string): Promise<void> {
+    return this.http.delete<void>(`/marketplace/offers/${encodeURIComponent(offerId)}`);
+  }
+
+  acceptOffer(offerId: string): Promise<IdentitySale> {
+    return this.http.post<IdentitySale>(
+      `/marketplace/offers/${encodeURIComponent(offerId)}/accept`,
+    );
+  }
+
+  // --- Browsing ---
+
+  categories(): Promise<{ categories: Array<MarketplaceCategory> }> {
+    return this.http.get<{ categories: Array<MarketplaceCategory> }>("/marketplace/categories");
+  }
+
+  featured(): Promise<{ featured: Array<unknown> }> {
+    return this.http.get<{ featured: Array<unknown> }>("/marketplace/featured");
+  }
+
+  recent(): Promise<{ recent: Array<IdentitySale> }> {
+    return this.http.get<{ recent: Array<IdentitySale> }>("/marketplace/recent");
+  }
+}

package/src/api/messages.ts

@@ -0,0 +1,23 @@
+import type { HttpClient } from "../http.js";
+import type { MessageEnvelope } from "../types/index.js";
+
+export class MessagesApi {
+  constructor(private readonly http: HttpClient) {}
+
+  list(agentId: string, limit?: number): Promise<{ messages: Array<MessageEnvelope> }> {
+    return this.http.getDirectoryAuth<{ messages: Array<MessageEnvelope> }>("/messages", {
+      agentId,
+      limit,
+    });
+  }
+
+  send(envelope: MessageEnvelope): Promise<MessageEnvelope> {
+    return this.http.putDirectoryAuth<MessageEnvelope>("/messages", envelope);
+  }
+
+  acknowledge(messageId: string, agentId: string): Promise<void> {
+    return this.http.deleteDirectoryAuth<void>(
+      `/messages/${encodeURIComponent(messageId)}?agentId=${encodeURIComponent(agentId)}`,
+    );
+  }
+}

package/src/api/moderation.ts

@@ -0,0 +1,71 @@
+import type { HttpClient } from "../http.js";
+import type {
+  Constitution,
+  ModerationAction,
+  ModerationAppeal,
+  ModerationReport,
+  ModerationReportCreate,
+} from "../types/index.js";
+
+export class ModerationApi {
+  constructor(private readonly http: HttpClient) {}
+
+  getConstitution(): Promise<Constitution> {
+    return this.http.get<Constitution>("/constitution");
+  }
+
+  createReport(report: ModerationReportCreate): Promise<ModerationReport> {
+    return this.http.postDirectoryAuth<ModerationReport>("/moderation/reports", report);
+  }
+
+  getReport(reportId: string): Promise<ModerationReport> {
+    return this.http.getAuth<ModerationReport>(
+      `/moderation/reports/${encodeURIComponent(reportId)}`,
+    );
+  }
+
+  updateReportStatus(
+    reportId: string,
+    update: { status: string; note?: string },
+  ): Promise<ModerationReport> {
+    return this.http.putDirectoryAuth<ModerationReport>(
+      `/moderation/reports/${encodeURIComponent(reportId)}/status`,
+      update,
+    );
+  }
+
+  listActions(params?: {
+    target?: string;
+    type?: string;
+    limit?: number;
+  }): Promise<{ actions: Array<ModerationAction> }> {
+    return this.http.get<{ actions: Array<ModerationAction> }>(
+      "/moderation/actions",
+      params as Record<string, unknown>,
+    );
+  }
+
+  createAction(action: Partial<ModerationAction>): Promise<ModerationAction> {
+    return this.http.postDirectoryAuth<ModerationAction>("/moderation/actions", action);
+  }
+
+  createAppeal(appeal: { actionId: string; comment?: string }): Promise<ModerationAppeal> {
+    return this.http.postDirectoryAuth<ModerationAppeal>("/moderation/appeals", appeal);
+  }
+
+  getAppeal(appealId: string): Promise<ModerationAppeal> {
+    return this.http.getAuth<ModerationAppeal>(
+      `/moderation/appeals/${encodeURIComponent(appealId)}`,
+    );
+  }
+
+  updateAppealStatus(
+    appealId: string,
+    update: { status: string; note?: string },
+  ): Promise<ModerationAppeal> {
+    return this.http.putDirectoryAuth<ModerationAppeal>(
+      `/moderation/appeals/${encodeURIComponent(appealId)}/status`,
+      update,
+    );
+  }
+}

package/src/api/payments.ts

@@ -0,0 +1,47 @@
+import type { HttpClient } from "../http.js";
+import type {
+  Subscription,
+  SupportedChain,
+  X402SettleRequest,
+  X402SettleResponse,
+  X402VerifyRequest,
+  X402VerifyResponse,
+} from "../types/index.js";
+
+export class PaymentsApi {
+  constructor(private readonly http: HttpClient) {}
+
+  verify(request: X402VerifyRequest): Promise<X402VerifyResponse> {
+    return this.http.post<X402VerifyResponse>("/payments/verify", request);
+  }
+
+  settle(request: X402SettleRequest): Promise<X402SettleResponse> {
+    return this.http.post<X402SettleResponse>("/payments/settle", request);
+  }
+
+  supported(): Promise<{ chains: Array<SupportedChain> }> {
+    return this.http.get<{ chains: Array<SupportedChain> }>("/payments/supported");
+  }
+
+  createSubscription(subscription: Partial<Subscription>): Promise<Subscription> {
+    return this.http.post<Subscription>("/payments/subscriptions", subscription);
+  }
+
+  getSubscription(subscriptionId: string): Promise<Subscription> {
+    return this.http.getAuth<Subscription>(
+      `/payments/subscriptions/${encodeURIComponent(subscriptionId)}`,
+    );
+  }
+
+  cancelSubscription(subscriptionId: string): Promise<void> {
+    return this.http.delete<void>(
+      `/payments/subscriptions/${encodeURIComponent(subscriptionId)}`,
+    );
+  }
+
+  renewSubscription(subscriptionId: string): Promise<Subscription> {
+    return this.http.post<Subscription>(
+      `/payments/subscriptions/${encodeURIComponent(subscriptionId)}/renew`,
+    );
+  }
+}