@calimero-network/mero-js 26.11.0 → 27.0.0

package/dist/admin-api/admin-types.js

@@ -1,12 +0,0 @@
-/**
- * Hex-encode a string's UTF-8 bytes, for {@link AccountSignWithRootRequest.payload}.
- *
- * Exists so each caller does not write the same loop. Every verifier this is
- * used with issues its challenge as text, and the node takes bytes — getting
- * that conversion subtly wrong (UTF-16 code units, a stray newline from a shell)
- * produces a signature over the wrong message, which fails at the verifier with
- * nothing local to point at.
- */
-export function hexEncodeUtf8(text) {
-    return Array.from(new TextEncoder().encode(text), (b) => b.toString(16).padStart(2, '0')).join('');
-}

package/dist/admin-api/index.d.ts

@@ -1,4 +0,0 @@
-export * from './admin-client.js';
-export * from './admin-types.js';
-export * from './admin-factory.js';
-export * from './redeem-invitation.js';

package/dist/admin-api/index.js

@@ -1,5 +0,0 @@
-// Admin API client
-export * from './admin-client.js';
-export * from './admin-types.js';
-export * from './admin-factory.js';
-export * from './redeem-invitation.js';

package/dist/admin-api/redeem-invitation.d.ts

@@ -1,101 +0,0 @@
-/** The two calls a redeem needs, so any client (or any app's join) can drive it. */
-export interface InviteRedeemer {
-    /**
-     * Send the join. Resolve on success, throw on failure.
-     *
-     * It does not have to be reliable, and it does not have to be idempotent on
-     * the client — the node's join is idempotent, and `memberships()` settles any
-     * ambiguity this throws.
-     */
-    join(namespaceId: string, invitation: unknown): Promise<void>;
-    /**
-     * Namespace ids this node is a member of.
-     *
-     * Throwing is a legitimate answer ("could not tell") and is treated as such:
-     * it never turns a join that succeeded into a failure.
-     */
-    memberships(): Promise<readonly string[]>;
-}
-/**
- * Why a join failed, as far as it tells a person what to do next.
- *
- * Read off the HTTP status where the node gives one (core rc.56+ answers a
- * refused join with a 4xx, not a 500), and off the message otherwise.
- */
-export type InviteFailureReason = 
-/** The invitation's time ran out. Only a new link helps. */
-'expired'
-/** The link is malformed or names nothing joinable. Only a new link helps. */
- | 'invalid'
-/**
- * This person already joined with this link once, and has since left. A link
- * admits each person once: only a new one helps.
- */
- | 'already-used'
-/** An admin removed this person. No link readmits them; an admin must re-add them. */
- | 'removed'
-/** The node refused this person for another reason (blocked, not allowed). */
- | 'refused'
-/** This client's session with the node lapsed; signing in finishes it. */
- | 'signed-out'
-/** No member was reachable to let them in yet. Trying later can work. */
- | 'no-one-online'
-/** This client could not reach its own node at all. */
- | 'node-unreachable'
-/** Nothing more specific is known; the node's message is all there is. */
- | 'unknown';
-/**
- * What happened, in the terms a UI needs.
- *
- * `already-member` is deliberately a success and deliberately distinct: it is
- * the outcome of following a link twice, or of the timeout above, and telling
- * someone "you are already in this one" is neither an error nor the same
- * message as having just joined.
- */
-export type RedeemOutcome = {
-    status: 'joined';
-    namespaceId: string;
-    teamName?: string;
-} | {
-    status: 'already-member';
-    namespaceId: string;
-    teamName?: string;
-} | {
-    status: 'failed';
-    namespaceId: string | null;
-    /** The node's own words, for logs and for a UI that shows detail. */
-    message: string;
-    /** Why, in terms a person can act on. */
-    reason: InviteFailureReason;
-    /**
-     * Whether trying again later could plausibly work. A malformed token
-     * cannot; an unreachable peer can. A caller holding the invitation uses
-     * this to decide whether to keep it — see {@link shouldRetain}.
-     */
-    retryable: boolean;
-};
-/** Whether an outcome means the invitation is finished with. */
-export declare function isSettled(outcome: RedeemOutcome): boolean;
-/**
- * Whether the invitation should be kept for another attempt later.
- *
- * The inverse of {@link isSettled}, named for the decision it drives.
- */
-export declare function shouldRetain(outcome: RedeemOutcome): boolean;
-/**
- * Join the namespace an invitation names, and report what happened.
- *
- * Sends the join once and never retries it: a failed request whose namespace
- * is then listed is `already-member`, not a failure. Never throws for an
- * ordinary failure — the outcome carries it, because every caller has to branch
- * on "already a member" anyway.
- *
- * Most callers want {@link AdminApiClient.redeemInvitation}, which supplies the
- * redeemer from the admin API. This form is for a join that is more than one
- * call — a namespace followed by the context inside it, say.
- */
-export declare function redeemInvitation(parsed: {
-    namespaceId: string;
-    invitation: unknown;
-    teamName?: string;
-}, redeemer: InviteRedeemer): Promise<RedeemOutcome>;

package/dist/admin-api/redeem-invitation.js

@@ -1,200 +0,0 @@
-// ── Redeeming an invitation: joining once, and knowing whether it worked ──────
-//
-// Deciding "did we join?" by whether the join request resolved is the wrong
-// question, and on a real node (core rc.41, 2026-09-22) it failed two ways:
-//
-//   1. The desktop proxy aborts every admin request at 30s. A namespace join
-//      whose members are all offline waits for one to appear — measured at 95s.
-//      So the request failed, the join landed anyway, and the app reported
-//      "could not join" for a namespace it was already in. It kept the
-//      invitation, and replayed it on every load.
-//
-//   2. A refresh after the join shared its `try`, so a refresh that threw
-//      turned a real join into a reported failure.
-//
-// So membership is the question, and there are two independent proofs of it:
-// the request resolving, and the namespace being listed. Either one is enough,
-// which matters because either one can be missing.
-import { classifyError, messageOf } from '../errors/classify.js';
-import { RelayLoginError } from '../account/relay-login-error.js';
-/** Whether an outcome means the invitation is finished with. */
-export function isSettled(outcome) {
-    return outcome.status !== 'failed' || !outcome.retryable;
-}
-/**
- * Whether the invitation should be kept for another attempt later.
- *
- * The inverse of {@link isSettled}, named for the decision it drives.
- */
-export function shouldRetain(outcome) {
-    return !isSettled(outcome);
-}
-/**
- * The refusal codes a join route answers with beside `error` (core's
- * `join_refusal_code`), and what each one tells a person.
- *
- * `join_refused_by_member` is absent on purpose: a member that refused may only
- * be behind, so it says nothing final on its own, and the member's own words
- * (in the message) are read by {@link reasonFromMessage} instead.
- */
-const REASON_FOR_CODE = {
-    invitation_expired: 'expired',
-    invitation_invalid: 'invalid',
-    invitation_already_used: 'already-used',
-    removed_from_group: 'removed',
-    reentry_blocked: 'refused',
-};
-/**
- * The machine-readable `code` a node put beside its `error`, if any: on
- * mero-js's `HTTPError` it is in the body text, on an axios-style error in
- * `response.data`.
- */
-function refusalCodeOf(err) {
-    if (!err || typeof err !== 'object')
-        return undefined;
-    const shaped = err;
-    if (typeof shaped.response?.data?.code === 'string')
-        return shaped.response.data.code;
-    if (typeof shaped.bodyText !== 'string')
-        return undefined;
-    try {
-        const body = JSON.parse(shaped.bodyText);
-        return typeof body?.code === 'string' ? body.code : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Which reason the message alone names, for a node that answers without a
- * useful status — older than rc.56, where every refusal was a bare 500 — or
- * without a `code`, or for a member's refusal quoted inside a retryable answer.
- *
- * Kept narrow on purpose. Anything not recognised here stays retryable, because
- * the cost of retrying a dead link is one more attempt, while the cost of
- * discarding a live one is someone who cannot join at all.
- */
-function reasonFromMessage(message) {
-    const m = message.toLowerCase();
-    if (m.includes('invitation has expired') ||
-        m.includes('invitation expired') ||
-        // Core rc.56+ names the group between the words: "invitation for group
-        // <id> expired at <secs>".
-        /\binvitation for group .+? expired at \d+/.test(m)) {
-        return 'expired';
-    }
-    if (m.includes('malformed') ||
-        m.includes('does not match namespace_id') ||
-        m.includes('invalid invitation') ||
-        /\binvitation for group .+? is invalid:/.test(m)) {
-        return 'invalid';
-    }
-    // Core's own words for a spent link and a removal (`MembershipError`), which a
-    // refusing member also quotes back to the joiner.
-    if (m.includes('has already used this invitation'))
-        return 'already-used';
-    if (/\bwas removed from group\b/.test(m))
-        return 'removed';
-    return null;
-}
-/**
- * The reasons that are final whatever status carried them: no later attempt
- * with this link can succeed for this person.
- */
-const FINAL_FROM_TEXT = new Set(['already-used', 'removed']);
-/**
- * Why a join failed, and whether a later attempt could work.
- *
- * The status decides where there is one. A 4xx the node chose is a definitive
- * answer about this invitation or this person, so it is not retried; a 5xx or
- * no answer at all is about the moment, so it is. Two exceptions keep an
- * invitation that is still good: a 401 is the client's session, not the
- * invitation, and a 404 is not specific enough to throw a link away on.
- */
-function classifyJoinFailure(err, message) {
-    // The join never left: the relay session it needed could not be minted. Says
-    // nothing about the invitation, which is kept for after a sign-in or a retry.
-    if (err instanceof RelayLoginError) {
-        return { reason: err.kind === 'signed-out' ? 'signed-out' : 'node-unreachable', retryable: true };
-    }
-    const { kind, status } = classifyError(err);
-    const fromText = reasonFromMessage(message);
-    // A code is the node naming the refusal itself: nothing below can know better.
-    const code = refusalCodeOf(err);
-    const fromCode = code ? REASON_FOR_CODE[code] : undefined;
-    if (fromCode)
-        return { reason: fromCode, retryable: false };
-    // A spent link or a removal is final even when a member said it inside a
-    // retryable answer (a 503 for a join every peer refused): asking again only
-    // asks the same members, who will say the same.
-    if (fromText && FINAL_FROM_TEXT.has(fromText))
-        return { reason: fromText, retryable: false };
-    // Any other member refusal is not "no one is online": someone answered, and
-    // their words are the message. Kept, since a member behind on the team's
-    // history refuses what it has not seen yet.
-    if (code === 'join_refused_by_member')
-        return { reason: 'unknown', retryable: true };
-    if (status === 401)
-        return { reason: 'signed-out', retryable: true };
-    if (status === 400)
-        return { reason: fromText ?? 'invalid', retryable: false };
-    if (status === 410)
-        return { reason: 'expired', retryable: false };
-    if (status === 403)
-        return { reason: 'refused', retryable: false };
-    // An expired invitation, a spent one, a member who was removed or blocked:
-    // every 409 a join can answer is final.
-    if (status === 409)
-        return { reason: fromText ?? 'refused', retryable: false };
-    if (kind === 'unavailable')
-        return { reason: 'no-one-online', retryable: true };
-    if (kind === 'unreachable')
-        return { reason: 'node-unreachable', retryable: true };
-    // A 500 from a node older than rc.56 may still be a refusal in disguise;
-    // anything else has only its message to go on.
-    if (fromText)
-        return { reason: fromText, retryable: false };
-    return { reason: 'unknown', retryable: true };
-}
-/**
- * Join the namespace an invitation names, and report what happened.
- *
- * Sends the join once and never retries it: a failed request whose namespace
- * is then listed is `already-member`, not a failure. Never throws for an
- * ordinary failure — the outcome carries it, because every caller has to branch
- * on "already a member" anyway.
- *
- * Most callers want {@link AdminApiClient.redeemInvitation}, which supplies the
- * redeemer from the admin API. This form is for a join that is more than one
- * call — a namespace followed by the context inside it, say.
- */
-export async function redeemInvitation(parsed, redeemer) {
-    const { namespaceId, invitation, teamName } = parsed;
-    let joinError = null;
-    try {
-        await redeemer.join(namespaceId, invitation);
-    }
-    catch (err) {
-        joinError = err;
-    }
-    // The request resolving is proof on its own, so this must not be able to
-    // demote a real join: a `memberships()` that throws is "could not tell".
-    let listed = null;
-    try {
-        listed = (await redeemer.memberships()).includes(namespaceId);
-    }
-    catch {
-        listed = null;
-    }
-    if (joinError === null) {
-        return { status: 'joined', namespaceId, teamName };
-    }
-    if (listed === true) {
-        // The join landed despite the error — an aborted request, or a link
-        // followed twice.
-        return { status: 'already-member', namespaceId, teamName };
-    }
-    const message = messageOf(joinError, 'Could not join. Check the invitation.');
-    const { reason, retryable } = classifyJoinFailure(joinError, message);
-    return { status: 'failed', namespaceId, message, reason, retryable };
-}

package/dist/auth/index.d.ts

@@ -1,34 +0,0 @@
-export interface AuthCallbackResult {
-    accessToken: string;
-    refreshToken: string;
-    applicationId: string;
-    contextId: string;
-    contextIdentity: string;
-    nodeUrl: string;
-}
-export interface AuthLoginOptions {
-    callbackUrl: string;
-    packageName?: string;
-    mode: string;
-    permissions?: string[];
-    registryUrl?: string;
-    packageVersion?: string;
-}
-export interface ParseAuthCallbackOptions {
-    /**
-     * Accept tokens this browser did not ask for, for a host that injects them itself
-     * (Calimero Desktop). Anyone who can open the page can then choose the session.
-     */
-    allowUnsolicited?: boolean;
-}
-/**
- * Parse an auth callback URL hash fragment.
- * Returns null if access_token is missing, or if the callback does not answer a
- * login begun here with {@link buildAuthLoginUrl} (single use, expires).
- */
-export declare function parseAuthCallback(url: string, options?: ParseAuthCallbackOptions): AuthCallbackResult | null;
-/**
- * Build the auth login URL for redirecting users to the node's auth page.
- * Remembers the login so {@link parseAuthCallback} can match the callback to it.
- */
-export declare function buildAuthLoginUrl(nodeUrl: string, opts: AuthLoginOptions): string;

package/dist/auth/index.js

@@ -1,67 +0,0 @@
-import { beginState, takeState } from '../cloud/link-state.js';
-const PENDING_KEY = 'calimero.auth.login.pending';
-const STATE_PARAM = 'auth_state';
-/**
- * Parse an auth callback URL hash fragment.
- * Returns null if access_token is missing, or if the callback does not answer a
- * login begun here with {@link buildAuthLoginUrl} (single use, expires).
- */
-export function parseAuthCallback(url, options = {}) {
-    try {
-        const hashIndex = url.indexOf('#');
-        if (hashIndex === -1)
-            return null;
-        const hash = url.substring(hashIndex + 1);
-        const params = new URLSearchParams(hash);
-        const accessToken = params.get('access_token');
-        if (!accessToken)
-            return null;
-        if (!options.allowUnsolicited && !takeState(PENDING_KEY, stateOf(url, hashIndex))) {
-            console.warn('[mero-js] ignoring auth callback tokens: they answer no login begun in this browser');
-            return null;
-        }
-        return {
-            accessToken,
-            refreshToken: params.get('refresh_token') ?? '',
-            applicationId: params.get('application_id') ?? '',
-            contextId: params.get('context_id') ?? '',
-            contextIdentity: params.get('context_identity') ?? '',
-            nodeUrl: params.get('node_url') ?? '',
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function stateOf(url, hashIndex) {
-    const queryIndex = url.indexOf('?');
-    if (queryIndex === -1 || queryIndex > hashIndex)
-        return null;
-    return new URLSearchParams(url.substring(queryIndex + 1, hashIndex)).get(STATE_PARAM);
-}
-/**
- * Build the auth login URL for redirecting users to the node's auth page.
- * Remembers the login so {@link parseAuthCallback} can match the callback to it.
- */
-export function buildAuthLoginUrl(nodeUrl, opts) {
-    const callback = new URL(opts.callbackUrl);
-    callback.searchParams.set(STATE_PARAM, beginState(PENDING_KEY, {}));
-    const params = new URLSearchParams();
-    params.set('callback-url', callback.toString());
-    if (opts.permissions && opts.permissions.length > 0) {
-        params.set('permissions', opts.permissions.join(','));
-    }
-    params.set('mode', opts.mode);
-    if (opts.packageName) {
-        params.set('package-name', opts.packageName);
-        if (opts.packageVersion) {
-            params.set('package-version', opts.packageVersion);
-        }
-        if (opts.registryUrl) {
-            params.set('registry-url', opts.registryUrl);
-        }
-    }
-    // Trim trailing slash from nodeUrl
-    const base = nodeUrl.replace(/\/+$/, '');
-    return `${base}/auth/login?${params.toString()}`;
-}

package/dist/auth-api/auth-client.d.ts

@@ -1,31 +0,0 @@
-import { HttpClient } from '../http-client/index.js';
-import { HealthResponse, IdentityResponse, ProvidersResponse, TokenRequest, TokenResponse, RefreshTokenRequest, MockTokenRequest, RevokeTokenRequest, RevokeTokenResponse, CreateKeyRequest, CreateKeyResponse, DeleteKeyResponse, RootKey, ClientKey, GenerateClientKeyRequest, DeleteClientResponse, PermissionResponse, UpdateKeyPermissionsRequest } from './auth-types.js';
-export declare class AuthApiClient {
-    private httpClient;
-    constructor(httpClient: HttpClient);
-    getHealth(): Promise<HealthResponse>;
-    getIdentity(): Promise<IdentityResponse>;
-    getProviders(): Promise<ProvidersResponse>;
-    getLoginPage(): Promise<string>;
-    generateTokens(request: TokenRequest): Promise<TokenResponse>;
-    refreshToken(request: RefreshTokenRequest): Promise<TokenResponse>;
-    generateMockTokens(request: MockTokenRequest): Promise<TokenResponse>;
-    validateToken(token: string): Promise<{
-        valid: boolean;
-        headers: Record<string, string>;
-        status: number;
-    }>;
-    validateTokenGet(token: string): Promise<{
-        status: number;
-        headers: Record<string, string>;
-    }>;
-    revokeTokens(request: RevokeTokenRequest): Promise<RevokeTokenResponse>;
-    listRootKeys(): Promise<RootKey[]>;
-    createRootKey(request: CreateKeyRequest): Promise<CreateKeyResponse>;
-    deleteRootKey(keyId: string): Promise<DeleteKeyResponse>;
-    listClientKeys(): Promise<ClientKey[]>;
-    generateClientKey(request: GenerateClientKeyRequest): Promise<TokenResponse>;
-    deleteClientKey(keyId: string, clientId: string): Promise<DeleteClientResponse>;
-    getKeyPermissions(keyId: string): Promise<PermissionResponse>;
-    updateKeyPermissions(keyId: string, changes: UpdateKeyPermissionsRequest): Promise<PermissionResponse>;
-}

package/dist/auth-api/auth-client.js

@@ -1,117 +0,0 @@
-import { pathSegment } from '../http-client/path-segment.js';
-export class AuthApiClient {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-    }
-    // Health and Status Endpoints
-    async getHealth() {
-        const response = await this.httpClient.get('/auth/health');
-        if (!response.data) {
-            throw new Error('Health response data is null');
-        }
-        return response.data;
-    }
-    async getIdentity() {
-        const response = await this.httpClient.get('/admin/identity');
-        if (!response.data) {
-            throw new Error('Identity response data is null');
-        }
-        return response.data;
-    }
-    async getProviders() {
-        const response = await this.httpClient.get('/auth/providers');
-        if (!response.data) {
-            throw new Error('Providers response data is null');
-        }
-        return response.data;
-    }
-    // Authentication Endpoints
-    async getLoginPage() {
-        return this.httpClient.get('/auth/login', { parse: 'text' });
-    }
-    async generateTokens(request) {
-        return this.httpClient.post('/auth/token', request);
-    }
-    async refreshToken(request) {
-        return this.httpClient.post('/auth/refresh', request);
-    }
-    async generateMockTokens(request) {
-        return this.httpClient.post('/auth/mock-token', request);
-    }
-    async validateToken(token) {
-        try {
-            const response = await this.validateTokenGet(token);
-            return {
-                valid: response.status === 200,
-                headers: response.headers,
-                status: response.status,
-            };
-        }
-        catch (error) {
-            return {
-                valid: false,
-                headers: {},
-                status: 401,
-            };
-        }
-    }
-    async validateTokenGet(token) {
-        const response = await this.httpClient.head('/auth/validate', {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        return {
-            status: response.status,
-            headers: response.headers,
-        };
-    }
-    // Token Management Endpoints
-    // NOTE: node auth status lives on AdminApiClient.isAuthed() (/admin-api/is-authed);
-    // there is no /auth/is-authed on the auth service.
-    async revokeTokens(request) {
-        const response = await this.httpClient.post('/admin/revoke', request);
-        if (!response.data) {
-            throw new Error('Revoke tokens response data is null');
-        }
-        return response.data;
-    }
-    // Key Management Endpoints
-    async listRootKeys() {
-        const response = await this.httpClient.get('/admin/keys');
-        if (!response.data) {
-            throw new Error('Root keys response data is null');
-        }
-        return response.data;
-    }
-    async createRootKey(request) {
-        const response = await this.httpClient.post('/admin/keys', request);
-        if (!response.data) {
-            throw new Error('Create root key response data is null');
-        }
-        return response.data;
-    }
-    async deleteRootKey(keyId) {
-        return this.httpClient.delete(`/admin/keys/${pathSegment(keyId)}`);
-    }
-    // Client Management Endpoints
-    async listClientKeys() {
-        const response = await this.httpClient.get('/admin/keys/clients');
-        if (!response.data) {
-            throw new Error('Client keys response data is null');
-        }
-        return response.data;
-    }
-    async generateClientKey(request) {
-        return this.httpClient.post('/admin/client-key', request);
-    }
-    async deleteClientKey(keyId, clientId) {
-        return this.httpClient.delete(`/admin/keys/${pathSegment(keyId)}/clients/${pathSegment(clientId)}`);
-    }
-    // Permission Management Endpoints
-    async getKeyPermissions(keyId) {
-        return this.httpClient.get(`/admin/keys/${pathSegment(keyId)}/permissions`);
-    }
-    async updateKeyPermissions(keyId, changes) {
-        // Core expects an { add, remove } delta, not a { permissions } replacement.
-        return this.httpClient.put(`/admin/keys/${pathSegment(keyId)}/permissions`, { add: changes.add, remove: changes.remove });
-    }
-}

package/dist/auth-api/auth-factory.d.ts

@@ -1,7 +0,0 @@
-import { AuthApiClient } from './auth-client.js';
-import { AuthApiClientConfig } from './auth-types.js';
-import { HttpClient } from '../http-client/index.js';
-export declare function createBrowserAuthApiClient(_config: AuthApiClientConfig): AuthApiClient;
-export declare function createNodeAuthApiClient(_config: AuthApiClientConfig): AuthApiClient;
-export declare function createAuthApiClient(_config: AuthApiClientConfig): AuthApiClient;
-export declare function createAuthApiClientFromHttpClient(httpClient: HttpClient, _config: AuthApiClientConfig): AuthApiClient;

package/dist/auth-api/auth-factory.js

@@ -1,41 +0,0 @@
-import { AuthApiClient } from './auth-client.js';
-// Mock HTTP client for testing
-class MockHttpClient {
-    async get() {
-        throw new Error('HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client');
-    }
-    async post() {
-        throw new Error('HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client');
-    }
-    async put() {
-        throw new Error('HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client');
-    }
-    async delete() {
-        throw new Error('HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client');
-    }
-    async patch() {
-        throw new Error('HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client');
-    }
-    async head() {
-        throw new Error('HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client');
-    }
-    async request() {
-        throw new Error('HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client');
-    }
-}
-// Factory functions for creating Auth API clients
-export function createBrowserAuthApiClient(_config) {
-    const httpClient = new MockHttpClient();
-    return new AuthApiClient(httpClient);
-}
-export function createNodeAuthApiClient(_config) {
-    const httpClient = new MockHttpClient();
-    return new AuthApiClient(httpClient);
-}
-export function createAuthApiClient(_config) {
-    const httpClient = new MockHttpClient();
-    return new AuthApiClient(httpClient);
-}
-export function createAuthApiClientFromHttpClient(httpClient, _config) {
-    return new AuthApiClient(httpClient);
-}