@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/trust/evaluators/trustChangeEvaluator.js

@@ -0,0 +1,201 @@
+import { logger } from "../../../logger.js";
+import { TrustEvidenceType } from "../types/trust.js";
+/** Track last evaluation time per entity to prevent rapid-fire trust changes */
+const lastEvaluationTime = new Map();
+const EVALUATION_COOLDOWN_MS = 60_000; // 60 seconds
+export const trustChangeEvaluator = {
+    name: "trustChangeEvaluator",
+    description: "Evaluates interactions to detect and record trust-affecting behaviors",
+    alwaysRun: true,
+    validate: async (runtime, _message, _state) => {
+        const trustEngine = runtime.getService("trust-engine");
+        return !!trustEngine;
+    },
+    handler: async (runtime, message) => {
+        const trustEngineWrapper = runtime.getService("trust-engine");
+        if (!trustEngineWrapper) {
+            return;
+        }
+        const trustEngine = trustEngineWrapper.trustEngine;
+        const entityId = message.entityId;
+        const lastTime = lastEvaluationTime.get(entityId);
+        if (lastTime && Date.now() - lastTime < EVALUATION_COOLDOWN_MS) {
+            return;
+        }
+        lastEvaluationTime.set(entityId, Date.now());
+        try {
+            const content = message.content.text?.toLowerCase() || "";
+            const positivePatterns = [
+                {
+                    pattern: /thank you|thanks|appreciate|grateful/i,
+                    type: TrustEvidenceType.HELPFUL_ACTION,
+                    impact: 5,
+                },
+                {
+                    pattern: /helped|assisted|supported|solved/i,
+                    type: TrustEvidenceType.HELPFUL_ACTION,
+                    impact: 10,
+                },
+                {
+                    pattern: /kept.*promise|delivered|followed through/i,
+                    type: TrustEvidenceType.PROMISE_KEPT,
+                    impact: 15,
+                },
+                {
+                    pattern: /contributed|shared|provided/i,
+                    type: TrustEvidenceType.COMMUNITY_CONTRIBUTION,
+                    impact: 8,
+                },
+            ];
+            const negativePatterns = [
+                {
+                    pattern: /spam|flood|repeat/i,
+                    type: TrustEvidenceType.SPAM_BEHAVIOR,
+                    impact: -10,
+                },
+                {
+                    pattern: /broke.*promise|failed to|didn't deliver/i,
+                    type: TrustEvidenceType.PROMISE_BROKEN,
+                    impact: -15,
+                },
+                {
+                    pattern: /hack|exploit|cheat/i,
+                    type: TrustEvidenceType.SECURITY_VIOLATION,
+                    impact: -25,
+                },
+                {
+                    pattern: /harass|abuse|threat/i,
+                    type: TrustEvidenceType.HARMFUL_ACTION,
+                    impact: -20,
+                },
+            ];
+            for (const { pattern, type, impact } of positivePatterns) {
+                if (pattern.test(content)) {
+                    await trustEngine.recordInteraction({
+                        sourceEntityId: entityId,
+                        targetEntityId: runtime.agentId,
+                        type,
+                        timestamp: Date.now(),
+                        impact,
+                        details: {
+                            description: `Positive behavior detected: ${type}`,
+                            messageId: message.id,
+                            roomId: message.roomId,
+                            autoDetected: true,
+                        },
+                        context: {
+                            evaluatorId: runtime.agentId,
+                            roomId: message.roomId,
+                        },
+                    });
+                    logger.info({
+                        entityId,
+                        type,
+                        impact,
+                    }, "[TrustChangeEvaluator] Recorded positive behavior:");
+                    return {
+                        success: true,
+                        text: `Noted positive behavior: ${type} (+${impact} trust)`,
+                        data: { type, impact, positive: true },
+                    };
+                }
+            }
+            for (const { pattern, type, impact } of negativePatterns) {
+                if (pattern.test(content)) {
+                    await trustEngine.recordInteraction({
+                        sourceEntityId: entityId,
+                        targetEntityId: runtime.agentId,
+                        type,
+                        timestamp: Date.now(),
+                        impact,
+                        details: {
+                            description: `Negative behavior detected: ${type}`,
+                            messageId: message.id,
+                            roomId: message.roomId,
+                            autoDetected: true,
+                        },
+                        context: {
+                            evaluatorId: runtime.agentId,
+                            roomId: message.roomId,
+                        },
+                    });
+                    logger.warn({
+                        entityId,
+                        type,
+                        impact,
+                    }, "[TrustChangeEvaluator] Recorded negative behavior:");
+                    return {
+                        success: false,
+                        text: `Noted concerning behavior: ${type} (${impact} trust)`,
+                        data: { type, impact, positive: false },
+                    };
+                }
+            }
+            try {
+                const recentMessages = await runtime.getMemories({
+                    tableName: "messages",
+                    roomId: message.roomId,
+                    count: 50,
+                });
+                const oneMinuteAgo = Date.now() - 60_000;
+                const recentFromEntity = recentMessages.filter((m) => m.entityId === entityId &&
+                    m.createdAt &&
+                    m.createdAt > oneMinuteAgo);
+                if (recentFromEntity.length > 10) {
+                    await trustEngine.recordInteraction({
+                        sourceEntityId: entityId,
+                        targetEntityId: runtime.agentId,
+                        type: TrustEvidenceType.SPAM_BEHAVIOR,
+                        timestamp: Date.now(),
+                        impact: -5,
+                        details: {
+                            description: "High message frequency detected",
+                            messageCount: recentFromEntity.length,
+                            roomId: message.roomId,
+                            autoDetected: true,
+                        },
+                        context: {
+                            evaluatorId: runtime.agentId,
+                            roomId: message.roomId,
+                        },
+                    });
+                    logger.warn({ entityId, messageCount: recentFromEntity.length }, "[TrustChangeEvaluator] High message frequency detected");
+                }
+            }
+            catch (spamErr) {
+                logger.debug({ error: spamErr }, "[TrustChangeEvaluator] Spam detection check failed");
+            }
+            return;
+        }
+        catch (error) {
+            logger.error({ error }, "[TrustChangeEvaluator] Error evaluating trust changes:");
+            return;
+        }
+    },
+    examples: [
+        {
+            prompt: "User sends a helpful message",
+            messages: [
+                {
+                    name: "{{name1}}",
+                    content: {
+                        text: "Thanks for helping me understand the trust system!",
+                    },
+                },
+            ],
+            outcome: "Positive behavior detected and trust increased",
+        },
+        {
+            prompt: "User exhibits spam behavior",
+            messages: [
+                {
+                    name: "{{name1}}",
+                    content: {
+                        text: "SPAM SPAM SPAM SPAM SPAM",
+                    },
+                },
+            ],
+            outcome: "Negative behavior detected and trust decreased",
+        },
+    ],
+};

package/packages/typescript/src/features/trust/index.d.ts

@@ -0,0 +1,23 @@
+import { type IAgentRuntime, type Plugin } from "../../types/index.ts";
+import * as schema from "./schema.ts";
+import { ContextualPermissionSystem } from "./services/ContextualPermissionSystem.ts";
+import { CredentialProtector } from "./services/CredentialProtector.ts";
+import { SecurityModule } from "./services/SecurityModule.ts";
+import { TrustEngine } from "./services/TrustEngine.ts";
+export type { AccessDecision, AccessRequest, ElevationRequest, ElevationResult, Permission, PermissionContext, PermissionDecision, } from "./types/permissions.ts";
+export * from "./types/security.ts";
+export * from "./types/trust.ts";
+export { ContextualPermissionSystem, CredentialProtector, SecurityModule, TrustEngine, };
+export type TrustEngineService = InstanceType<typeof TrustEngine>;
+export type SecurityModuleService = InstanceType<typeof SecurityModule>;
+export type ContextualPermissionSystemService = InstanceType<typeof ContextualPermissionSystem>;
+export type CredentialProtectorService = InstanceType<typeof CredentialProtector>;
+export * from "./actions/index.ts";
+export * from "./evaluators/index.ts";
+export * from "./providers/index.ts";
+export { ContextualPermissionSystemServiceWrapper, CredentialProtectorServiceWrapper, SecurityModuleServiceWrapper, TrustEngineServiceWrapper, } from "./services/wrappers.ts";
+declare function ensureAdminRoleOnInit(runtime: IAgentRuntime): Promise<void>;
+declare const trustPlugin: Plugin;
+export { ensureAdminRoleOnInit, schema };
+export default trustPlugin;
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/trust/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/trust/index.ts"],"names":[],"mappings":"AACA,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,MAAM,EAGX,MAAM,sBAAsB,CAAC;AAc9B,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAQxD,YAAY,EACX,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,iBAAiB,EACjB,kBAAkB,GAClB,MAAM,wBAAwB,CAAC;AAEhC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,kBAAkB,CAAC;AAEjC,OAAO,EACN,0BAA0B,EAC1B,mBAAmB,EACnB,cAAc,EACd,WAAW,GACX,CAAC;AAGF,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC,OAAO,WAAW,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,YAAY,CAAC,OAAO,cAAc,CAAC,CAAC;AACxE,MAAM,MAAM,iCAAiC,GAAG,YAAY,CAC3D,OAAO,0BAA0B,CACjC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,YAAY,CACpD,OAAO,mBAAmB,CAC1B,CAAC;AAGF,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AAGrC,OAAO,EACN,wCAAwC,EACxC,iCAAiC,EACjC,4BAA4B,EAC5B,yBAAyB,GACzB,MAAM,wBAAwB,CAAC;AAEhC,iBAAe,qBAAqB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA8C1E;AAED,QAAA,MAAM,WAAW,EAAE,MAqClB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,CAAC;AACzC,eAAe,WAAW,CAAC"}

package/packages/typescript/src/features/trust/index.js

@@ -0,0 +1,96 @@
+import { logger } from "../../logger.js";
+import { Role, } from "../../types/index.js";
+import { evaluateTrustAction } from "./actions/evaluateTrust.js";
+import { recordTrustInteractionAction } from "./actions/recordTrustInteraction.js";
+import { requestElevationAction } from "./actions/requestElevation.js";
+import { updateRoleAction } from "./actions/roles.js";
+import { updateSettingsAction } from "./actions/settings.js";
+import { reflectionEvaluator } from "./evaluators/reflection.js";
+import { securityEvaluator } from "./evaluators/securityEvaluator.js";
+import { trustChangeEvaluator } from "./evaluators/trustChangeEvaluator.js";
+import { adminTrustProvider } from "./providers/adminTrust.js";
+import { roleProvider } from "./providers/roles.js";
+import { securityStatusProvider } from "./providers/securityStatus.js";
+import { settingsProvider } from "./providers/settings.js";
+import { trustProfileProvider } from "./providers/trustProfile.js";
+import * as schema from "./schema.js";
+import { ContextualPermissionSystem } from "./services/ContextualPermissionSystem.js";
+import { CredentialProtector } from "./services/CredentialProtector.js";
+import { SecurityModule } from "./services/SecurityModule.js";
+import { TrustEngine } from "./services/TrustEngine.js";
+import { ContextualPermissionSystemServiceWrapper, CredentialProtectorServiceWrapper, SecurityModuleServiceWrapper, TrustEngineServiceWrapper, } from "./services/wrappers.js";
+// Export types
+export * from "./types/security.js";
+// Export types (avoid duplicate exports)
+export * from "./types/trust.js";
+// Export services
+export { ContextualPermissionSystem, CredentialProtector, SecurityModule, TrustEngine, };
+// Export actions and providers
+export * from "./actions/index.js";
+export * from "./evaluators/index.js";
+export * from "./providers/index.js";
+// Service Wrappers (extracted to break circular deps with evaluators/providers)
+export { ContextualPermissionSystemServiceWrapper, CredentialProtectorServiceWrapper, SecurityModuleServiceWrapper, TrustEngineServiceWrapper, } from "./services/wrappers.js";
+async function ensureAdminRoleOnInit(runtime) {
+    const ownerSetting = runtime.getSetting("OWNER_ENTITY_ID");
+    const worldSetting = runtime.getSetting("WORLD_ID");
+    const adminEntityId = typeof ownerSetting === "string" ? ownerSetting : undefined;
+    const worldId = typeof worldSetting === "string" ? worldSetting : undefined;
+    if (!adminEntityId || !worldId) {
+        return;
+    }
+    try {
+        const world = await runtime.getWorld(worldId);
+        if (!world) {
+            logger.debug({ worldId, adminEntityId }, "[TrustPlugin] WORLD_ID not found; skipping admin role bootstrap");
+            return;
+        }
+        const metadata = world.metadata ?? {};
+        world.metadata = metadata;
+        const metadataRecord = metadata;
+        const roles = metadataRecord.roles ?? {};
+        metadataRecord.roles = roles;
+        const currentRole = roles[adminEntityId];
+        if (currentRole === Role.ADMIN || currentRole === Role.OWNER) {
+            return;
+        }
+        roles[adminEntityId] = Role.ADMIN;
+        await runtime.updateWorld(world);
+        logger.info({ adminEntityId, worldId }, "[TrustPlugin] Bootstrapped admin role for app user");
+    }
+    catch (error) {
+        logger.warn({ error, adminEntityId, worldId }, "[TrustPlugin] Failed to bootstrap admin role on init");
+    }
+}
+const trustPlugin = {
+    name: "trust",
+    description: "Advanced trust and security system for AI agents",
+    actions: [
+        updateRoleAction,
+        updateSettingsAction,
+        recordTrustInteractionAction,
+        evaluateTrustAction,
+        requestElevationAction,
+    ],
+    providers: [
+        roleProvider,
+        settingsProvider,
+        trustProfileProvider,
+        securityStatusProvider,
+        adminTrustProvider,
+    ],
+    evaluators: [securityEvaluator, reflectionEvaluator, trustChangeEvaluator],
+    services: [
+        TrustEngineServiceWrapper,
+        SecurityModuleServiceWrapper,
+        CredentialProtectorServiceWrapper,
+        ContextualPermissionSystemServiceWrapper,
+    ],
+    schema,
+    async init(_config, runtime) {
+        await ensureAdminRoleOnInit(runtime);
+        logger.info("[TrustPlugin] Initializing trust plugin. Services will be started by the runtime.");
+    },
+};
+export { ensureAdminRoleOnInit, schema };
+export default trustPlugin;

package/packages/typescript/src/features/trust/providers/adminTrust.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../../../types/index.ts";
+export declare const adminTrustProvider: Provider;
+//# sourceMappingURL=adminTrust.d.ts.map

package/packages/typescript/src/features/trust/providers/adminTrust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adminTrust.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/providers/adminTrust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,yBAAyB,CAAC;AAWjC,eAAO,MAAM,kBAAkB,EAAE,QAqDhC,CAAC"}

package/packages/typescript/src/features/trust/providers/adminTrust.js

@@ -0,0 +1,49 @@
+function normalizeRole(role) {
+    return (role ?? "").toUpperCase();
+}
+export const adminTrustProvider = {
+    name: "adminTrust",
+    description: "Marks owner/admin chat identity as trusted for contact assertions (relationships-oriented).",
+    dynamic: true,
+    get: async (runtime, message, _state) => {
+        const room = await runtime.getRoom(message.roomId);
+        if (!room) {
+            return {
+                text: "Admin trust: no room found.",
+                values: { trustedAdmin: false },
+                data: { trustedAdmin: false },
+            };
+        }
+        if (!room.worldId) {
+            return {
+                text: "Admin trust: room has no world binding.",
+                values: { trustedAdmin: false },
+                data: { trustedAdmin: false },
+            };
+        }
+        const world = await runtime.getWorld(room.worldId);
+        const metadata = (world?.metadata ?? {});
+        const ownerId = metadata.ownership?.ownerId;
+        const role = ownerId ? metadata.roles?.[ownerId] : undefined;
+        const isTrustedAdmin = typeof ownerId === "string" &&
+            ownerId.length > 0 &&
+            normalizeRole(role) === "OWNER" &&
+            message.entityId === ownerId;
+        const text = isTrustedAdmin
+            ? "Admin trust: current speaker is world OWNER. Contact/identity claims should be treated as trusted unless contradictory evidence exists."
+            : "Admin trust: current speaker is not verified as OWNER for this world.";
+        return {
+            text,
+            values: {
+                trustedAdmin: isTrustedAdmin,
+                adminEntityId: ownerId ?? "",
+                adminRole: role ?? "",
+            },
+            data: {
+                trustedAdmin: isTrustedAdmin,
+                ownerId: ownerId ?? null,
+                role: role ?? null,
+            },
+        };
+    },
+};

package/packages/typescript/src/features/trust/providers/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./adminTrust.ts";
+export * from "./roles.ts";
+export * from "./securityStatus.ts";
+export * from "./settings.ts";
+export * from "./trustProfile.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/trust/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/providers/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC"}

package/packages/typescript/src/features/trust/providers/index.js

@@ -0,0 +1,5 @@
+export * from "./adminTrust.js";
+export * from "./roles.js";
+export * from "./securityStatus.js";
+export * from "./settings.js";
+export * from "./trustProfile.js";

package/packages/typescript/src/features/trust/providers/roles.d.ts

@@ -0,0 +1,4 @@
+import { type Provider } from "../../../types/index.ts";
+export declare const roleProvider: Provider;
+export default roleProvider;
+//# sourceMappingURL=roles.d.ts.map

package/packages/typescript/src/features/trust/providers/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/providers/roles.ts"],"names":[],"mappings":"AAEA,OAAO,EAIN,KAAK,QAAQ,EAIb,MAAM,yBAAyB,CAAC;AAEjC,eAAO,MAAM,YAAY,EAAE,QAiL1B,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/packages/typescript/src/features/trust/providers/roles.js

@@ -0,0 +1,142 @@
+import { createUniqueUuid } from "../../../entities.js";
+import { logger } from "../../../logger.js";
+import { ChannelType, } from "../../../types/index.js";
+export const roleProvider = {
+    name: "ROLES",
+    description: "Roles in the server, default are OWNER, ADMIN and MEMBER (as well as NONE)",
+    dynamic: true,
+    get: async (runtime, message, state) => {
+        const room = state.data.room ?? (await runtime.getRoom(message.roomId));
+        if (!room) {
+            logger.debug("No room found for roles provider, skipping");
+            return {
+                data: { roles: [] },
+                values: {
+                    roles: "No room context available for role information.",
+                },
+                text: "No room context available for role information.",
+            };
+        }
+        if (room.type !== ChannelType.GROUP) {
+            return {
+                data: {
+                    roles: [],
+                },
+                values: {
+                    roles: "No access to role information in DMs, the role provider is only available in group scenarios.",
+                },
+                text: "No access to role information in DMs, the role provider is only available in group scenarios.",
+            };
+        }
+        const serverId = room.messageServerId;
+        if (!serverId) {
+            throw new Error("No server ID found");
+        }
+        logger.info(`Using server ID: ${serverId}`);
+        const worldId = createUniqueUuid(runtime, serverId);
+        const world = await runtime.getWorld(worldId);
+        if (!world?.metadata?.ownership?.ownerId) {
+            logger.info(`No ownership data found for server ${serverId}, initializing empty role hierarchy`);
+            return {
+                data: {
+                    roles: [],
+                },
+                values: {
+                    roles: "No role information available for this server.",
+                },
+                text: "No role information available for this server.",
+            };
+        }
+        const roles = world.metadata.roles || {};
+        if (Object.keys(roles).length === 0) {
+            logger.info(`No roles found for server ${serverId}`);
+            return {
+                data: {
+                    roles: [],
+                },
+                values: {
+                    roles: "No role information available for this server.",
+                },
+            };
+        }
+        logger.info(`Found ${Object.keys(roles).length} roles`);
+        const owners = [];
+        const admins = [];
+        const members = [];
+        for (const entityId of Object.keys(roles)) {
+            const userRole = roles[entityId];
+            const user = await runtime.getEntityById(entityId);
+            const metadata = user?.metadata;
+            const name = metadata?.default?.name ||
+                metadata?.discord?.name ||
+                user?.names?.[0];
+            const username = metadata?.default?.username ||
+                metadata?.discord?.username ||
+                metadata?.discord?.userName ||
+                user?.names?.[0];
+            const names = user?.names;
+            if (owners.some((owner) => owner.username === username) ||
+                admins.some((admin) => admin.username === username) ||
+                members.some((member) => member.username === username)) {
+                continue;
+            }
+            if (!name || !username || !names || names.length === 0) {
+                logger.warn(`User ${entityId} (role: ${userRole}) has no name or username, skipping`);
+                continue;
+            }
+            switch (userRole) {
+                case "OWNER":
+                    owners.push({ name, username, names });
+                    break;
+                case "ADMIN":
+                    admins.push({ name, username, names });
+                    break;
+                default:
+                    members.push({ name, username, names });
+                    break;
+            }
+        }
+        let response = "# Server Role Hierarchy\n\n";
+        if (owners.length > 0) {
+            response += "## Owners\n";
+            owners.forEach((owner) => {
+                response += `${owner.name} (${owner.names.join(", ")})\n`;
+            });
+            response += "\n";
+        }
+        if (admins.length > 0) {
+            response += "## Administrators\n";
+            admins.forEach((admin) => {
+                response += `${admin.name} (${admin.names.join(", ")}) (${admin.username})\n`;
+            });
+            response += "\n";
+        }
+        if (members.length > 0) {
+            response += "## Members\n";
+            members.forEach((member) => {
+                response += `${member.name} (${member.names.join(", ")}) (${member.username})\n`;
+            });
+        }
+        if (owners.length === 0 && admins.length === 0 && members.length === 0) {
+            return {
+                data: {
+                    roles: [],
+                },
+                values: {
+                    roles: "No role information available for this server.",
+                },
+                text: "No role information available for this server.",
+            };
+        }
+        return {
+            data: {
+                roles: response,
+            },
+            values: {
+                roles: response,
+            },
+            text: response,
+        };
+    },
+};
+export default roleProvider;

package/packages/typescript/src/features/trust/providers/securityStatus.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../../../types/index.ts";
+export declare const securityStatusProvider: Provider;
+//# sourceMappingURL=securityStatus.d.ts.map

package/packages/typescript/src/features/trust/providers/securityStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"securityStatus.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/providers/securityStatus.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGX,QAAQ,EAER,MAAM,yBAAyB,CAAC;AAgBjC,eAAO,MAAM,sBAAsB,EAAE,QAwIpC,CAAC"}