@attlaz/client 1.77.1

package/dist/Http/Transport/OAuthClient.js

@@ -0,0 +1,315 @@
+import { JsonSerializable } from '../../Model/JsonSerializable.js';
+import { VERSION } from '../../version.js';
+import { ClientError } from '../ClientError.js';
+import { HttpStatus } from '../HttpStatus.js';
+import { HttpClient } from '../HttpClient.js';
+import { HttpClientRequest } from '../HttpClientRequest.js';
+import { OAuthClientToken } from '../OAuthClientToken.js';
+export class OAuthClient {
+    options;
+    debug = false;
+    oauthClientToken = null;
+    refreshTokenPromise = null;
+    version = null;
+    parseErrorHandler = null;
+    constructor(options) {
+        this.options = options;
+        this.initDefaultHeaders();
+    }
+    async authenticate(username = null, password = null) {
+        // TODO: should we encrypt the password in the client (or is https save enough)?
+        try {
+            if (username !== null && username !== undefined && password !== null && password !== undefined) {
+                // Password flow / Owner Credentials grant
+                const params = {
+                    grant_type: 'password',
+                    client_id: this.options.clientId,
+                    username,
+                    password,
+                    scope: this.options.scopes.join(' '),
+                };
+                if (!this.isPublicClient()) {
+                    params.client_secret = this.options.clientSecret;
+                }
+                const rawAuthToken = await this.requestToken(params);
+                this.oauthClientToken = this.tokenToOauthClientToken(rawAuthToken);
+                return true;
+            }
+            if (this.options.clientId !== null && this.options.clientSecret !== null) {
+                // Client credentials flow (only for confidential clients)
+                const rawAuthToken = await this.requestToken({
+                    grant_type: 'client_credentials',
+                    client_id: this.options.clientId,
+                    client_secret: this.options.clientSecret,
+                    scope: this.options.scopes.join(' '),
+                });
+                this.oauthClientToken = this.tokenToOauthClientToken(rawAuthToken);
+            }
+            return true;
+        }
+        catch (requestError) {
+            if (this.debug) {
+                console.debug('[Client] Error during authentication', requestError);
+            }
+            throw ClientError.fromError(requestError);
+        }
+    }
+    async refreshToken() {
+        if (this.debug) {
+            console.debug('[OAuthClient] refresh token');
+        }
+        if (this.oauthClientToken === null) {
+            throw new Error('unable to refresh token, auth token not set');
+        }
+        if (this.oauthClientToken.refresh_token === undefined || this.oauthClientToken.refresh_token === null || this.oauthClientToken.refresh_token === '') {
+            throw new Error('unable to refresh token, refresh token not set');
+        }
+        try {
+            const params = {
+                grant_type: 'refresh_token',
+                client_id: this.options.clientId,
+                refresh_token: this.oauthClientToken.refresh_token,
+                scope: this.options.scopes.join(' '),
+            };
+            if (!this.isPublicClient()) {
+                params.client_secret = this.options.clientSecret;
+            }
+            const rawAuthToken = await this.requestToken(params);
+            this.oauthClientToken = this.tokenToOauthClientToken(rawAuthToken);
+        }
+        catch (e) {
+            if (e instanceof ClientError) {
+                // A refresh grant rejected by the server (4xx — the refresh token is
+                // expired/revoked/invalid_grant) means the session is irrecoverable and
+                // the user must re-authenticate. Surface it as 401 Unauthorized so
+                // consumers sign out and redirect to login instead of showing a generic
+                // error. Transient failures (network / 5xx) are rethrown unchanged so a
+                // hiccup doesn't force a logout.
+                if (e.httpStatus !== null && e.httpStatus >= 400 && e.httpStatus < 500) {
+                    throw new ClientError('Refresh token rejected, re-authentication required', HttpStatus.HTTP_UNAUTHORIZED);
+                }
+                throw e;
+            }
+            throw ClientError.fromError(e);
+        }
+    }
+    isPublicClient() {
+        return this.options.clientSecret === null || this.options.clientSecret === '';
+    }
+    /**
+     * Performs an OAuth token request (password, client_credentials or refresh_token grant) and
+     * returns the raw token response. On a non-ok response it throws a ClientError carrying the
+     * server's HTTP status and, when the body is JSON, its structured error message.
+     */
+    async requestToken(params) {
+        const response = await fetch(this.getApiEndpointUrl(this.options.accessTokenUri), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams(params).toString(),
+        });
+        if (!response.ok) {
+            const clientError = new ClientError(response.statusText || 'Token request failed', response.status);
+            // The token endpoint bypasses HttpClient (and authenticate() bypasses Endpoint.toApiError),
+            // so without this the server's body is discarded and callers only see the generic HTTP
+            // statusText. Attach the body and surface its structured OAuth error message directly so a
+            // failed login shows e.g. an invalid-credentials reason. Mirrors HttpClient.request() +
+            // Endpoint.toApiError(). The refresh path replaces this message with a 401, so it's unaffected.
+            try {
+                const data = await response.json();
+                clientError.response = {
+                    status: response.status,
+                    statusText: response.statusText,
+                    data,
+                };
+                const apiMessage = data?.error?.message;
+                if (apiMessage !== undefined && apiMessage !== null && apiMessage !== '') {
+                    clientError.message = apiMessage;
+                }
+            }
+            catch {
+                // Response body is not JSON — leave response/message as-is
+            }
+            throw clientError;
+        }
+        return response.json();
+    }
+    isTokenExpired() {
+        if (this.oauthClientToken === null) {
+            throw new Error('No token defined');
+        }
+        return OAuthClientToken.isExpired(this.oauthClientToken);
+    }
+    async request(action, parameters = null, method = 'GET', signWithOauthToken = true) {
+        if (signWithOauthToken) {
+            // A single null check both guards and narrows the token type. No access token at
+            // all is an auth failure (401), so consumers route it to the same sign-out path as
+            // a rejected refresh.
+            if (this.oauthClientToken === null) {
+                throw new ClientError('Unable to perform request, access token not provided', HttpStatus.HTTP_UNAUTHORIZED);
+            }
+            if (OAuthClientToken.isExpired(this.oauthClientToken)) {
+                if (this.refreshTokenPromise === null) {
+                    this.refreshTokenPromise = this.refreshToken();
+                    try {
+                        await this.refreshTokenPromise;
+                    }
+                    finally {
+                        // Always clear, even on failure, so a single failed refresh doesn't
+                        // poison every later request with the same rejected promise (e.g.
+                        // after the user re-authenticates).
+                        this.refreshTokenPromise = null;
+                    }
+                }
+                else {
+                    await this.refreshTokenPromise;
+                }
+            }
+        }
+        const requestData = this.createRequestData(action, parameters, method, signWithOauthToken);
+        if (this.debug) {
+            console.debug('[OAuthClient] Request: ' + requestData.method.toUpperCase() + ' ' + requestData.getFullUrl(), { headers: requestData.headers });
+        }
+        try {
+            const response = await HttpClient.request(requestData);
+            return response.body;
+        }
+        catch (error) {
+            if (!(error instanceof ClientError)) {
+                const clientError = ClientError.fromError(error);
+                if (this.debug) {
+                    console.error('[Client] Error:', { error, clientError });
+                }
+                throw clientError;
+            }
+            if (this.debug) {
+                console.error('[Client] Error:', { error });
+            }
+            throw error;
+        }
+    }
+    isAuthenticated() {
+        // TODO: other ways to determine if the client is authenticated?
+        return this.oauthClientToken !== null && this.oauthClientToken !== undefined;
+    }
+    getToken() {
+        return this.oauthClientToken;
+    }
+    setToken(token) {
+        this.oauthClientToken = token;
+    }
+    unsetToken() {
+        this.oauthClientToken = null;
+    }
+    enableDebug() {
+        this.debug = true;
+    }
+    disableDebug() {
+        this.debug = false;
+    }
+    isDebugEnabled() {
+        return this.debug;
+    }
+    setParseErrorHandler(handler) {
+        this.parseErrorHandler = handler;
+    }
+    reportParseError(message, context) {
+        if (this.parseErrorHandler !== null) {
+            this.parseErrorHandler(message, context);
+            return;
+        }
+        console.error(message, context);
+    }
+    defaultHeaders = {};
+    getDefaultHeaders() {
+        return this.defaultHeaders;
+    }
+    initDefaultHeaders() {
+        const userAgentInfo = {
+            version: VERSION,
+            language: 'Javascript',
+            language_version: '',
+            publisher: 'Attlaz',
+        };
+        const headers = { 'X-Attlaz-Client': JSON.stringify(userAgentInfo) };
+        if (this.isNodeEnvironment()) {
+            headers['User-Agent'] = 'Attlaz Http/' + VERSION;
+        }
+        this.defaultHeaders = headers;
+    }
+    addDefaultHeader(header, value) {
+        this.defaultHeaders[header] = value;
+    }
+    setVersion(version) {
+        this.version = version;
+    }
+    isNodeEnvironment() {
+        return typeof process !== 'undefined' && process.versions !== null && process.versions.node !== null;
+    }
+    tokenToOauthClientToken(oauthToken) {
+        let scopes = '';
+        if (Object.prototype.hasOwnProperty.call(oauthToken, 'scopes') && oauthToken.scopes !== undefined) {
+            scopes = oauthToken.scopes;
+        }
+        else if (Object.prototype.hasOwnProperty.call(oauthToken, 'scope') && oauthToken.scope !== undefined) {
+            scopes = oauthToken.scope;
+        }
+        const refreshToken = oauthToken.refresh_token === undefined || oauthToken.refresh_token === null ? null : oauthToken.refresh_token;
+        const token = new OAuthClientToken(oauthToken.access_token, oauthToken.token_type, refreshToken, scopes);
+        const t = new Date();
+        t.setSeconds(t.getSeconds() + oauthToken.expires_in);
+        token.expires = t;
+        return token;
+    }
+    getApiEndpointUrl(uri) {
+        if (uri.startsWith('http://') || uri.startsWith('https://')) {
+            return uri;
+        }
+        return this.options.apiEndpoint.replace(/\/+$/, '') + '/' + uri.replace(/^\/+/g, '');
+    }
+    createRequestData(action, parameters = null, method = 'GET', signWithOauthToken = true) {
+        const url = this.getApiEndpointUrl(action);
+        let requestData = new HttpClientRequest(url, method);
+        requestData.headers = this.getDefaultHeaders();
+        if (this.version !== null) {
+            requestData.setHeader('Attlaz-API-Version', this.version);
+        }
+        if ((method === 'POST' || method === 'DELETE' || method === 'PUT') && parameters !== null && parameters !== undefined) {
+            if (typeof parameters === 'object') {
+                requestData.body = JsonSerializable.stringify(parameters);
+            }
+            else if (typeof parameters === 'string') {
+                requestData.body = parameters;
+            }
+            else {
+                console.error('Unknown parameter type: ' + typeof parameters);
+            }
+            requestData.setJsonHeader();
+        }
+        if (method === 'GET' && parameters !== null && parameters !== undefined) {
+            const params = parameters;
+            Object.keys(params).forEach((key) => {
+                requestData.addQueryParam(key, params[key]);
+            });
+        }
+        if (signWithOauthToken) {
+            // request() already ensured a present, non-expired token; this guard only narrows
+            // the type before signing.
+            if (this.oauthClientToken === null) {
+                throw new ClientError('Unable to perform request, access token not provided', HttpStatus.HTTP_UNAUTHORIZED);
+            }
+            requestData = this.signRequest(requestData, this.oauthClientToken);
+        }
+        return requestData;
+    }
+    signRequest(requestObject, token) {
+        const tokenType = token.token_type;
+        const accessToken = token.access_token;
+        if (tokenType !== undefined && tokenType.toLowerCase() === 'bearer') {
+            requestObject.setHeader('Authorization', 'Bearer ' + accessToken);
+        }
+        else {
+            throw new ClientError('Unsupported token type "' + (tokenType ?? 'undefined') + '": only Bearer tokens are supported');
+        }
+        return requestObject;
+    }
+}

package/dist/Model/AccessToken/UserAccessToken.d.ts

@@ -0,0 +1,15 @@
+import { StateAware } from '../StateAware.js';
+import { State } from '../State.js';
+export declare class UserAccessToken implements StateAware {
+    id: string;
+    userId: string;
+    ipAllowList: string[];
+    name: string;
+    scopes: string[];
+    token: string;
+    createdAt: Date;
+    lastUsedAt: Date | null;
+    expiresAt: Date | null;
+    state: State;
+    static parse(rawUser: any): UserAccessToken;
+}

package/dist/Model/AccessToken/UserAccessToken.js

@@ -0,0 +1,28 @@
+import { State } from '../State.js';
+import { Utils } from '../../Utils.js';
+export class UserAccessToken {
+    id;
+    userId;
+    ipAllowList = [];
+    name;
+    scopes = [];
+    token;
+    createdAt;
+    lastUsedAt = null;
+    expiresAt = null;
+    state = State.Active;
+    static parse(rawUser) {
+        const userAccessToken = new UserAccessToken();
+        userAccessToken.id = rawUser.id;
+        userAccessToken.userId = rawUser.user;
+        userAccessToken.ipAllowList = rawUser.ip_allow_list;
+        userAccessToken.name = rawUser.name;
+        userAccessToken.scopes = rawUser.scopes;
+        userAccessToken.token = rawUser.token;
+        userAccessToken.createdAt = Utils.parseRawDate(rawUser.created_at);
+        userAccessToken.lastUsedAt = rawUser.last_used_at === null ? null : Utils.parseRawDate(rawUser.last_used_at);
+        userAccessToken.expiresAt = rawUser.expires_at === null ? null : Utils.parseRawDate(rawUser.expires_at);
+        userAccessToken.state = State.fromString(rawUser.state);
+        return userAccessToken;
+    }
+}

package/dist/Model/AccessToken/UserAccessTokenStatus.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Display/filter status of a user API key. Mirrors the server enum
+ * (Library/Core Attlaz-OAuth/Model/UserAccessTokenStatus). Folds the derived "expired" concept
+ * (computed from the expiry date, not stored) on top of the stored state.
+ */
+export declare enum UserAccessTokenStatus {
+    Active = "active",
+    Inactive = "inactive",
+    Expired = "expired",
+    Revoked = "revoked"
+}

package/dist/Model/AccessToken/UserAccessTokenStatus.js

@@ -0,0 +1,12 @@
+/**
+ * Display/filter status of a user API key. Mirrors the server enum
+ * (Library/Core Attlaz-OAuth/Model/UserAccessTokenStatus). Folds the derived "expired" concept
+ * (computed from the expiry date, not stored) on top of the stored state.
+ */
+export var UserAccessTokenStatus;
+(function (UserAccessTokenStatus) {
+    UserAccessTokenStatus["Active"] = "active";
+    UserAccessTokenStatus["Inactive"] = "inactive";
+    UserAccessTokenStatus["Expired"] = "expired";
+    UserAccessTokenStatus["Revoked"] = "revoked";
+})(UserAccessTokenStatus || (UserAccessTokenStatus = {}));

package/dist/Model/Adapter/Adapter.d.ts

@@ -0,0 +1,14 @@
+import { MetaDataWithIconAware } from '../../Core/MetaDataWithIconAware.js';
+import { ApiRecord } from '../ApiRecord.js';
+export declare class Adapter extends MetaDataWithIconAware {
+    id: string;
+    vendor: string;
+    logo: string | null;
+    type: string;
+    longDescription: string | null;
+    capabilities: string[];
+    categoryIds: string[];
+    docs: string | null;
+    website: string | null;
+    static parse(rawAdapter: ApiRecord): Adapter;
+}

package/dist/Model/Adapter/Adapter.js

@@ -0,0 +1,28 @@
+import { MetaDataWithIconAware } from '../../Core/MetaDataWithIconAware.js';
+export class Adapter extends MetaDataWithIconAware {
+    id;
+    vendor;
+    logo;
+    type;
+    longDescription;
+    capabilities;
+    categoryIds;
+    docs;
+    website;
+    static parse(rawAdapter) {
+        const adapter = MetaDataWithIconAware.parseMetaData(new Adapter(), rawAdapter);
+        // adapter.id = rawAdapter.id as string;
+        // adapter.name = rawAdapter.name as string;
+        // adapter.description = rawAdapter.description as string;
+        adapter.vendor = rawAdapter.vendor;
+        adapter.longDescription = rawAdapter.long_description;
+        adapter.capabilities = rawAdapter.capabilities;
+        // adapter.icon = rawAdapter.icon as string;
+        adapter.logo = MetaDataWithIconAware.parseIcon(rawAdapter.logo);
+        adapter.type = rawAdapter.type;
+        adapter.categoryIds = rawAdapter.categories;
+        adapter.docs = rawAdapter.docs;
+        adapter.website = rawAdapter.website;
+        return adapter;
+    }
+}

package/dist/Model/Adapter/AdapterCategory.d.ts

@@ -0,0 +1,6 @@
+export declare class AdapterCategory {
+    id: string;
+    slug: string;
+    name: string;
+    static parse(rawAdapterCategory: any): AdapterCategory;
+}

package/dist/Model/Adapter/AdapterCategory.js

@@ -0,0 +1,12 @@
+export class AdapterCategory {
+    id;
+    slug;
+    name;
+    static parse(rawAdapterCategory) {
+        const adapterCategory = new AdapterCategory();
+        adapterCategory.id = rawAdapterCategory.id;
+        adapterCategory.slug = rawAdapterCategory.slug;
+        adapterCategory.name = rawAdapterCategory.name;
+        return adapterCategory;
+    }
+}

package/dist/Model/Adapter/AdapterConfiguration.d.ts

@@ -0,0 +1,12 @@
+import { DataValueValue } from '../DataValue.js';
+export declare class AdapterConfiguration {
+    id: string;
+    key: string;
+    type: string;
+    adapter: string;
+    name: string;
+    description: string;
+    default: DataValueValue | null;
+    validation: string[];
+    static parse(rawAdapterConfiguration: any): AdapterConfiguration;
+}

package/dist/Model/Adapter/AdapterConfiguration.js

@@ -0,0 +1,22 @@
+export class AdapterConfiguration {
+    id;
+    key;
+    type;
+    adapter;
+    name;
+    description;
+    default;
+    validation;
+    static parse(rawAdapterConfiguration) {
+        const configuration = new AdapterConfiguration();
+        configuration.id = rawAdapterConfiguration.id;
+        configuration.key = rawAdapterConfiguration.key;
+        configuration.type = rawAdapterConfiguration.type;
+        configuration.adapter = rawAdapterConfiguration.adapter;
+        configuration.name = rawAdapterConfiguration.name;
+        configuration.description = rawAdapterConfiguration.description;
+        configuration.default = rawAdapterConfiguration.default;
+        configuration.validation = rawAdapterConfiguration.validation;
+        return configuration;
+    }
+}

package/dist/Model/Adapter/AdapterConnection.d.ts

@@ -0,0 +1,15 @@
+import { StateAware } from '../StateAware.js';
+import { State } from '../State.js';
+import { ApiRecord } from '../ApiRecord.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { AdapterConnectionStatus } from './AdapterConnectionStatus.js';
+export declare class AdapterConnection extends MetaDataAware implements StateAware {
+    id: string;
+    key: string;
+    adapter: string;
+    projectId: string;
+    status: AdapterConnectionStatus;
+    state: State;
+    lastUsedAt: Date | null;
+    static parse(rawAdapterConnection: ApiRecord): AdapterConnection;
+}

package/dist/Model/Adapter/AdapterConnection.js

@@ -0,0 +1,24 @@
+import { Utils } from '../../Utils.js';
+import { State } from '../State.js';
+import { MetaDataAware } from '../../Core/MetaDataAware.js';
+import { AdapterConnectionStatus } from './AdapterConnectionStatus.js';
+export class AdapterConnection extends MetaDataAware {
+    id;
+    key;
+    adapter;
+    projectId;
+    status;
+    state = State.Active;
+    lastUsedAt = null;
+    static parse(rawAdapterConnection) {
+        const adapterConnection = MetaDataAware.parseMetaData(new AdapterConnection(), rawAdapterConnection);
+        adapterConnection.id = rawAdapterConnection.id;
+        adapterConnection.key = rawAdapterConnection.key;
+        adapterConnection.adapter = rawAdapterConnection.adapter;
+        adapterConnection.projectId = rawAdapterConnection.project;
+        adapterConnection.state = State.fromString(rawAdapterConnection.state);
+        adapterConnection.status = AdapterConnectionStatus.fromString(rawAdapterConnection.status);
+        adapterConnection.lastUsedAt = (rawAdapterConnection.last_used_at === null || rawAdapterConnection.last_used_at === undefined) ? null : Utils.parseRawDate(rawAdapterConnection.last_used_at);
+        return adapterConnection;
+    }
+}

package/dist/Model/Adapter/AdapterConnectionConfigurationValue.d.ts

@@ -0,0 +1,7 @@
+import { DataValueValue } from '../DataValue.js';
+export declare class AdapterConnectionConfigurationValue {
+    id: string;
+    adapterConnectionId: string;
+    configurationId: string;
+    value: DataValueValue | null;
+}

package/dist/Model/Adapter/AdapterConnectionConfigurationValue.js

@@ -0,0 +1,6 @@
+export class AdapterConnectionConfigurationValue {
+    id;
+    adapterConnectionId;
+    configurationId;
+    value;
+}

package/dist/Model/Adapter/AdapterConnectionEvent.d.ts

@@ -0,0 +1,9 @@
+import { DataValueCollection } from '../DataValueCollection.js';
+export declare class AdapterConnectionEvent {
+    id: string;
+    adapterConnection: string;
+    type: string;
+    time: Date;
+    data: DataValueCollection;
+    static parse(rawAdapterConnection: any): AdapterConnectionEvent;
+}

package/dist/Model/Adapter/AdapterConnectionEvent.js

@@ -0,0 +1,18 @@
+import { DataValueCollection } from '../DataValueCollection.js';
+import { Utils } from '../../Utils.js';
+export class AdapterConnectionEvent {
+    id;
+    adapterConnection;
+    type;
+    time;
+    data;
+    static parse(rawAdapterConnection) {
+        const adapterConnectionEvent = new AdapterConnectionEvent();
+        adapterConnectionEvent.id = rawAdapterConnection.id;
+        adapterConnectionEvent.adapterConnection = rawAdapterConnection.adapter_connection;
+        adapterConnectionEvent.type = rawAdapterConnection.type;
+        adapterConnectionEvent.time = Utils.parseRawDate(rawAdapterConnection.time);
+        adapterConnectionEvent.data = DataValueCollection.fromObject(rawAdapterConnection.data);
+        return adapterConnectionEvent;
+    }
+}

package/dist/Model/Adapter/AdapterConnectionStatus.d.ts

@@ -0,0 +1,9 @@
+export declare enum AdapterConnectionStatus {
+    Unknown = "unknown",
+    Healthy = "healthy",
+    Warning = "warning",
+    Critical = "critical"
+}
+export declare namespace AdapterConnectionStatus {
+    const fromString: (input: string) => AdapterConnectionStatus;
+}

package/dist/Model/Adapter/AdapterConnectionStatus.js

@@ -0,0 +1,20 @@
+import { Utils } from '../../Utils.js';
+export var AdapterConnectionStatus;
+(function (AdapterConnectionStatus) {
+    AdapterConnectionStatus["Unknown"] = "unknown";
+    AdapterConnectionStatus["Healthy"] = "healthy";
+    AdapterConnectionStatus["Warning"] = "warning";
+    AdapterConnectionStatus["Critical"] = "critical";
+})(AdapterConnectionStatus || (AdapterConnectionStatus = {}));
+(function (AdapterConnectionStatus) {
+    AdapterConnectionStatus.fromString = (input) => {
+        if (input === null) {
+            return AdapterConnectionStatus.Unknown;
+        }
+        const result = Utils.parseEnum(input, AdapterConnectionStatus);
+        if (result === null) {
+            throw new Error('Unable to parse AdapterConnectionStatus from string: Unknown AdapterConnectionStatus "' + input + '"');
+        }
+        return result;
+    };
+})(AdapterConnectionStatus || (AdapterConnectionStatus = {}));

package/dist/Model/Adapter/TestConnectionResult.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Result of `AdapterConnectionEndpoint.testConnection()`.
+ *
+ * Mirrors the shape produced by Services-Api's `ConnectionTestController`. The
+ * server derives `state` mechanically (worst of all `checks` entries: skipped <
+ * passed < warning < failed) so consumers can treat it as authoritative for the
+ * overall connection status.
+ *
+ * Kept as a local copy of the server shape; if a third consumer ever needs the
+ * same type, lift it to Library/Core (see project plan).
+ */
+export type ConnectionTestState = 'passed' | 'warning' | 'failed' | 'skipped';
+export interface TestConnectionCheck {
+    /** User-visible label, e.g. "Reach Hue bridge" or "Configuration valid". */
+    name: string;
+    state: ConnectionTestState;
+    /** Wall-clock duration of this check in ms. `0` for checks that never ran. */
+    durationMs: number;
+    /** Free-form additional info, e.g. "HTTP 200" or "Missing scope: playlist-read". */
+    detail?: string;
+}
+export interface TestConnectionResult {
+    state: ConnectionTestState;
+    checks: TestConnectionCheck[];
+    /** Top-level message when nothing meaningful ran (e.g. adapter unknown). */
+    error?: string;
+}
+/**
+ * Parser for the JSON payload returned by `POST /services/:id/test-connection`.
+ * The server emits the shape directly (no envelope), so the parser is mostly
+ * identity with a defensive default for missing fields.
+ */
+export declare function parseTestConnectionResult(raw: any): TestConnectionResult;

package/dist/Model/Adapter/TestConnectionResult.js

@@ -0,0 +1,19 @@
+/**
+ * Parser for the JSON payload returned by `POST /services/:id/test-connection`.
+ * The server emits the shape directly (no envelope), so the parser is mostly
+ * identity with a defensive default for missing fields.
+ */
+export function parseTestConnectionResult(raw) {
+    return {
+        state: (raw.state ?? 'skipped'),
+        checks: Array.isArray(raw.checks)
+            ? raw.checks.map((c) => ({
+                name: String(c.name ?? ''),
+                state: (c.state ?? 'skipped'),
+                durationMs: Number(c.duration_ms ?? c.durationMs ?? 0),
+                ...(c.detail !== undefined && c.detail !== null ? { detail: String(c.detail) } : {}),
+            }))
+            : [],
+        ...(raw.error !== undefined && raw.error !== null ? { error: String(raw.error) } : {}),
+    };
+}

package/dist/Model/ApiRecord.d.ts

@@ -0,0 +1 @@
+export type ApiRecord = Record<string, string | number | boolean | Date | null>;