@majikah/sdk 0.1.0

package/dist/services/notary/NotaryClient.js

@@ -0,0 +1,291 @@
+import { MajikSignature, } from "@majikah/majik-signature";
+import { APIError } from "../../errors/APIError";
+import { MajikahError } from "../../errors/MajikahError";
+import { assertNonEmpty } from "../shared/validation";
+import { sleep } from "../shared/sleep";
+import { validateSealHash } from "./validation";
+import { normalizeToBlob } from "../shared/encoding";
+/**
+ * Client for notarizing sealed Majik Signature documents on-chain.
+ *
+ * Notarization uses a two-phase flow:
+ *
+ * 1. A sealed document is identified by its `sealHash` and payment is
+ *    initiated or detected.
+ * 2. After payment is complete, the seal is registered on-chain and the
+ *    resulting anchor is embedded back into the document.
+ *
+ * Lower-level methods such as `payment()`, `register()`, and `status()`
+ * expose the individual API operations, while the higher-level methods
+ * provide complete file-aware workflows.
+ */
+export class NotaryClient {
+    http;
+    /**
+     * Creates a Notary client using the provided HTTP transport.
+     *
+     * @param http HTTP client used to communicate with the Majikah API.
+     */
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Creates or resumes payment for a sealed document.
+     *
+     * If the seal has already been anchored, the existing chain anchor is
+     * returned and no payment is required.
+     *
+     * If payment has not yet been completed, the response contains checkout
+     * information that can be presented to the user.
+     *
+     * @param sealHash Unique hash identifying the sealed document.
+     * @returns Either an existing chain anchor or payment checkout information.
+     * @throws APIError When payment has already been completed for the seal.
+     */
+    async payment(sealHash) {
+        validateSealHash(sealHash);
+        const raw = await this.http.request("notary", "/payment", {
+            method: "POST",
+            body: { sealHash },
+        });
+        if ("anchor" in raw) {
+            return { status: "already_anchored", anchor: raw.anchor };
+        }
+        return { status: "checkout_required", ...raw };
+    }
+    /**
+     * Submits a paid seal for on-chain notarization.
+     *
+     * Registration returns immediately. If the anchor is still being confirmed,
+     * use {@link status} or {@link pollUntilTerminal} to track its progress.
+     *
+     * Payment must already be completed for the supplied `sealHash`.
+     *
+     * @param sealHash Unique hash identifying the paid sealed document.
+     * @returns The newly created or existing chain anchor.
+     * @throws APIError When no completed payment exists for the seal hash.
+     */
+    async register(sealHash) {
+        validateSealHash(sealHash);
+        return this.http.request("notary", "/register", {
+            method: "POST",
+            body: { sealHash },
+        });
+    }
+    /**
+     * Retrieves the current confirmation status of a notarization anchor.
+     *
+     * @param anchorId Identifier of the chain anchor.
+     * @returns The current chain anchor state.
+     * @throws ValidationError When the anchor ID is empty.
+     */
+    async status(anchorId) {
+        assertNonEmpty(anchorId, "anchorId");
+        return this.http.request("notary", `/status/${encodeURIComponent(anchorId)}`, {
+            method: "GET",
+        });
+    }
+    /**
+     * Polls a notarization anchor until it reaches a terminal state.
+     *
+     * Resolves when the anchor becomes `confirmed`, `finalized`, or `failed`.
+     * A failed anchor is returned normally rather than thrown as an exception;
+     * callers should inspect `anchor.status` to determine the outcome.
+     *
+     * @param anchorId Identifier of the chain anchor to monitor.
+     * @param options Polling interval and timeout settings.
+     * @returns The anchor in its terminal state.
+     * @throws MajikahError When the anchor remains pending until the timeout.
+     */
+    async pollUntilTerminal(anchorId, options) {
+        const interval = options?.intervalMs ?? 2000;
+        const timeout = options?.timeoutMs ?? 130_000;
+        const start = Date.now();
+        for (;;) {
+            const anchor = await this.status(anchorId);
+            if (anchor.status !== "pending") {
+                return anchor;
+            }
+            if (Date.now() - start >= timeout) {
+                throw new MajikahError(`Anchor "${anchorId}" did not reach a terminal state within ${timeout}ms (last status: pending). ` +
+                    `Call status("${anchorId}") again later to check.`);
+            }
+            await sleep(interval);
+        }
+    }
+    /**
+     * Starts the payment-aware notarization flow for an already-sealed file.
+     *
+     * This method does not wait for payment or blockchain confirmation.
+     * Its result tells the caller what action is required next:
+     *
+     * - `anchored`: The document was already anchored and the returned blob
+     *   contains the existing anchor.
+     * - `payment_required`: Present the checkout information to the user,
+     *   then call {@link finalizeNotarization} after payment completes.
+     * - `ready_to_finalize`: Payment was previously completed, so
+     *   {@link finalizeNotarization} can be called immediately.
+     *
+     * @param file Sealed file to notarize.
+     * @param options Optional MIME type used when reading and updating the file.
+     * @returns The current state of the notarization flow.
+     * @throws ValidationError When the file is not sealed.
+     *
+     * @example
+     * ```ts
+     * const result = await majikah.notary.initiateNotarization(sealedFile);
+     *
+     * if (result.status === "payment_required") {
+     *   showQrCode(result.checkout.checkout_url);
+     *
+     *   // After the user completes payment:
+     *   const { blob, anchor } =
+     *     await majikah.notary.finalizeNotarization(
+     *       sealedFile,
+     *       result.sealHash,
+     *     );
+     * }
+     * ```
+     */
+    async initiateNotarization(file, options) {
+        const mimeOpt = options?.mimeType
+            ? { mimeType: options.mimeType }
+            : undefined;
+        const sealInfo = await MajikSignature.getSealInfo(file, mimeOpt);
+        if (!sealInfo) {
+            throw new (await import("../../errors/ValidationError")).ValidationError("File is not sealed — notarization requires a sealed envelope. " +
+                "Seal it first via MajikSignature.seal(), or use sealAndInitiateNotarization() / signSealAndInitiateNotarization().", file);
+        }
+        const sealHash = sealInfo.sealHash;
+        try {
+            const result = await this.payment(sealHash);
+            if (result.status === "already_anchored") {
+                const blob = await MajikSignature.registerChainAnchor(file, result.anchor, mimeOpt);
+                return {
+                    status: "anchored",
+                    blob,
+                    anchor: result.anchor,
+                };
+            }
+            const { status: _drop, ...checkout } = result;
+            const sealedBlob = normalizeToBlob(file, options?.mimeType ?? "application/octet-stream");
+            return {
+                status: "payment_required",
+                sealHash,
+                checkout,
+                sealedBlob,
+            };
+        }
+        catch (err) {
+            if (err instanceof APIError && err.code === "ALREADY_PAID") {
+                const sealedBlob = normalizeToBlob(file, options?.mimeType ?? "application/octet-stream");
+                return {
+                    status: "ready_to_finalize",
+                    sealHash,
+                    sealedBlob,
+                };
+            }
+            throw err;
+        }
+    }
+    /**
+     * Completes notarization after payment has been completed.
+     *
+     * Registers the sealed document's `sealHash`, waits for confirmation when
+     * necessary, and embeds the resulting chain anchor back into the file.
+     *
+     * Call this after {@link initiateNotarization} returns either
+     * `payment_required` and the user has paid, or `ready_to_finalize`.
+     *
+     * @param file Sealed file being notarized.
+     * @param sealHash Seal hash returned by {@link initiateNotarization}.
+     * @param options MIME type and polling settings.
+     * @returns The notarized file and its chain anchor.
+     */
+    async finalizeNotarization(file, sealHash, options) {
+        validateSealHash(sealHash);
+        let anchor = await this.register(sealHash);
+        if (anchor.status === "pending") {
+            anchor = await this.pollUntilTerminal(anchor.id, options?.poll);
+        }
+        const blob = await MajikSignature.registerChainAnchor(file, anchor, options?.mimeType ? { mimeType: options.mimeType } : undefined);
+        return {
+            blob,
+            anchor,
+        };
+    }
+    /**
+     * Seals an already-signed file and starts the notarization flow.
+     *
+     * Use this when all required signers have already signed the document and
+     * the issuer is ready to seal the signature envelope and begin payment.
+     *
+     * @param file Already-signed file.
+     * @param issuerKey Unlocked MajikKey belonging to the issuer sealing the file.
+     * @param options MIME type and seal timestamp settings.
+     * @returns The current state of the notarization flow.
+     *
+     * @example
+     * ```ts
+     * const result =
+     *   await majikah.notary.sealAndInitiateNotarization(
+     *     signedFile,
+     *     issuerKey,
+     *   );
+     * ```
+     */
+    async sealAndInitiateNotarization(file, issuerKey, options) {
+        const { blob: sealedBlob } = await MajikSignature.seal(file, issuerKey, {
+            mimeType: options?.mimeType,
+            timestamp: options?.sealTimestamp,
+        });
+        return this.initiateNotarization(sealedBlob, {
+            mimeType: options?.mimeType,
+        });
+    }
+    /**
+     * Signs, seals, and starts notarization for a single-signer document.
+     *
+     * This is the complete convenience flow for documents where the supplied
+     * key is the only signer:
+     *
+     * `sign → seal → initiate notarization`
+     *
+     * Sealing makes the envelope immutable to further signatures, so this
+     * method should not be used when additional signers still need to sign.
+     * For multi-signature documents, have all signers sign first and then use
+     * {@link sealAndInitiateNotarization}.
+     *
+     * @param file File to sign and notarize.
+     * @param key Unlocked MajikKey used for both signing and sealing.
+     * @param options Signing, MIME type, validity, and sealing settings.
+     * @returns The current state of the notarization flow.
+     *
+     * @example
+     * ```ts
+     * const result =
+     *   await majikah.notary.signSealAndInitiateNotarization(
+     *     file,
+     *     aliceKey,
+     *     {
+     *       contentType: "application/pdf",
+     *     },
+     *   );
+     * ```
+     */
+    async signSealAndInitiateNotarization(file, key, options) {
+        const { blob: signedBlob } = await MajikSignature.signFile(file, key, {
+            contentType: options?.contentType,
+            timestamp: options?.timestamp,
+            mimeType: options?.mimeType,
+            expectedSigners: options?.expectedSigners,
+            validUntil: options?.validUntil,
+        });
+        return this.sealAndInitiateNotarization(signedBlob, key, {
+            mimeType: options?.mimeType,
+            sealTimestamp: options?.sealTimestamp,
+        });
+    }
+}
+Object.freeze(NotaryClient);
+Object.freeze(NotaryClient.prototype);

package/dist/services/notary/validation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mirrors the gateway's own validateNotaryRequest() exactly — SHA3-512,
+ * hex-encoded, SEAL_HASH_HEX_LEN (128) characters. Distinct from TSA's
+ * content hash (base64/SHA-256) — different hash, different encoding,
+ * different length; don't conflate the two.
+ */
+export declare function validateSealHash(sealHash: string): void;

package/dist/services/notary/validation.js

@@ -0,0 +1,19 @@
+import { SEAL_HASH_HEX_LEN } from "@majikah/majik-signature";
+import { ValidationError } from "../../errors/ValidationError";
+/**
+ * Mirrors the gateway's own validateNotaryRequest() exactly — SHA3-512,
+ * hex-encoded, SEAL_HASH_HEX_LEN (128) characters. Distinct from TSA's
+ * content hash (base64/SHA-256) — different hash, different encoding,
+ * different length; don't conflate the two.
+ */
+export function validateSealHash(sealHash) {
+    if (typeof sealHash !== "string") {
+        throw new ValidationError("sealHash must be a string", sealHash);
+    }
+    if (sealHash.length !== SEAL_HASH_HEX_LEN) {
+        throw new ValidationError(`sealHash must be exactly ${SEAL_HASH_HEX_LEN} hex characters (SHA3-512), got ${sealHash.length}`, sealHash);
+    }
+    if (!/^[0-9a-f]+$/i.test(sealHash)) {
+        throw new ValidationError("sealHash must be a hex string", sealHash);
+    }
+}

package/dist/services/shared/encoding.d.ts

@@ -0,0 +1,21 @@
+import { FileLike } from "@majikah/majik-signature";
+/**
+ * Converts a Base64-encoded string into raw bytes.
+ *
+ * Uses the runtime's `atob()` implementation and returns the decoded
+ * content as a `Uint8Array`.
+ *
+ * @param b64 Base64-encoded string.
+ * @returns Decoded bytes.
+ * @throws DOMException When the input is not valid Base64.
+ */
+export declare function base64ToBytes(b64: string): Uint8Array;
+/**
+ * Converts raw bytes into a Base64-encoded string.
+ *
+ * @param bytes Bytes to encode.
+ * @returns Base64 representation of the provided bytes.
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function bytesToBlob(bytes: Uint8Array, mimeType: string): Blob;
+export declare function normalizeToBlob(input: FileLike, mimeType?: string): Blob;

package/dist/services/shared/encoding.js

@@ -0,0 +1,43 @@
+/**
+ * Converts a Base64-encoded string into raw bytes.
+ *
+ * Uses the runtime's `atob()` implementation and returns the decoded
+ * content as a `Uint8Array`.
+ *
+ * @param b64 Base64-encoded string.
+ * @returns Decoded bytes.
+ * @throws DOMException When the input is not valid Base64.
+ */
+export function base64ToBytes(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Converts raw bytes into a Base64-encoded string.
+ *
+ * @param bytes Bytes to encode.
+ * @returns Base64 representation of the provided bytes.
+ */
+export function bytesToBase64(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export function bytesToBlob(bytes, mimeType) {
+    return new Blob([bytes], { type: mimeType });
+}
+export function normalizeToBlob(input, mimeType = "application/octet-stream") {
+    if (input instanceof Blob)
+        return input;
+    if (input instanceof Uint8Array)
+        return bytesToBlob(input, mimeType);
+    if (input instanceof ArrayBuffer)
+        return bytesToBlob(new Uint8Array(input), mimeType);
+    throw new Error("Unsupported file input — expected Blob, File, Uint8Array, or ArrayBuffer.");
+}

package/dist/services/shared/resolve-signature.d.ts

@@ -0,0 +1,23 @@
+import type { MajikSignature } from "@majikah/majik-signature";
+export interface ResolveSignatureOptions {
+    /**
+     * Appended to the "no signatures found" error — lets each caller point
+     * to its own "sign it first" guidance (TSA vs MUID have different next
+     * steps) without this shared helper needing to know about either.
+     */
+    noSignatureHint?: string;
+}
+/**
+ * Resolves a single target signature out of a file/envelope's signature
+ * list — the shared "which signer did you mean" logic used anywhere an
+ * SDK method needs to act on exactly one existing signature rather than
+ * create a new one (TSA timestamping an existing file, MUID verifying an
+ * existing file).
+ *
+ * - No signatures at all → throws with an actionable hint.
+ * - expectedSignerId provided → must match exactly, or throws.
+ * - No expectedSignerId, exactly one signer → returns it.
+ * - No expectedSignerId, multiple signers → throws asking for disambiguation,
+ *   rather than silently guessing "the first" or "the last" one.
+ */
+export declare function resolveTargetSignature(signatures: MajikSignature[], expectedSignerId?: string, options?: ResolveSignatureOptions): MajikSignature;

package/dist/services/shared/resolve-signature.js

@@ -0,0 +1,31 @@
+import { ValidationError } from "../../errors/ValidationError";
+/**
+ * Resolves a single target signature out of a file/envelope's signature
+ * list — the shared "which signer did you mean" logic used anywhere an
+ * SDK method needs to act on exactly one existing signature rather than
+ * create a new one (TSA timestamping an existing file, MUID verifying an
+ * existing file).
+ *
+ * - No signatures at all → throws with an actionable hint.
+ * - expectedSignerId provided → must match exactly, or throws.
+ * - No expectedSignerId, exactly one signer → returns it.
+ * - No expectedSignerId, multiple signers → throws asking for disambiguation,
+ *   rather than silently guessing "the first" or "the last" one.
+ */
+export function resolveTargetSignature(signatures, expectedSignerId, options) {
+    if (signatures.length === 0) {
+        const hint = options?.noSignatureHint ? ` ${options.noSignatureHint}` : "";
+        throw new ValidationError(`No signatures found.${hint}`, signatures);
+    }
+    if (expectedSignerId) {
+        const match = signatures.find((s) => s.signerId === expectedSignerId);
+        if (!match) {
+            throw new ValidationError(`No signature found for signerId "${expectedSignerId}".`, expectedSignerId);
+        }
+        return match;
+    }
+    if (signatures.length > 1) {
+        throw new ValidationError(`This file/envelope has ${signatures.length} signers — pass expectedSignerId to disambiguate which one to use.`, signatures.map((s) => s.signerId));
+    }
+    return signatures[0];
+}

package/dist/services/shared/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<void>;

package/dist/services/shared/sleep.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/services/shared/validation.d.ts

@@ -0,0 +1,9 @@
+export declare function isSHA256Hex(value: unknown): value is string;
+/**
+ * Validates that a string contains a non-empty, non-whitespace value.
+ *
+ * @param value Value to validate.
+ * @param field Field name used in the validation error message.
+ * @throws ValidationError When the value is empty or not a string.
+ */
+export declare function assertNonEmpty(value: string, field: string): void;

package/dist/services/shared/validation.js

@@ -0,0 +1,16 @@
+import { ValidationError } from "../../errors";
+export function isSHA256Hex(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/i.test(value);
+}
+/**
+ * Validates that a string contains a non-empty, non-whitespace value.
+ *
+ * @param value Value to validate.
+ * @param field Field name used in the validation error message.
+ * @throws ValidationError When the value is empty or not a string.
+ */
+export function assertNonEmpty(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new ValidationError(`${field} must be a non-empty string`, value);
+    }
+}

package/dist/services/slink/SLinkClient.d.ts

@@ -0,0 +1,174 @@
+import type { MajikKey } from "@majikah/majik-key";
+import { MajikSLink, type MajikSLinkJSON } from "@majikah/majik-slink";
+import type { HttpClient } from "../../transport/HttpClient";
+import type { PageResult, PaginationParams } from "../../types/common";
+import type { PublicKeyResolver, RegisterUrlOptions, SLinkPublicView, SLinkSearchResult, VerifiedSLinkMatch } from "../../types/slink";
+/**
+ * Client for creating, registering, searching, and verifying Majik SLinks.
+ *
+ * SLink verification has two distinct stages:
+ * - API lookup confirms that a claim exists.
+ * - Local cryptographic verification confirms that the claim's signature
+ *   is valid using trusted public keys.
+ */
+export declare class SLinkClient {
+    private readonly http;
+    /**
+     * Creates an SLink client using the provided HTTP transport.
+     *
+     * @param http HTTP client used to communicate with the Majikah API.
+     */
+    constructor(http: HttpClient);
+    /**
+     * Registers an SLink that has already been created and signed.
+     *
+     * Accepts either a `MajikSLink` instance or its serialized JSON form.
+     *
+     * @param slink SLink instance or serialized SLink data.
+     * @returns The registered SLink.
+     * @throws ValidationError When no SLink is provided.
+     */
+    create(slink: MajikSLink | MajikSLinkJSON): Promise<MajikSLinkJSON>;
+    /**
+     * Creates, signs, and registers an SLink for a URL in one operation.
+     *
+     * This is the convenience method for callers that do not already have a
+     * `MajikSLink` instance. It requires an unlocked `MajikKey` to sign the
+     * claim.
+     *
+     * @param rawUrl URL or domain to associate with the SLink.
+     * @param key Unlocked MajikKey used to sign the SLink.
+     * @param userId User identifier recorded as the signer.
+     * @param muid MUID associated with the claim.
+     * @param options Optional SLink metadata.
+     * @returns The registered SLink.
+     *
+     * @example
+     * ```ts
+     * const stored = await majikah.slink.registerUrl(
+     *   "https://youtube.com/watch?v=dQw4w9WgXcQ",
+     *   aliceKey,
+     *   userId,
+     *   muid,
+     * );
+     * ```
+     */
+    registerUrl(rawUrl: string, key: MajikKey, userId: string, muid: string, options?: RegisterUrlOptions): Promise<MajikSLinkJSON>;
+    /**
+     * Lists SLinks owned by the current API credentials.
+     *
+     * Results use cursor-based pagination. Pass the returned `next_cursor`
+     * directly into the next request's `cursor` parameter.
+     *
+     * @param params Optional pagination settings.
+     * @returns A page of SLinks and pagination metadata.
+     */
+    me(params?: PaginationParams): Promise<PageResult<MajikSLinkJSON>>;
+    /**
+     * Searches for SLink claims associated with a content hash.
+     *
+     * This confirms which SLink claims exist for the supplied hash but does not
+     * perform cryptographic signature verification.
+     *
+     * @param hash Content hash associated with the SLink claims.
+     * @returns Matching SLinks and their public MUID information.
+     * @throws ValidationError When the hash is empty.
+     */
+    verifyByHash(hash: string): Promise<SLinkSearchResult>;
+    /**
+     * Searches for SLink claims associated with a URL.
+     *
+     * Bare domains are automatically normalized to use `https://`.
+     * This method confirms that matching claims exist but does not verify their
+     * signatures cryptographically.
+     *
+     * @param url URL or domain associated with the SLink claim.
+     * @returns Matching SLinks and their public MUID information.
+     *
+     * @example
+     * ```ts
+     * const results = await majikah.slink.verifyUrl("thezelijah.world");
+     * ```
+     */
+    verifyUrl(url: string): Promise<SLinkSearchResult>;
+    /**
+     * Finds SLink claims for a URL and cryptographically verifies every
+     * matching signature locally.
+     *
+     * The API lookup only establishes that a claim exists for the URL. It does
+     * not prove that a signature is valid because SLink public keys are not
+     * stored server-side. This method resolves the required public keys through
+     * `resolvePublicKeys` and verifies each signature locally.
+     *
+     * For the common MUID-backed flow, use `createMuidPublicKeyResolver()`.
+     * It resolves each signer's public keys through `MUIDClient.lookup()` and
+     * converts the API's Base64-encoded keys into the format required for
+     * cryptographic verification.
+     *
+     * @param url URL or domain associated with the SLink claims.
+     * @param resolvePublicKeys Callback that resolves trusted public keys for
+     * each SLink signer.
+     * @returns Each matching SLink paired with its local verification result.
+     *
+     * @example
+     * ```ts
+     * import { createMuidPublicKeyResolver } from "@majikah/sdk";
+     *
+     * const results = await majikah.slink.verifyUrlWithProof(
+     *   "thezelijah.world",
+     *   createMuidPublicKeyResolver(majikah.muid),
+     * );
+     *
+     * const verified = results.filter(({ result }) => result.valid);
+     * ```
+     *
+     * A custom resolver can be used when public keys come from another trusted
+     * registry or key source:
+     *
+     * @example
+     * ```ts
+     * const results = await majikah.slink.verifyUrlWithProof(
+     *   "thezelijah.world",
+     *   async (muid, signerId) => {
+     *     const keys = await myKeyRegistry.get(muid);
+     *
+     *     return {
+     *       signerId,
+     *       edPublicKey: keys.edPublicKey,
+     *       mlDsaPublicKey: keys.mlDsaPublicKey,
+     *     };
+     *   },
+     * );
+     * ```
+     */
+    verifyUrlWithProof(url: string, resolvePublicKeys: PublicKeyResolver): Promise<VerifiedSLinkMatch[]>;
+    /**
+     * Cryptographically verifies already-fetched SLink search results locally.
+     *
+     * Use this when the matches were obtained separately through `verifyUrl()`
+     * or `verifyByHash()` and you want to verify them without another API lookup.
+     *
+     * @param matches SLink matches to verify.
+     * @param resolvePublicKeys Callback used to obtain trusted public signing keys.
+     * @returns Each match paired with its local cryptographic verification result.
+     */
+    verifyMatches(matches: SLinkPublicView[], resolvePublicKeys: PublicKeyResolver): Promise<VerifiedSLinkMatch[]>;
+    /**
+     * Retrieves an SLink by its identifier.
+     *
+     * @param id SLink identifier.
+     * @returns The SLink together with its owner's public MUID information.
+     * @throws ValidationError When the identifier is empty.
+     */
+    lookup(id: string): Promise<SLinkPublicView>;
+    /**
+     * Deletes an SLink by its identifier.
+     *
+     * @param id SLink identifier.
+     * @returns The identifier of the deleted SLink.
+     * @throws ValidationError When the identifier is empty.
+     */
+    delete(id: string): Promise<{
+        id: string;
+    }>;
+}