@smythos/sre 1.5.0

package/dist/types/subsystems/LLMManager/paramMappings.d.ts

@@ -0,0 +1,69 @@
+declare const _default: {
+    Echo: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+        frequencyPenalty: string;
+        presencePenalty: string;
+    };
+    OpenAI: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+        frequencyPenalty: string;
+        presencePenalty: string;
+    };
+    cohere: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+        topK: string;
+        frequencyPenalty: string;
+        presencePenalty: string;
+    };
+    TogetherAI: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+        topK: string;
+        frequencyPenalty: string;
+    };
+    Anthropic: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+        topK: string;
+    };
+    GoogleAI: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+        topK: string;
+    };
+    Groq: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+    };
+    Bedrock: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+    };
+    VertexAI: {
+        maxTokens: string;
+        temperature: string;
+        stopSequences: string;
+        topP: string;
+        topK: string;
+    };
+};
+export default _default;

package/dist/types/subsystems/MemoryManager/Cache.service/CacheConnector.d.ts

@@ -0,0 +1,41 @@
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IACL, IAccessCandidate } from '@sre/types/ACL.types';
+import { CacheMetadata } from '@sre/types/Cache.types';
+export interface ICacheRequest {
+    get: (key: string) => Promise<any>;
+    /**
+     * Set a value in the cache
+     * @param key
+     * @param data
+     * @param acl
+     * @param metadata
+     * @param ttl Cache time to live in seconds
+     * @returns
+     */
+    set: (key: string, data: any, acl?: IACL, metadata?: CacheMetadata, ttl?: number) => Promise<boolean>;
+    delete: (key: string) => Promise<void>;
+    exists: (key: string) => Promise<boolean>;
+    getMetadata: (key: string) => Promise<CacheMetadata | undefined>;
+    setMetadata: (key: string, metadata: CacheMetadata) => Promise<void>;
+    updateTTL: (key: string, ttl?: number) => Promise<void>;
+    getTTL: (key: string) => Promise<number>;
+    getACL: (key: string) => Promise<IACL | undefined>;
+    setACL: (key: string, acl: IACL) => Promise<void>;
+}
+export declare abstract class CacheConnector extends SecureConnector {
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    requester(candidate: AccessCandidate): ICacheRequest;
+    abstract get(acRequest: AccessRequest, key: string): Promise<any>;
+    abstract set(acRequest: AccessRequest, key: string, data: any, acl?: IACL, metadata?: CacheMetadata, ttl?: number): Promise<boolean>;
+    abstract delete(acRequest: AccessRequest, key: string): Promise<void>;
+    abstract exists(acRequest: AccessRequest, key: string): Promise<boolean>;
+    abstract getMetadata(acRequest: AccessRequest, key: string): Promise<CacheMetadata | undefined>;
+    abstract setMetadata(acRequest: AccessRequest, key: string, metadata: CacheMetadata): Promise<void>;
+    abstract updateTTL(acRequest: AccessRequest, key: string, ttl?: number): Promise<void>;
+    abstract getTTL(acRequest: AccessRequest, key: string): Promise<number>;
+    abstract getACL(acRequest: AccessRequest, key: string): Promise<IACL | undefined>;
+    abstract setACL(acRequest: AccessRequest, key: string, acl: IACL): Promise<void>;
+}

package/dist/types/subsystems/MemoryManager/Cache.service/connectors/LocalStorageCache.class.d.ts

@@ -0,0 +1,33 @@
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { CacheMetadata } from '@sre/types/Cache.types';
+import { CacheConnector } from '../CacheConnector';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { LocalStorageConfig } from '@sre/IO/Storage.service/connectors/LocalStorage.class';
+export declare class LocalStorageCache extends CacheConnector {
+    name: string;
+    private folder;
+    private _prefix;
+    private _mdPrefix;
+    private isInitialized;
+    constructor(_settings: LocalStorageConfig);
+    private initialize;
+    get prefix(): string;
+    get mdPrefix(): string;
+    get(acRequest: AccessRequest, key: string): Promise<string | null>;
+    set(acRequest: AccessRequest, key: string, data: any, acl?: IACL, metadata?: CacheMetadata, ttl?: number): Promise<boolean>;
+    delete(acRequest: AccessRequest, key: string): Promise<void>;
+    exists(acRequest: AccessRequest, key: string): Promise<boolean>;
+    getMetadata(acRequest: AccessRequest, key: string): Promise<CacheMetadata>;
+    setMetadata(acRequest: AccessRequest, key: string, metadata: CacheMetadata): Promise<void>;
+    updateTTL(acRequest: AccessRequest, key: string, ttl?: number): Promise<void>;
+    getTTL(acRequest: AccessRequest, key: string): Promise<number>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    getACL(acRequest: AccessRequest, key: string): Promise<IACL>;
+    setACL(acRequest: AccessRequest, key: string, acl: IACL): Promise<void>;
+    private serializeMetadata;
+    private deserializeMetadata;
+    private getStorageFilePath;
+    private getMetadataFilePath;
+    private createDirectories;
+}

package/dist/types/subsystems/MemoryManager/Cache.service/connectors/RAMCache.class.d.ts

@@ -0,0 +1,31 @@
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { CacheMetadata } from '@sre/types/Cache.types';
+import { CacheConnector } from '../CacheConnector';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+export declare class RAMCache extends CacheConnector {
+    protected _settings: any;
+    name: string;
+    private _prefix;
+    private _mdPrefix;
+    private cache;
+    private cleanupInterval;
+    constructor(_settings: any);
+    get prefix(): string;
+    get mdPrefix(): string;
+    private getFullKey;
+    private getFullMetadataKey;
+    private cleanupExpiredEntries;
+    get(acRequest: AccessRequest, key: string): Promise<string | null>;
+    set(acRequest: AccessRequest, key: string, data: any, acl?: IACL, metadata?: CacheMetadata, ttl?: number): Promise<boolean>;
+    delete(acRequest: AccessRequest, key: string): Promise<void>;
+    exists(acRequest: AccessRequest, key: string): Promise<boolean>;
+    getMetadata(acRequest: AccessRequest, key: string): Promise<CacheMetadata>;
+    setMetadata(acRequest: AccessRequest, key: string, metadata: CacheMetadata): Promise<void>;
+    updateTTL(acRequest: AccessRequest, key: string, ttl?: number): Promise<void>;
+    getTTL(acRequest: AccessRequest, key: string): Promise<number>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    getACL(acRequest: AccessRequest, key: string): Promise<IACL>;
+    setACL(acRequest: AccessRequest, key: string, acl: IACL): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/types/subsystems/MemoryManager/Cache.service/connectors/RedisCache.class.d.ts

@@ -0,0 +1,33 @@
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { CacheMetadata } from '@sre/types/Cache.types';
+import IORedis from 'ioredis';
+import { CacheConnector } from '../CacheConnector';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { RedisConfig } from '@sre/types/Redis.types';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+export declare class RedisCache extends CacheConnector {
+    protected _settings: RedisConfig;
+    name: string;
+    private redis;
+    private _prefix;
+    private _mdPrefix;
+    constructor(_settings: RedisConfig);
+    get client(): IORedis;
+    get prefix(): string;
+    get mdPrefix(): string;
+    get(acRequest: AccessRequest, key: string): Promise<string | null>;
+    set(acRequest: AccessRequest, key: string, data: any, acl?: IACL, metadata?: CacheMetadata, ttl?: number): Promise<boolean>;
+    delete(acRequest: AccessRequest, key: string): Promise<void>;
+    exists(acRequest: AccessRequest, key: string): Promise<boolean>;
+    getMetadata(acRequest: AccessRequest, key: string): Promise<CacheMetadata>;
+    setMetadata(acRequest: AccessRequest, key: string, metadata: CacheMetadata): Promise<void>;
+    private setMetadataWithTTL;
+    updateTTL(acRequest: AccessRequest, key: string, ttl?: number): Promise<void>;
+    getTTL(acRequest: AccessRequest, key: string): Promise<number>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    getACL(acRequest: AccessRequest, key: string): Promise<IACL>;
+    setACL(acRequest: AccessRequest, key: string, acl: IACL): Promise<void>;
+    private serializeRedisMetadata;
+    private deserializeRedisMetadata;
+    stop(): Promise<void>;
+}

package/dist/types/subsystems/MemoryManager/Cache.service/connectors/S3Cache.class.d.ts

@@ -0,0 +1,38 @@
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { CacheMetadata } from '@sre/types/Cache.types';
+import { CacheConnector } from '../CacheConnector';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { S3Client } from '@aws-sdk/client-s3';
+export type S3CacheConfig = {
+    bucketName: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+};
+export declare class S3Cache extends CacheConnector {
+    protected _settings: S3CacheConfig;
+    name: string;
+    private s3Client;
+    private bucketName;
+    private isInitialized;
+    private cachePrefix;
+    constructor(_settings: S3CacheConfig);
+    get client(): S3Client;
+    get(acRequest: AccessRequest, key: string): Promise<string | null>;
+    set(acRequest: AccessRequest, key: string, data: any, acl?: IACL, metadata?: CacheMetadata, ttl?: number): Promise<boolean>;
+    delete(acRequest: AccessRequest, key: string): Promise<void>;
+    exists(acRequest: AccessRequest, key: string): Promise<boolean>;
+    getMetadata(acRequest: AccessRequest, key: string): Promise<CacheMetadata>;
+    setMetadata(acRequest: AccessRequest, key: string, metadata: CacheMetadata): Promise<void>;
+    updateTTL(acRequest: AccessRequest, key: string, ttl?: number): Promise<void>;
+    getTTL(acRequest: AccessRequest, key: string): Promise<number>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    getACL(acRequest: AccessRequest, key: string): Promise<IACL>;
+    setACL(acRequest: AccessRequest, key: string, acl: IACL): Promise<void>;
+    private getS3Metadata;
+    private setS3Metadata;
+    private initialize;
+    private serializeS3Metadata;
+    private deserializeS3Metadata;
+}

package/dist/types/subsystems/MemoryManager/Cache.service/index.d.ts

@@ -0,0 +1,4 @@
+import { ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+export declare class CacheService extends ConnectorServiceProvider {
+    register(): void;
+}

package/dist/types/subsystems/MemoryManager/LLMCache.d.ts

@@ -0,0 +1,27 @@
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+export type LLMCacheObject = {
+    ttl: number;
+    data: any;
+};
+export declare class LLMCache {
+    private _cacheConnector;
+    private _cacheId;
+    private _ttl;
+    private _candidate;
+    get id(): string;
+    /**
+     * Creates a new LLMCache instace for a smythOS actor, the actor can be an agent, a user or a team
+     * This is mainly use with agent to maintain a cache of the current LLM context
+     *
+     * This class can be used to share llm contexts data accross multiple instances of an agent, or between a ConversationHelper and a remote agent
+     *
+     * @param candidate
+     * @param cacheId
+     * @param ttl
+     */
+    constructor(candidate: AccessCandidate, cacheId?: string, ttl?: number);
+    set(key: string, data: any): Promise<void>;
+    get(key: string, format?: 'json' | 'text'): Promise<any>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/subsystems/MemoryManager/LLMContext.d.ts

@@ -0,0 +1,25 @@
+import { ILLMContextStore } from '@sre/types/LLM.types';
+import { LLMCache } from './LLMCache';
+export declare class LLMContext {
+    private llmInference;
+    private _systemPrompt;
+    private _llmContextStore;
+    private _llmCache;
+    get systemPrompt(): string;
+    set systemPrompt(systemPrompt: string);
+    get llmCache(): LLMCache;
+    contextLength: number;
+    private _messages;
+    get messages(): any[];
+    get model(): any;
+    /**
+     *
+     * @param source a messages[] object, or smyth file system uri (smythfs://...)
+     */
+    constructor(llmInference: any, _systemPrompt?: string, llmContextStore?: ILLMContextStore);
+    private push;
+    addUserMessage(content: string, message_id: string, metadata?: any): void;
+    addAssistantMessage(content: string, message_id: string, metadata?: any): void;
+    addToolMessage(messageBlock: any, toolsData: any, message_id: string, metadata?: any): void;
+    getContextWindow(maxTokens: number, maxOutputTokens?: number): Promise<any[]>;
+}

package/dist/types/subsystems/MemoryManager/RuntimeContext.d.ts

@@ -0,0 +1,50 @@
+import EventEmitter from 'events';
+import { AgentRuntime } from '@sre/AgentManager/AgentRuntime.class';
+type TRuntimeData = {
+    input?: {
+        [key: string]: any;
+    };
+    _LoopData?: any;
+    _ChildLoopData?: any;
+};
+type TComponentContext = {
+    active: boolean;
+    name: string;
+    runtimeData?: TRuntimeData;
+    step: number;
+    input?: {
+        [key: string]: any;
+    };
+    output?: {
+        [key: string]: any;
+    };
+};
+export declare class RuntimeContext extends EventEmitter {
+    private runtime;
+    circularLimitReached: string | boolean;
+    step: number;
+    sessionResult: boolean;
+    sessionResults: any;
+    components: {
+        [id: string]: {
+            ctx: TComponentContext;
+        };
+    };
+    checkRuntimeContext: any;
+    private ctxFile;
+    private _runtimeFileReady;
+    private _cacheConnector;
+    private _readyPromise;
+    constructor(runtime: AgentRuntime);
+    private serialize;
+    private deserialize;
+    private reset;
+    private initRuntimeContext;
+    ready(): Promise<boolean>;
+    sync(): Promise<void>;
+    incStep(): void;
+    updateComponent(componentId: string, data: any): void;
+    resetComponent(componentId: string): void;
+    getComponentData(componentId: string): TComponentContext;
+}
+export {};

package/dist/types/subsystems/Security/AccessControl/ACL.class.d.ts

@@ -0,0 +1,29 @@
+import { IACL, IAccessRequest, TACLEntry, TAccessLevel, TAccessRole } from '@sre/types/ACL.types';
+export declare class ACL implements IACL {
+    hashAlgorithm?: string | undefined;
+    entries?: {
+        [key in TAccessRole]?: TACLEntry | undefined;
+    };
+    migrated?: boolean | undefined;
+    get ACL(): IACL;
+    get serializedACL(): string;
+    constructor(acl?: IACL | string);
+    static from(acl?: IACL | string): ACL;
+    /**
+     * This function checks if the candidate has access to the requested level
+     * it only checks the exact access level, not the higher levels
+     * Examples :
+     * - if the candidate has read access, it will return true only if the requested level is read
+     * - if the current ACL has team access but the candidate is an agent, it will not match the team access
+     * @param acRequest
+     * @returns
+     */
+    checkExactAccess(acRequest: IAccessRequest): boolean;
+    addPublicAccess(level: TAccessLevel | TAccessLevel[]): ACL;
+    removePublicAccess(level: TAccessLevel | TAccessLevel[]): ACL;
+    addAccess(role: TAccessRole, ownerId: string, level: TAccessLevel | TAccessLevel[]): ACL;
+    static addAccess(role: TAccessRole, ownerId: string, level: TAccessLevel | TAccessLevel[]): ACL;
+    removeAccess(role: TAccessRole, ownerId: string, level: TAccessLevel | TAccessLevel[]): ACL;
+    private serializeACL;
+    private deserializeACL;
+}

package/dist/types/subsystems/Security/AccessControl/AccessCandidate.class.d.ts

@@ -0,0 +1,21 @@
+import { IAccessCandidate, TAccessRole } from '@sre/types/ACL.types';
+import { AccessRequest } from './AccessRequest.class';
+export declare class AccessCandidate implements IAccessCandidate {
+    role: TAccessRole;
+    id: string;
+    constructor(candidate?: IAccessCandidate);
+    toString(): string;
+    get request(): AccessRequest;
+    get readRequest(): AccessRequest;
+    get writeRequest(): AccessRequest;
+    get ownerRequest(): AccessRequest;
+    static clone(candidate: IAccessCandidate): AccessCandidate;
+    team(teamId: string): AccessCandidate;
+    static team(teamId: string): AccessCandidate;
+    agent(agentId: string): AccessCandidate;
+    static agent(agentId: string): AccessCandidate;
+    user(userId: string): AccessCandidate;
+    static user(userId: string): AccessCandidate;
+    public(): AccessCandidate;
+    static public(): AccessCandidate;
+}

package/dist/types/subsystems/Security/AccessControl/AccessRequest.class.d.ts

@@ -0,0 +1,13 @@
+import { IAccessCandidate, IAccessRequest, TAccessLevel } from '@sre/types/ACL.types';
+export declare class AccessRequest implements IAccessRequest {
+    id: string;
+    resourceId: string;
+    level: TAccessLevel[];
+    candidate: IAccessCandidate;
+    constructor(object?: IAccessRequest | IAccessCandidate);
+    static clone(request: IAccessRequest): AccessRequest;
+    setLevel(level: TAccessLevel | TAccessLevel[]): AccessRequest;
+    addLevel(level: TAccessLevel | TAccessLevel[]): AccessRequest;
+    resource(resourceId: string): AccessRequest;
+    setCandidate(candidate: IAccessCandidate): AccessRequest;
+}

package/dist/types/subsystems/Security/Account.service/AccountConnector.d.ts

@@ -0,0 +1,27 @@
+import { Connector } from '@sre/Core/Connector.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { AccessCandidate } from '../AccessControl/AccessCandidate.class';
+import { KeyValueObject } from '@sre/types/Common.types';
+import { ACL } from '../AccessControl/ACL.class';
+export interface ISmythAccountRequest {
+    isTeamMember(teamId: string): Promise<boolean>;
+    getCandidateTeam(): Promise<string | undefined>;
+    getAllTeamSettings(): Promise<KeyValueObject>;
+    getAllUserSettings(): Promise<KeyValueObject>;
+    getTeamSetting(settingKey: string): Promise<string>;
+    getUserSetting(settingKey: string): Promise<string>;
+    getAgentSetting(settingKey: string): Promise<string>;
+    getTeam(): Promise<string>;
+}
+export declare abstract class AccountConnector extends Connector {
+    requester(candidate: AccessCandidate): ISmythAccountRequest;
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    abstract isTeamMember(teamId: string, candidate: IAccessCandidate): Promise<boolean>;
+    abstract getCandidateTeam(candidate: IAccessCandidate): Promise<string | undefined>;
+    abstract getAllTeamSettings(acRequest: AccessRequest, teamId: string): Promise<KeyValueObject>;
+    abstract getAllUserSettings(acRequest: AccessRequest, accountId: string): Promise<KeyValueObject>;
+    abstract getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string): Promise<string>;
+    abstract getUserSetting(acRequest: AccessRequest, accountId: string, settingKey: string): Promise<string>;
+    abstract getAgentSetting(acRequest: AccessRequest, agentId: string, settingKey: string): Promise<string>;
+}

package/dist/types/subsystems/Security/Account.service/connectors/AWSAccount.class.d.ts

@@ -0,0 +1,19 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { AccountConnector } from '../AccountConnector';
+import { KeyValueObject } from '@sre/types/Common.types';
+export declare class AWSAccount extends AccountConnector {
+    protected _settings: any;
+    name: string;
+    private pool;
+    constructor(_settings: any);
+    isTeamMember(team: string, candidate: IAccessCandidate): Promise<boolean>;
+    getCandidateTeam(candidate: IAccessCandidate): Promise<string | undefined>;
+    getAllTeamSettings(acRequest: AccessRequest, teamId: string): Promise<KeyValueObject[]>;
+    getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string): Promise<string>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    getAllUserSettings(acRequest: AccessRequest, accountId: string): Promise<KeyValueObject[]>;
+    getUserSetting(acRequest: AccessRequest, accountId: string, settingKey: string): Promise<string>;
+    getAgentSetting(acRequest: AccessRequest, agentId: string, settingKey: string): Promise<string>;
+}

package/dist/types/subsystems/Security/Account.service/connectors/DummyAccount.class.d.ts

@@ -0,0 +1,19 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { AccountConnector } from '../AccountConnector';
+import { KeyValueObject } from '@sre/types/Common.types';
+export declare class DummyAccount extends AccountConnector {
+    protected _settings?: any;
+    name: string;
+    data: any;
+    constructor(_settings?: any);
+    isTeamMember(team: string, candidate: IAccessCandidate): Promise<boolean>;
+    getCandidateTeam(candidate: IAccessCandidate): Promise<string | undefined>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    getAllTeamSettings(acRequest: AccessRequest, teamId: string): Promise<KeyValueObject[]>;
+    getAllUserSettings(acRequest: AccessRequest, accountId: string): Promise<KeyValueObject[]>;
+    getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string): Promise<string>;
+    getUserSetting(acRequest: AccessRequest, accountId: string, settingKey: string): Promise<string>;
+    getAgentSetting(acRequest: AccessRequest, agentId: string, settingKey: string): Promise<string>;
+}

package/dist/types/subsystems/Security/Account.service/connectors/JSONFileAccount.class.d.ts

@@ -0,0 +1,25 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { AccountConnector } from '../AccountConnector';
+import { KeyValueObject } from '@sre/types/Common.types';
+export type TJSONFileAccountSettings = {
+    file: string;
+};
+export declare class JSONFileAccount extends AccountConnector {
+    protected _settings: TJSONFileAccountSettings;
+    name: string;
+    private data;
+    private file;
+    constructor(_settings: TJSONFileAccountSettings);
+    private loadData;
+    private saveData;
+    isTeamMember(team: string, candidate: IAccessCandidate): Promise<boolean>;
+    getCandidateTeam(candidate: IAccessCandidate): Promise<string | undefined>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    getAllTeamSettings(acRequest: AccessRequest, teamId: string): Promise<KeyValueObject[]>;
+    getAllUserSettings(acRequest: AccessRequest, accountId: string): Promise<KeyValueObject[]>;
+    getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string): Promise<string>;
+    getUserSetting(acRequest: AccessRequest, accountId: string, settingKey: string): Promise<string>;
+    getAgentSetting(acRequest: AccessRequest, agentId: string, settingKey: string): Promise<string>;
+}

package/dist/types/subsystems/Security/Account.service/index.d.ts

@@ -0,0 +1,4 @@
+import { ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+export declare class AccountService extends ConnectorServiceProvider {
+    register(): void;
+}

package/dist/types/subsystems/Security/Credentials.helper.d.ts

@@ -0,0 +1,16 @@
+import { AccessCandidate } from '../..';
+export type TCredentialsRequest = {
+    vaultProvider?: string;
+    keyName: string;
+    mapping?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Get credentials from a vault
+ *
+ * @param candidate - The candidate requesting the credentials
+ * @param credentialsRequest - The credentials request
+ * @returns The credentials
+ */
+export declare function getCredentials(candidate: AccessCandidate, credentialsRequest: TCredentialsRequest | string): Promise<string | Record<string, any>>;

package/dist/types/subsystems/Security/ManagedVault.service/ManagedVaultConnector.d.ts

@@ -0,0 +1,23 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+/**
+ * The managed vault is a vault that is managed by the SRE, its keys are not visible to the user.
+ * it's used to store generated tokens at runtime, like OAuth tokens
+ */
+export interface IManagedVaultRequest {
+    get(keyId: string): Promise<string>;
+    set(keyId: string, value: string): Promise<void>;
+    delete(keyId: string): Promise<void>;
+    exists(keyId: string): Promise<boolean>;
+}
+export declare abstract class ManagedVaultConnector extends SecureConnector {
+    requester(candidate: AccessCandidate): IManagedVaultRequest;
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract get(acRequest: AccessRequest, keyId: string): Promise<string>;
+    protected abstract set(acRequest: AccessRequest, keyId: string, value: string): Promise<void>;
+    protected abstract delete(acRequest: AccessRequest, keyId: string): Promise<void>;
+    protected abstract exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+}

package/dist/types/subsystems/Security/ManagedVault.service/connectors/NullManagedVault.class.d.ts

@@ -0,0 +1,14 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ManagedVaultConnector } from '../ManagedVaultConnector';
+export declare class NullManagedVault extends ManagedVaultConnector {
+    protected _settings: any;
+    name: string;
+    constructor(_settings: any);
+    protected get(acRequest: AccessRequest, keyId: string): Promise<any>;
+    protected set(acRequest: AccessRequest, keyId: string, value: string): Promise<void>;
+    protected delete(acRequest: AccessRequest, keyId: string): Promise<void>;
+    protected exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+}

package/dist/types/subsystems/Security/ManagedVault.service/connectors/SecretManagerManagedVault.d.ts

@@ -0,0 +1,22 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ManagedVaultConnector } from '../ManagedVaultConnector';
+import { SecretsManagerConfig } from '../../Vault.service/connectors/SecretsManager.class';
+export declare class SecretManagerManagedVault extends ManagedVaultConnector {
+    protected _settings: SecretsManagerConfig & {
+        vaultName: string;
+    };
+    name: string;
+    scope: string;
+    private secretsManager;
+    constructor(_settings: SecretsManagerConfig & {
+        vaultName: string;
+    });
+    protected get(acRequest: AccessRequest, secretName: string): Promise<any>;
+    protected set(acRequest: AccessRequest, secretName: string, value: string): Promise<void>;
+    protected delete(acRequest: AccessRequest, secretName: string): Promise<void>;
+    protected exists(acRequest: AccessRequest, secretName: string): Promise<boolean>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    private getSecretByName;
+}

package/dist/types/subsystems/Security/ManagedVault.service/index.d.ts

@@ -0,0 +1,4 @@
+import { ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+export declare class ManagedVaultService extends ConnectorServiceProvider {
+    register(): void;
+}

package/dist/types/subsystems/Security/SecureConnector.class.d.ts

@@ -0,0 +1,13 @@
+import { Connector } from '@sre/Core/Connector.class';
+import { IAccessCandidate, TAccessTicket } from '@sre/types/ACL.types';
+import { ACL } from './AccessControl/ACL.class';
+import { AccessRequest } from './AccessControl/AccessRequest.class';
+export declare abstract class SecureConnector<TRequest = any> extends Connector<TRequest> {
+    abstract name: string;
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    protected hasAccess(acRequest: AccessRequest): Promise<boolean>;
+    getAccessTicket(resourceId: string, request: AccessRequest): Promise<TAccessTicket>;
+    static AccessControl(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+}

package/dist/types/subsystems/Security/Vault.service/Vault.helper.d.ts

@@ -0,0 +1,5 @@
+export declare class VaultHelper {
+    static getTeamKey(key: string, teamId: string): Promise<string>;
+    static getUserKey(key: string, userId: string): Promise<string>;
+    static getAgentKey(key: string, agentId: string): Promise<string>;
+}