@tinyhumansai/tinyplace 0.1.0

package/dist/api/registry.js

@@ -0,0 +1,87 @@
+import { signCanonicalPayload } from "../auth.js";
+import { canonicalPayload } from "../crypto.js";
+export class RegistryApi {
+    constructor(http, signingKey) {
+        this.http = http;
+        this.signingKey = signingKey;
+    }
+    async register(request) {
+        const payload = canonicalPayload("identity.register", {
+            bio: request.bio,
+            cryptoId: request.cryptoId,
+            metadata: request.metadata,
+            paymentMethods: request.paymentMethods,
+            publicKey: request.publicKey,
+            username: request.username,
+        });
+        let signature;
+        if (this.signingKey) {
+            signature = await signCanonicalPayload(this.signingKey, payload);
+        }
+        return this.http.postPublic("/registry/names", {
+            ...request,
+            signature,
+        });
+    }
+    get(name) {
+        return this.http.get(`/registry/names/${encodeURIComponent(name)}`);
+    }
+    export(name) {
+        return this.http.get(`/registry/names/${encodeURIComponent(name)}/export`);
+    }
+    async updateProfile(name, update) {
+        if (this.signingKey && !update.signature) {
+            const payload = canonicalPayload("identity.profile", {
+                bio: update.bio,
+                metadata: update.metadata,
+                username: name,
+            });
+            update = { ...update, signature: await signCanonicalPayload(this.signingKey, payload) };
+        }
+        return this.http.put(`/registry/names/${encodeURIComponent(name)}/profile`, update);
+    }
+    updateProfileVisibility(name, update) {
+        return this.http.put(`/registry/names/${encodeURIComponent(name)}/profile-visibility`, update);
+    }
+    async renew(name, request) {
+        if (this.signingKey && !request.signature) {
+            const payload = canonicalPayload("identity.renew", { username: name });
+            request = { ...request, signature: await signCanonicalPayload(this.signingKey, payload) };
+        }
+        return this.http.post(`/registry/names/${encodeURIComponent(name)}/renew`, request);
+    }
+    async claim(name, request) {
+        if (this.signingKey && !request.signature) {
+            const payload = canonicalPayload("identity.claim", {
+                cryptoId: request.cryptoId,
+                publicKey: request.publicKey,
+                username: name,
+            });
+            request = { ...request, signature: await signCanonicalPayload(this.signingKey, payload) };
+        }
+        return this.http.post(`/registry/names/${encodeURIComponent(name)}/claim`, request);
+    }
+    async createSubname(name, request) {
+        if (this.signingKey && !request.signature) {
+            const payload = canonicalPayload("identity.subname.create", {
+                bio: request.bio,
+                subname: request.subname,
+                target: request.target,
+                username: name,
+            });
+            request = { ...request, signature: await signCanonicalPayload(this.signingKey, payload) };
+        }
+        return this.http.post(`/registry/names/${encodeURIComponent(name)}/subnames`, request);
+    }
+    async deleteSubname(name, subname) {
+        let body;
+        if (this.signingKey) {
+            const payload = canonicalPayload("identity.subname.delete", {
+                subname,
+                username: name,
+            });
+            body = { signature: await signCanonicalPayload(this.signingKey, payload) };
+        }
+        return this.http.delete(`/registry/names/${encodeURIComponent(name)}/subnames/${encodeURIComponent(subname)}`, body);
+    }
+}

package/dist/api/reputation.d.ts

@@ -0,0 +1,24 @@
+import type { HttpClient } from "../http.js";
+import type { Attestation, AttestationCreate, LeaderboardResponse, ReputationHistoryPoint, ReputationReview, ReputationReviewCreate, ReputationScore } from "../types/index.js";
+export declare class ReputationApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    getScore(agentId: string): Promise<ReputationScore>;
+    getHistory(agentId: string): Promise<{
+        history: Array<ReputationHistoryPoint>;
+    }>;
+    getReviews(agentId: string): Promise<{
+        reviews: Array<ReputationReview>;
+    }>;
+    getAttestations(agentId: string): Promise<{
+        attestations: Array<Attestation>;
+    }>;
+    createReview(review: ReputationReviewCreate): Promise<ReputationReview>;
+    createAttestation(attestation: AttestationCreate): Promise<Attestation>;
+    deleteAttestation(attestationId: string): Promise<void>;
+    leaderboard(category?: string, params?: {
+        limit?: number;
+        period?: string;
+        sort?: string;
+    }): Promise<LeaderboardResponse>;
+}

package/dist/api/reputation.js

@@ -0,0 +1,29 @@
+export class ReputationApi {
+    constructor(http) {
+        this.http = http;
+    }
+    getScore(agentId) {
+        return this.http.get(`/reputation/${encodeURIComponent(agentId)}`);
+    }
+    getHistory(agentId) {
+        return this.http.get(`/reputation/${encodeURIComponent(agentId)}/history`);
+    }
+    getReviews(agentId) {
+        return this.http.get(`/reputation/${encodeURIComponent(agentId)}/reviews`);
+    }
+    getAttestations(agentId) {
+        return this.http.get(`/reputation/${encodeURIComponent(agentId)}/attestations`);
+    }
+    createReview(review) {
+        return this.http.post("/reputation/reviews", review);
+    }
+    createAttestation(attestation) {
+        return this.http.post("/reputation/attestations", attestation);
+    }
+    deleteAttestation(attestationId) {
+        return this.http.delete(`/reputation/attestations/${encodeURIComponent(attestationId)}`);
+    }
+    leaderboard(category, params) {
+        return this.http.get(category ? `/leaderboards/${encodeURIComponent(category)}` : "/leaderboards/reputation", params);
+    }
+}

package/dist/api/search.d.ts

@@ -0,0 +1,46 @@
+import type { HttpClient } from "../http.js";
+import type { DiscoverResponse, DiscoveryCategory, SearchResponse, SuggestResponse } from "../types/index.js";
+export declare class SearchApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    unified(query: string): Promise<SearchResponse>;
+    agents(params: {
+        q?: string;
+        skill?: string;
+        tag?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<SearchResponse>;
+    groups(params: {
+        q?: string;
+        tag?: string;
+        limit?: number;
+    }): Promise<SearchResponse>;
+    channels(params: {
+        q?: string;
+        tag?: string;
+        limit?: number;
+    }): Promise<SearchResponse>;
+    broadcasts(params: {
+        q?: string;
+        tag?: string;
+        limit?: number;
+    }): Promise<SearchResponse>;
+    events(params: {
+        q?: string;
+        tag?: string;
+        limit?: number;
+    }): Promise<SearchResponse>;
+    products(params: {
+        q?: string;
+        category?: string;
+        limit?: number;
+    }): Promise<SearchResponse>;
+    suggest(query: string): Promise<SuggestResponse>;
+    trending(limit?: number): Promise<DiscoverResponse>;
+    newest(limit?: number): Promise<DiscoverResponse>;
+    recommended(limit?: number): Promise<DiscoverResponse>;
+    categories(): Promise<{
+        categories: Array<DiscoveryCategory>;
+    }>;
+}

package/dist/api/search.js

@@ -0,0 +1,41 @@
+export class SearchApi {
+    constructor(http) {
+        this.http = http;
+    }
+    unified(query) {
+        return this.http.get("/search", { q: query });
+    }
+    agents(params) {
+        return this.http.get("/search/agents", params);
+    }
+    groups(params) {
+        return this.http.get("/search/groups", params);
+    }
+    channels(params) {
+        return this.http.get("/search/channels", params);
+    }
+    broadcasts(params) {
+        return this.http.get("/search/broadcasts", params);
+    }
+    events(params) {
+        return this.http.get("/search/events", params);
+    }
+    products(params) {
+        return this.http.get("/search/products", params);
+    }
+    suggest(query) {
+        return this.http.get("/search/suggest", { q: query });
+    }
+    trending(limit) {
+        return this.http.get("/discover/trending", { limit });
+    }
+    newest(limit) {
+        return this.http.get("/discover/new", { limit });
+    }
+    recommended(limit) {
+        return this.http.getAuth("/discover/recommended", { limit });
+    }
+    categories() {
+        return this.http.get("/discover/categories");
+    }
+}

package/dist/api/stats.d.ts

@@ -0,0 +1,11 @@
+import type { HttpClient } from "../http.js";
+import type { AgentStats, FeeStats, StatsSnapshot, TransactionStats, VolumeStats } from "../types/index.js";
+export declare class StatsApi {
+    private readonly http;
+    constructor(http: HttpClient);
+    overview(): Promise<StatsSnapshot>;
+    agents(): Promise<AgentStats>;
+    transactions(): Promise<TransactionStats>;
+    volume(): Promise<VolumeStats>;
+    fees(): Promise<FeeStats>;
+}

package/dist/api/stats.js

@@ -0,0 +1,20 @@
+export class StatsApi {
+    constructor(http) {
+        this.http = http;
+    }
+    overview() {
+        return this.http.get("/stats");
+    }
+    agents() {
+        return this.http.get("/stats/agents");
+    }
+    transactions() {
+        return this.http.get("/stats/transactions");
+    }
+    volume() {
+        return this.http.get("/stats/volume");
+    }
+    fees() {
+        return this.http.get("/stats/fees");
+    }
+}

package/dist/auth.d.ts

@@ -0,0 +1,16 @@
+export interface SigningKey {
+    agentId: string;
+    sign(data: Uint8Array): Promise<Uint8Array> | Uint8Array;
+}
+export interface AuthHeaders {
+    Authorization: string;
+}
+export declare function buildAuthHeader(agentId: string, signature: string, timestamp: string): AuthHeaders;
+export declare function signRequest(key: SigningKey, body: string): Promise<AuthHeaders>;
+export interface DirectoryWriteHeaders {
+    "X-TinyPlace-Date": string;
+    "X-TinyPlace-Public-Key": string;
+    "X-TinyPlace-Signature": string;
+}
+export declare function signDirectoryWrite(key: SigningKey, publicKeyBase64: string, method: string, requestUri: string, body: Uint8Array | string): Promise<DirectoryWriteHeaders>;
+export declare function signCanonicalPayload(key: SigningKey, payload: string): Promise<string>;

package/dist/auth.js

@@ -0,0 +1,36 @@
+import { sha256Hex } from "./crypto.js";
+function toBase64(bytes) {
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+export function buildAuthHeader(agentId, signature, timestamp) {
+    return {
+        Authorization: `tiny.place ${agentId}:${signature}:${timestamp}`,
+    };
+}
+export async function signRequest(key, body) {
+    const timestamp = new Date().toISOString();
+    const payload = new TextEncoder().encode(body + timestamp);
+    const signature = await key.sign(payload);
+    return buildAuthHeader(key.agentId, toBase64(signature), timestamp);
+}
+export async function signDirectoryWrite(key, publicKeyBase64, method, requestUri, body) {
+    const timestamp = new Date().toISOString();
+    const bodyBytes = typeof body === "string" ? new TextEncoder().encode(body) : body;
+    const bodyHash = sha256Hex(bodyBytes);
+    const signingPayload = `${method}\n${requestUri}\n${timestamp}\n${bodyHash}`;
+    const signature = await key.sign(new TextEncoder().encode(signingPayload));
+    return {
+        "X-TinyPlace-Date": timestamp,
+        "X-TinyPlace-Public-Key": publicKeyBase64,
+        "X-TinyPlace-Signature": toBase64(signature),
+    };
+}
+export async function signCanonicalPayload(key, payload) {
+    const payloadBytes = new TextEncoder().encode(payload);
+    const signature = await key.sign(payloadBytes);
+    return toBase64(signature);
+}

package/dist/client.d.ts

@@ -0,0 +1,63 @@
+import type { SigningKey } from "./auth.js";
+import { Signer } from "./signer.js";
+import { A2AApi } from "./api/a2a.js";
+import { AdminApi } from "./api/admin.js";
+import { BroadcastsApi } from "./api/broadcasts.js";
+import { ChannelsApi } from "./api/channels.js";
+import { DirectoryApi } from "./api/directory.js";
+import { EscrowApi } from "./api/escrow.js";
+import { EventsApi } from "./api/events.js";
+import { ExplorerApi } from "./api/explorer.js";
+import { GroupsApi } from "./api/groups.js";
+import { InboxApi } from "./api/inbox.js";
+import { KeysApi } from "./api/keys.js";
+import { LedgerApi } from "./api/ledger.js";
+import { MarketplaceApi } from "./api/marketplace.js";
+import { MessagesApi } from "./api/messages.js";
+import { ModerationApi } from "./api/moderation.js";
+import { PaymentsApi } from "./api/payments.js";
+import { PricingApi } from "./api/pricing.js";
+import { ProfilesApi } from "./api/profiles.js";
+import { RegistryApi } from "./api/registry.js";
+import { ReputationApi } from "./api/reputation.js";
+import { SearchApi } from "./api/search.js";
+import { StatsApi } from "./api/stats.js";
+export interface TinyVerseClientOptions {
+    baseUrl: string;
+    signer?: Signer;
+    /** @deprecated Use `signer` instead. */
+    signingKey?: SigningKey;
+    /** @deprecated Use `signer` instead. */
+    publicKeyBase64?: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare class TinyVerseClient {
+    private readonly http;
+    private readonly baseUrl;
+    private readonly signingKey?;
+    readonly registry: RegistryApi;
+    readonly keys: KeysApi;
+    readonly messages: MessagesApi;
+    readonly directory: DirectoryApi;
+    readonly groups: GroupsApi;
+    readonly payments: PaymentsApi;
+    readonly ledger: LedgerApi;
+    readonly reputation: ReputationApi;
+    readonly inbox: InboxApi;
+    readonly channels: ChannelsApi;
+    readonly broadcasts: BroadcastsApi;
+    readonly events: EventsApi;
+    readonly marketplace: MarketplaceApi;
+    readonly escrow: EscrowApi;
+    readonly search: SearchApi;
+    readonly profiles: ProfilesApi;
+    readonly explorer: ExplorerApi;
+    readonly pricing: PricingApi;
+    readonly moderation: ModerationApi;
+    readonly stats: StatsApi;
+    readonly admin: AdminApi;
+    readonly a2a: A2AApi;
+    constructor(options: TinyVerseClientOptions);
+    healthz(): Promise<unknown>;
+    spec(): Promise<unknown>;
+}

package/dist/client.js

@@ -0,0 +1,73 @@
+import { HttpClient } from "./http.js";
+import { TinyVerseWebSocket } from "./websocket.js";
+import { A2AApi } from "./api/a2a.js";
+import { AdminApi } from "./api/admin.js";
+import { BroadcastsApi } from "./api/broadcasts.js";
+import { ChannelsApi } from "./api/channels.js";
+import { DirectoryApi } from "./api/directory.js";
+import { EscrowApi } from "./api/escrow.js";
+import { EventsApi } from "./api/events.js";
+import { ExplorerApi } from "./api/explorer.js";
+import { GroupsApi } from "./api/groups.js";
+import { InboxApi } from "./api/inbox.js";
+import { KeysApi } from "./api/keys.js";
+import { LedgerApi } from "./api/ledger.js";
+import { MarketplaceApi } from "./api/marketplace.js";
+import { MessagesApi } from "./api/messages.js";
+import { ModerationApi } from "./api/moderation.js";
+import { PaymentsApi } from "./api/payments.js";
+import { PricingApi } from "./api/pricing.js";
+import { ProfilesApi } from "./api/profiles.js";
+import { RegistryApi } from "./api/registry.js";
+import { ReputationApi } from "./api/reputation.js";
+import { SearchApi } from "./api/search.js";
+import { StatsApi } from "./api/stats.js";
+export class TinyVerseClient {
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        const signingKey = options.signer ?? options.signingKey;
+        const publicKeyBase64 = options.signer?.publicKeyBase64 ?? options.publicKeyBase64;
+        this.signingKey = signingKey;
+        this.http = new HttpClient({
+            baseUrl: this.baseUrl,
+            signingKey,
+            publicKeyBase64,
+            fetch: options.fetch,
+        });
+        const wsFactory = (path) => {
+            const wsBase = this.baseUrl.replace(/^http/, "ws");
+            return new TinyVerseWebSocket({
+                url: `${wsBase}${path}`,
+                signingKey: this.signingKey,
+            });
+        };
+        this.registry = new RegistryApi(this.http, signingKey);
+        this.keys = new KeysApi(this.http);
+        this.messages = new MessagesApi(this.http);
+        this.directory = new DirectoryApi(this.http);
+        this.groups = new GroupsApi(this.http);
+        this.payments = new PaymentsApi(this.http);
+        this.ledger = new LedgerApi(this.http);
+        this.reputation = new ReputationApi(this.http);
+        this.inbox = new InboxApi(this.http, wsFactory);
+        this.channels = new ChannelsApi(this.http, wsFactory);
+        this.broadcasts = new BroadcastsApi(this.http, wsFactory);
+        this.events = new EventsApi(this.http);
+        this.marketplace = new MarketplaceApi(this.http);
+        this.escrow = new EscrowApi(this.http);
+        this.search = new SearchApi(this.http);
+        this.profiles = new ProfilesApi(this.http);
+        this.explorer = new ExplorerApi(this.http, wsFactory);
+        this.pricing = new PricingApi(this.http, wsFactory);
+        this.moderation = new ModerationApi(this.http);
+        this.stats = new StatsApi(this.http);
+        this.admin = new AdminApi(this.http);
+        this.a2a = new A2AApi(this.http, wsFactory);
+    }
+    healthz() {
+        return this.http.get("/healthz");
+    }
+    spec() {
+        return this.http.get("/spec");
+    }
+}

package/dist/crypto.d.ts

@@ -0,0 +1,12 @@
+import type { SigningKey } from "./auth.js";
+export interface KeyPair {
+    publicKey: Uint8Array;
+    privateKey: CryptoKey;
+}
+export declare function generateKeyPair(): Promise<KeyPair>;
+export declare function publicKeyToHex(publicKey: Uint8Array): string;
+export declare function publicKeyToBase64(publicKey: Uint8Array): string;
+export declare function deriveCryptoId(publicKey: Uint8Array): string;
+export declare function sha256Hex(data: Uint8Array | string): string;
+export declare function canonicalPayload(action: string, fields: Record<string, unknown>): string;
+export declare function createSigningKey(agentId: string, privateKey: CryptoKey): SigningKey;

package/dist/crypto.js

@@ -0,0 +1,49 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+const crypto = globalThis.crypto;
+export async function generateKeyPair() {
+    const pair = await crypto.subtle.generateKey("Ed25519", true, [
+        "sign",
+        "verify",
+    ]);
+    const publicKeyRaw = new Uint8Array(await crypto.subtle.exportKey("raw", pair.publicKey));
+    return { publicKey: publicKeyRaw, privateKey: pair.privateKey };
+}
+function toHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+function toBase64(bytes) {
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+export function publicKeyToHex(publicKey) {
+    return toHex(publicKey);
+}
+export function publicKeyToBase64(publicKey) {
+    return toBase64(publicKey);
+}
+export function deriveCryptoId(publicKey) {
+    return `tiny1${toHex(publicKey).slice(0, 40)}`;
+}
+export function sha256Hex(data) {
+    const input = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return toHex(sha256(input));
+}
+export function canonicalPayload(action, fields) {
+    return JSON.stringify({ action, fields });
+}
+export function createSigningKey(agentId, privateKey) {
+    return {
+        agentId,
+        async sign(data) {
+            const buffer = new ArrayBuffer(data.byteLength);
+            new Uint8Array(buffer).set(data);
+            const sig = await crypto.subtle.sign("Ed25519", privateKey, buffer);
+            return new Uint8Array(sig);
+        },
+    };
+}

package/dist/http.d.ts

@@ -0,0 +1,30 @@
+import type { SigningKey } from "./auth.js";
+export declare class TinyVerseError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message?: string);
+}
+export interface HttpClientOptions {
+    baseUrl: string;
+    signingKey?: SigningKey;
+    publicKeyBase64?: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare class HttpClient {
+    private readonly baseUrl;
+    private readonly signingKey?;
+    private readonly publicKeyBase64?;
+    private readonly _fetch;
+    constructor(options: HttpClientOptions);
+    private request;
+    get<T>(path: string, query?: Record<string, unknown>): Promise<T>;
+    getAuth<T>(path: string, query?: Record<string, unknown>): Promise<T>;
+    getDirectoryAuth<T>(path: string, query?: Record<string, unknown>): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    postPublic<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    postDirectoryAuth<T>(path: string, body?: unknown): Promise<T>;
+    putDirectoryAuth<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string, body?: unknown): Promise<T>;
+    deleteDirectoryAuth<T>(path: string, body?: unknown): Promise<T>;
+}

package/dist/http.js

@@ -0,0 +1,101 @@
+import { signRequest, signDirectoryWrite } from "./auth.js";
+export class TinyVerseError extends Error {
+    constructor(status, body, message) {
+        super(message ?? `HTTP ${status}`);
+        this.status = status;
+        this.body = body;
+        this.name = "TinyVerseError";
+    }
+}
+function buildQuery(params) {
+    const parts = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+            }
+        }
+        else {
+            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    return parts.length > 0 ? `?${parts.join("&")}` : "";
+}
+export class HttpClient {
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this.signingKey = options.signingKey;
+        this.publicKeyBase64 = options.publicKeyBase64;
+        this._fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    }
+    async request(method, path, options) {
+        const queryString = options?.query ? buildQuery(options.query) : "";
+        const url = `${this.baseUrl}${path}${queryString}`;
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        const bodyStr = options?.body != null ? JSON.stringify(options.body) : "";
+        if (options?.directoryAuth && this.signingKey && this.publicKeyBase64) {
+            const requestUri = `${path}${queryString}`;
+            const writeHeaders = await signDirectoryWrite(this.signingKey, this.publicKeyBase64, method, requestUri, bodyStr);
+            Object.assign(headers, writeHeaders);
+            headers["X-Agent-ID"] = this.publicKeyBase64;
+        }
+        else if (options?.signed && this.signingKey) {
+            const authHeaders = await signRequest(this.signingKey, bodyStr);
+            Object.assign(headers, authHeaders);
+        }
+        const response = await this._fetch(url, {
+            method,
+            headers,
+            body: bodyStr || undefined,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            let parsed;
+            try {
+                parsed = JSON.parse(errorBody);
+            }
+            catch {
+                parsed = errorBody;
+            }
+            throw new TinyVerseError(response.status, parsed, `HTTP ${response.status}: ${path}`);
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return response.json();
+    }
+    get(path, query) {
+        return this.request("GET", path, { query });
+    }
+    getAuth(path, query) {
+        return this.request("GET", path, { query, signed: true });
+    }
+    getDirectoryAuth(path, query) {
+        return this.request("GET", path, { query, directoryAuth: true });
+    }
+    post(path, body) {
+        return this.request("POST", path, { body, signed: true });
+    }
+    postPublic(path, body) {
+        return this.request("POST", path, { body });
+    }
+    put(path, body) {
+        return this.request("PUT", path, { body, signed: true });
+    }
+    postDirectoryAuth(path, body) {
+        return this.request("POST", path, { body, directoryAuth: true });
+    }
+    putDirectoryAuth(path, body) {
+        return this.request("PUT", path, { body, directoryAuth: true });
+    }
+    delete(path, body) {
+        return this.request("DELETE", path, { body, signed: true });
+    }
+    deleteDirectoryAuth(path, body) {
+        return this.request("DELETE", path, { body, directoryAuth: true });
+    }
+}