@majikah/sdk 0.1.0

package/dist/services/slink/SLinkClient.js

@@ -0,0 +1,231 @@
+import { MajikSLink } from "@majikah/majik-slink";
+import { ValidationError } from "../../errors/ValidationError";
+import { normalizeUrl } from "./validation";
+import { assertNonEmpty } from "../shared/validation";
+/**
+ * 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 class SLinkClient {
+    http;
+    /**
+     * Creates an SLink client using the provided HTTP transport.
+     *
+     * @param http HTTP client used to communicate with the Majikah API.
+     */
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * 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.
+     */
+    async create(slink) {
+        if (!slink) {
+            throw new ValidationError("slink is required", slink);
+        }
+        const json = slink instanceof MajikSLink ? slink.toJSON() : slink;
+        return this.http.request("slink", "", {
+            method: "POST",
+            body: json,
+        });
+    }
+    /**
+     * 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,
+     * );
+     * ```
+     */
+    async registerUrl(rawUrl, key, userId, muid, options) {
+        const slink = await MajikSLink.create(rawUrl, key, userId, muid, options);
+        return this.create(slink);
+    }
+    /**
+     * 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.
+     */
+    async me(params) {
+        return this.http.request("slink", "/me", {
+            method: "GET",
+            query: {
+                cursor: params?.cursor,
+                limit: params?.limit !== undefined ? String(params.limit) : undefined,
+            },
+        });
+    }
+    /**
+     * 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.
+     */
+    async verifyByHash(hash) {
+        assertNonEmpty(hash, "hash");
+        return this.http.request("slink", "/verify", {
+            method: "GET",
+            query: { hash },
+        });
+    }
+    /**
+     * 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");
+     * ```
+     */
+    async verifyUrl(url) {
+        const normalized = normalizeUrl(url);
+        return this.http.request("slink", "/verify", {
+            method: "GET",
+            query: { url: normalized },
+        });
+    }
+    /**
+     * 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,
+     *     };
+     *   },
+     * );
+     * ```
+     */
+    async verifyUrlWithProof(url, resolvePublicKeys) {
+        const { matches } = await this.verifyUrl(url);
+        return this.verifyMatches(matches, resolvePublicKeys);
+    }
+    /**
+     * 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.
+     */
+    async verifyMatches(matches, resolvePublicKeys) {
+        const results = [];
+        for (const match of matches) {
+            const publicKeys = await resolvePublicKeys(match.slink.muid, match.slink.signature.signerId);
+            const result = MajikSLink.verifySignature(match.slink, publicKeys);
+            results.push({
+                match,
+                result,
+            });
+        }
+        return results;
+    }
+    /**
+     * 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.
+     */
+    async lookup(id) {
+        assertNonEmpty(id, "id");
+        return this.http.request("slink", `/${encodeURIComponent(id)}`, {
+            method: "GET",
+        });
+    }
+    /**
+     * Deletes an SLink by its identifier.
+     *
+     * @param id SLink identifier.
+     * @returns The identifier of the deleted SLink.
+     * @throws ValidationError When the identifier is empty.
+     */
+    async delete(id) {
+        assertNonEmpty(id, "id");
+        return this.http.request("slink", `/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        });
+    }
+}
+Object.freeze(SLinkClient);
+Object.freeze(SLinkClient.prototype);

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

@@ -0,0 +1,24 @@
+/**
+ * Normalizes a URL by adding `https://` when no HTTP(S) scheme is present.
+ *
+ * The returned value is intentionally not percent-encoded. Query parameter
+ * encoding is handled by the HTTP client when the request URL is built,
+ * preventing double encoding.
+ *
+ * @param input URL or domain to normalize.
+ * @returns A normalized HTTP(S) URL.
+ * @throws ValidationError When the input is empty or not a string.
+ *
+ * @example
+ * ```ts
+ * normalizeUrl("thezelijah.world");
+ * // "https://thezelijah.world"
+ *
+ * normalizeUrl("http://thezelijah.world");
+ * // "http://thezelijah.world"
+ *
+ * normalizeUrl("https://thezelijah.world");
+ * // "https://thezelijah.world"
+ * ```
+ */
+export declare function normalizeUrl(input: string): string;

package/dist/services/slink/validation.js

@@ -0,0 +1,31 @@
+import { ValidationError } from "../../errors/ValidationError";
+/**
+ * Normalizes a URL by adding `https://` when no HTTP(S) scheme is present.
+ *
+ * The returned value is intentionally not percent-encoded. Query parameter
+ * encoding is handled by the HTTP client when the request URL is built,
+ * preventing double encoding.
+ *
+ * @param input URL or domain to normalize.
+ * @returns A normalized HTTP(S) URL.
+ * @throws ValidationError When the input is empty or not a string.
+ *
+ * @example
+ * ```ts
+ * normalizeUrl("thezelijah.world");
+ * // "https://thezelijah.world"
+ *
+ * normalizeUrl("http://thezelijah.world");
+ * // "http://thezelijah.world"
+ *
+ * normalizeUrl("https://thezelijah.world");
+ * // "https://thezelijah.world"
+ * ```
+ */
+export function normalizeUrl(input) {
+    if (typeof input !== "string" || input.trim().length === 0) {
+        throw new ValidationError("url must be a non-empty string", input);
+    }
+    const trimmed = input.trim();
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}

package/dist/services/tsa/TSAClient.d.ts

@@ -0,0 +1,101 @@
+import type { MajikKey } from "@majikah/majik-key";
+import { MajikSignature, type EnvelopeInput, type FileLike, type MajikSignatureJSON } from "@majikah/majik-signature";
+import type { HttpClient } from "../../transport/HttpClient";
+import type { MajikTimestamp, MajikTSARequest, TSAQuota, StampDetachedResult, StampFileDetachedOptions, StampFileOptions, StampResult, TimestampExistingDetachedResult, TimestampExistingOptions, TimestampExistingResult } from "../../types/tsa";
+/**
+ * Client for interacting with the Majikah Time Stamping Authority.
+ *
+ * Provides low-level TSA requests as well as higher-level helpers for:
+ * - requesting timestamps for existing signatures
+ * - timestamping already-signed files and envelopes
+ * - signing and timestamping files in one operation
+ */
+export declare class TSAClient {
+    private readonly http;
+    /**
+     * Creates a TSA client using the provided HTTP transport.
+     *
+     * @param http HTTP client used to communicate with the Majikah API.
+     */
+    constructor(http: HttpClient);
+    /**
+     * Issues a trusted timestamp request for a TSA payload.
+     *
+     * @param request TSA request containing the signature hash and related data.
+     * @returns The trusted timestamp returned by the TSA.
+     */
+    issue(request: MajikTSARequest): Promise<MajikTimestamp>;
+    /**
+     * Returns the current TSA credit quota for the authenticated caller.
+     *
+     * @returns The number of available TSA credits and related quota data.
+     */
+    quota(): Promise<TSAQuota>;
+    /**
+     * Requests a trusted timestamp using an existing signature.
+     *
+     * @param signature Signature instance or serialized signature JSON.
+     * @returns The trusted timestamp issued for the signature.
+     */
+    issueForSignature(signature: MajikSignature | MajikSignatureJSON): Promise<MajikTimestamp>;
+    /**
+     * Attaches a trusted timestamp to an already-signed embedded file.
+     *
+     * The file must already contain at least one signature. No signing key is
+     * required because this method only timestamps an existing signature.
+     *
+     * @param file Signed file containing one or more signatures.
+     * @param options Optional signer and file-processing settings.
+     * @returns The file and signature after the TSA has been attached.
+     */
+    timestampFile(file: FileLike, options?: TimestampExistingOptions): Promise<TimestampExistingResult>;
+    /**
+     * Attaches a trusted timestamp to a signature in a detached envelope.
+     *
+     * The envelope must already contain at least one signature. When multiple
+     * signatures are present, `expectedSignerId` identifies which signature
+     * receives the TSA.
+     *
+     * @param envelope Existing detached signature envelope.
+     * @param options Optional signer selection and file-processing settings.
+     * @returns The updated envelope, signature, and `.mjksig` representation.
+     */
+    timestampDetached(envelope: EnvelopeInput, options?: TimestampExistingOptions): Promise<TimestampExistingDetachedResult>;
+    /**
+     * Signs a file and attaches a trusted timestamp in one operation.
+     *
+     * This creates a new signature using the provided MajikKey, requests a TSA
+     * timestamp for that signature, and embeds the timestamped signature into
+     * the resulting file.
+     *
+     * @param file File to sign and timestamp.
+     * @param key Unlocked MajikKey used to create the signature.
+     * @param options Optional signing and file-processing settings.
+     * @returns The timestamped file and its signature metadata.
+     */
+    stampFile(file: FileLike, key: MajikKey, options?: StampFileOptions): Promise<StampResult>;
+    /**
+     * Signs a file and returns its trusted timestamp as a detached envelope.
+     *
+     * Unlike {@link stampFile}, the timestamped signature is not embedded back
+     * into the file. The returned envelope can be distributed separately for
+     * out-of-band verification.
+     *
+     * @param file File to sign and timestamp.
+     * @param key Unlocked MajikKey used to create the signature.
+     * @param options Optional signing and envelope settings.
+     * @returns The signed file, updated envelope, signature, and `.mjksig` blob.
+     */
+    stampFileDetached(file: FileLike, key: MajikKey, options?: StampFileDetachedOptions): Promise<StampDetachedResult>;
+    /**
+     * Prevents a TSA request from being issued for a signature that is already
+     * timestamped.
+     *
+     * This check avoids consuming a TSA credit for an operation that would fail
+     * when the timestamp is attached.
+     *
+     * @param signature Signature that will receive the TSA.
+     * @throws ValidationError When the signature already contains a TSA.
+     */
+    private assertNoExistingTSA;
+}

package/dist/services/tsa/TSAClient.js

@@ -0,0 +1,178 @@
+import { MajikSignature, MajikSignatureEnvelope, } from "@majikah/majik-signature";
+import { ValidationError } from "../../errors/ValidationError";
+import { validateTSARequest } from "./validation";
+import { resolveTargetSignature } from "../shared/resolve-signature";
+/**
+ * Client for interacting with the Majikah Time Stamping Authority.
+ *
+ * Provides low-level TSA requests as well as higher-level helpers for:
+ * - requesting timestamps for existing signatures
+ * - timestamping already-signed files and envelopes
+ * - signing and timestamping files in one operation
+ */
+export class TSAClient {
+    http;
+    /**
+     * Creates a TSA client using the provided HTTP transport.
+     *
+     * @param http HTTP client used to communicate with the Majikah API.
+     */
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Issues a trusted timestamp request for a TSA payload.
+     *
+     * @param request TSA request containing the signature hash and related data.
+     * @returns The trusted timestamp returned by the TSA.
+     */
+    async issue(request) {
+        validateTSARequest(request);
+        return this.http.request("tsa", "/timestamp", {
+            method: "POST",
+            body: request,
+        });
+    }
+    /**
+     * Returns the current TSA credit quota for the authenticated caller.
+     *
+     * @returns The number of available TSA credits and related quota data.
+     */
+    async quota() {
+        const res = await this.http.request("tsa", "/quota", { method: "GET" });
+        return res.tsa_credits;
+    }
+    /**
+     * Requests a trusted timestamp using an existing signature.
+     *
+     * @param signature Signature instance or serialized signature JSON.
+     * @returns The trusted timestamp issued for the signature.
+     */
+    async issueForSignature(signature) {
+        const sig = signature instanceof MajikSignature
+            ? signature
+            : MajikSignature.fromJSON(signature);
+        return this.issue(sig.buildTSARequestPayload());
+    }
+    /**
+     * Attaches a trusted timestamp to an already-signed embedded file.
+     *
+     * The file must already contain at least one signature. No signing key is
+     * required because this method only timestamps an existing signature.
+     *
+     * @param file Signed file containing one or more signatures.
+     * @param options Optional signer and file-processing settings.
+     * @returns The file and signature after the TSA has been attached.
+     */
+    async timestampFile(file, options) {
+        const signatures = await MajikSignature.extractFrom(file, {
+            mimeType: options?.mimeType,
+        });
+        const target = resolveTargetSignature(signatures, options?.expectedSignerId, {
+            noSignatureHint: "Sign the file first, or use stampFile()/stampFileDetached() to sign and timestamp in one call.",
+        });
+        this.assertNoExistingTSA(target);
+        const timestamp = await this.issueForSignature(target);
+        target.addTSA(timestamp);
+        const blob = await target.embedIn(file, {
+            mimeType: options?.mimeType,
+        });
+        return { blob, signature: target };
+    }
+    /**
+     * Attaches a trusted timestamp to a signature in a detached envelope.
+     *
+     * The envelope must already contain at least one signature. When multiple
+     * signatures are present, `expectedSignerId` identifies which signature
+     * receives the TSA.
+     *
+     * @param envelope Existing detached signature envelope.
+     * @param options Optional signer selection and file-processing settings.
+     * @returns The updated envelope, signature, and `.mjksig` representation.
+     */
+    async timestampDetached(envelope, options) {
+        const env = await MajikSignatureEnvelope.from(envelope);
+        const signatures = env.signatures.map((s) => MajikSignature.fromJSON(s));
+        const target = resolveTargetSignature(signatures, options?.expectedSignerId, {
+            noSignatureHint: "Sign the file first, or use stampFile()/stampFileDetached() to sign and timestamp in one call.",
+        });
+        this.assertNoExistingTSA(target);
+        const timestamp = await this.issueForSignature(target);
+        target.addTSA(timestamp);
+        const nextEnvelope = env.withSignature(target.toJSON());
+        return {
+            envelope: nextEnvelope,
+            signature: target,
+            mjksig: nextEnvelope.toMJKSIG(),
+        };
+    }
+    /**
+     * Signs a file and attaches a trusted timestamp in one operation.
+     *
+     * This creates a new signature using the provided MajikKey, requests a TSA
+     * timestamp for that signature, and embeds the timestamped signature into
+     * the resulting file.
+     *
+     * @param file File to sign and timestamp.
+     * @param key Unlocked MajikKey used to create the signature.
+     * @param options Optional signing and file-processing settings.
+     * @returns The timestamped file and its signature metadata.
+     */
+    async stampFile(file, key, options) {
+        const { blob, signature, handler, mimeType } = await MajikSignature.signFile(file, key, options);
+        const timestamp = await this.issueForSignature(signature);
+        signature.addTSA(timestamp);
+        const finalBlob = await signature.embedIn(blob, { mimeType });
+        return {
+            blob: finalBlob,
+            signature,
+            handler,
+            mimeType,
+        };
+    }
+    /**
+     * Signs a file and returns its trusted timestamp as a detached envelope.
+     *
+     * Unlike {@link stampFile}, the timestamped signature is not embedded back
+     * into the file. The returned envelope can be distributed separately for
+     * out-of-band verification.
+     *
+     * @param file File to sign and timestamp.
+     * @param key Unlocked MajikKey used to create the signature.
+     * @param options Optional signing and envelope settings.
+     * @returns The signed file, updated envelope, signature, and `.mjksig` blob.
+     */
+    async stampFileDetached(file, key, options) {
+        const { blob, envelope, signature, handler, mimeType } = await MajikSignature.signFileDetached(file, key, options);
+        const timestamp = await this.issueForSignature(signature);
+        signature.addTSA(timestamp);
+        const nextEnvelope = envelope.withSignature(signature.toJSON());
+        return {
+            blob,
+            envelope: nextEnvelope,
+            signature,
+            mjksig: nextEnvelope.toMJKSIG(),
+            handler,
+            mimeType,
+        };
+    }
+    /**
+     * Prevents a TSA request from being issued for a signature that is already
+     * timestamped.
+     *
+     * This check avoids consuming a TSA credit for an operation that would fail
+     * when the timestamp is attached.
+     *
+     * @param signature Signature that will receive the TSA.
+     * @throws ValidationError When the signature already contains a TSA.
+     */
+    assertNoExistingTSA(signature) {
+        if (signature.hasTSA) {
+            throw new ValidationError(`Signature for signerId "${signature.signerId}" already has a TSA attached — a TSA cannot be replaced once set.`, signature.signerId);
+        }
+    }
+}
+// Freeze static methods
+Object.freeze(TSAClient);
+// Freeze instance methods
+Object.freeze(TSAClient.prototype);

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

@@ -0,0 +1,2 @@
+import type { MajikTSARequest } from "../../types/tsa";
+export declare function validateTSARequest(req: MajikTSARequest): void;

package/dist/services/tsa/validation.js

@@ -0,0 +1,12 @@
+// services/tsa/validation.ts
+import { ValidationError } from "../../errors/ValidationError";
+import { CONTENT_HASH_B64_LEN } from "@majikah/majik-signature";
+export function validateTSARequest(req) {
+    if (req?.digest?.algorithm !== "SHA-256") {
+        throw new ValidationError('digest.algorithm must be "SHA-256"', req);
+    }
+    if (typeof req.digest.value !== "string" ||
+        req.digest.value.length !== CONTENT_HASH_B64_LEN) {
+        throw new ValidationError("digest.value must be a valid SHA-256 hex digest", req);
+    }
+}

package/dist/transport/HttpClient.d.ts

@@ -0,0 +1,85 @@
+import { type MajikahClientOptions, type ServiceGroup } from "../types/common";
+/**
+ * Options for an individual HTTP request made through the API client.
+ */
+interface RequestOptions {
+    /** HTTP method used for the request. */
+    method: "GET" | "POST" | "DELETE";
+    /** Query parameters appended to the request URL. */
+    query?: Record<string, string | undefined>;
+    /** Request body that will be serialized as JSON. */
+    body?: unknown;
+    /**
+     * Marks a POST request as safe to retry.
+     *
+     * Use this only when the operation is idempotent and repeating it cannot
+     * create an unintended side effect.
+     */
+    idempotent?: boolean;
+}
+/**
+ * Internal HTTP transport used by the Majikah SDK service clients.
+ *
+ * Handles API URL resolution, authentication headers, request timeouts,
+ * response parsing, error mapping, and retry behavior for retry-safe requests.
+ */
+export declare class HttpClient {
+    private readonly routes;
+    private readonly apiKey;
+    private readonly timeoutMs;
+    private readonly retry;
+    private readonly fetchImpl;
+    private readonly extraHeaders;
+    /**
+     * Creates an HTTP client from the SDK configuration.
+     *
+     * @param options API client configuration including authentication,
+     * timeout, retry, and transport settings.
+     * @throws MajikahError When no API key is provided.
+     */
+    constructor(options: MajikahClientOptions);
+    /**
+     * Sends a request to a Majikah API service.
+     *
+     * GET requests are automatically retried according to the configured retry
+     * policy. POST requests are only retried when explicitly marked as
+     * idempotent.
+     *
+     * Successful API responses are unwrapped and return their `data` value
+     * directly. API errors are converted into SDK-specific error types.
+     *
+     * @typeParam T Expected type of the unwrapped response data.
+     * @param group Service group receiving the request.
+     * @param path API path relative to the service route.
+     * @param opts HTTP method, query parameters, body, and retry settings.
+     * @returns The response data returned by the API.
+     * @throws MajikahError When the request fails or times out.
+     * @throws RateLimitError When the API rejects the request due to rate limits.
+     */
+    request<T>(group: ServiceGroup, path: string, opts: RequestOptions): Promise<T>;
+    /**
+     * Builds a fully resolved API URL from a service route and query parameters.
+     *
+     * Undefined query values are omitted from the final URL.
+     *
+     * @param group Service group used to resolve the API route.
+     * @param path API path relative to the resolved service route.
+     * @param query Optional query parameters.
+     * @returns Fully resolved request URL.
+     */
+    private buildUrl;
+    /**
+     * Executes a single HTTP request without retrying.
+     *
+     * The response envelope is validated and unwrapped before returning the
+     * contained data. HTTP and API errors are converted through `mapError()`.
+     *
+     * @typeParam T Expected type of the unwrapped response data.
+     * @param url Fully resolved request URL.
+     * @param opts Request configuration.
+     * @returns The response data returned by the API.
+     * @throws MajikahError When the request times out or the API returns an error.
+     */
+    private attempt;
+}
+export {};