@smythos/sre 1.5.0

package/dist/types/subsystems/AgentManager/AgentRequest.class.d.ts

@@ -0,0 +1,15 @@
+export declare class AgentRequest {
+    headers: any;
+    body: any;
+    query: any;
+    params: any;
+    method: string;
+    path: string;
+    sessionID: string;
+    res: Response | null;
+    req: Request | null;
+    files: any[];
+    _agent_authinfo: any;
+    constructor(req?: AgentRequest | string[] | any);
+    header(name: string): any;
+}

package/dist/types/subsystems/AgentManager/AgentRuntime.class.d.ts

@@ -0,0 +1,91 @@
+import { Agent } from './Agent.class';
+import { LLMCache } from '@sre/MemoryManager/LLMCache';
+export declare class AgentRuntime {
+    agent: Agent;
+    private static processResults;
+    private static tagsData;
+    static dummy: {};
+    private agentContext;
+    llmCache: LLMCache;
+    private xDebugRun;
+    private xDebugInject;
+    private xDebugRead;
+    private xDebugStop;
+    private xDebugPendingInject;
+    private xMockDataInject;
+    xDebugId: string | undefined;
+    private xDebugCmd;
+    private _debugActive;
+    private _runtimeFileReady;
+    sessionClosed: boolean;
+    private reqTagOwner;
+    reqTag: any;
+    processID: any;
+    workflowReqId: any;
+    alwaysActiveComponents: any;
+    exclusiveComponents: any;
+    private checkRuntimeContext;
+    get circularLimitReached(): string | boolean;
+    set circularLimitReached(value: string | boolean);
+    get debug(): boolean;
+    get curStep(): number;
+    constructor(agent: Agent);
+    ready(): Promise<boolean>;
+    destroy(): void;
+    incTag(componentId: any): void;
+    sync(): Promise<void>;
+    getWaitingComponents(): any;
+    getExclusiveActiveComponents(): any;
+    readState(stateId: string, deltaOnly?: boolean): {
+        state: {};
+        dbgSession: any;
+        sessionClosed: boolean;
+        error: string;
+        step?: undefined;
+    } | {
+        state: {};
+        dbgSession: any;
+        sessionClosed: boolean;
+        step: number;
+        error?: undefined;
+    };
+    /**
+     * This method is called by the agent to run a process cycle, it will run all active components and return the results
+     * The function is called multiple times until all components are executed and no more active components are available
+     * @returns
+     */
+    runCycle(): Promise<any>;
+    private processResults;
+    checkCircularLimit(): string | boolean;
+    injectDebugOutput(componentId: string): Promise<any>;
+    getRuntimeData(componentId: any): {
+        input?: {
+            [key: string]: any;
+        };
+        _LoopData?: any;
+        _ChildLoopData?: any;
+    };
+    updateRuntimeData(componentId: any, data: any): void;
+    saveRuntimeComponentData(componentId: any, data: any): void;
+    incStep(): void;
+    updateComponent(componentId: string, data: any): void;
+    resetComponent(componentId: string): void;
+    getComponentData(componentId: string): {
+        active: boolean;
+        name: string;
+        runtimeData?: {
+            input?: {
+                [key: string]: any;
+            };
+            _LoopData?: any;
+            _ChildLoopData?: any;
+        };
+        step: number;
+        input?: {
+            [key: string]: any;
+        };
+        output?: {
+            [key: string]: any;
+        };
+    };
+}

package/dist/types/subsystems/AgentManager/AgentSSE.class.d.ts

@@ -0,0 +1,40 @@
+import { Agent } from './Agent.class';
+export declare class AgentSSE {
+    private agent;
+    private connections;
+    /**
+     * Creates a new AgentSSE instance
+     * @param agent - The agent instance this SSE belongs to
+     */
+    constructor(agent: Agent);
+    /**
+     * Updates or adds a response object with the given monitor ID
+     * Maintains backward compatibility by also setting the res property
+     * @param res - The response object to add or update
+     * @param monitorId - The monitor ID associated with this connection
+     * @returns The connection ID that was created or updated
+     */
+    add(res: any, monitorId: string): void;
+    [Symbol.iterator](): IterableIterator<[string, any]>;
+    /**
+     * Sends an event to all connected clients
+     * @param _type - The event type
+     * @param _data - The event data
+     */
+    send(_type: string, _data: any): Promise<void>;
+    /**
+     * Removes a specific connection
+     * @param connectionId - The ID of the connection to remove
+     * @returns True if the connection was found and removed, false otherwise
+     */
+    remove(connectionId: string): boolean;
+    /**
+     * Closes all connections
+     */
+    close(): Promise<void>;
+    /**
+     * Gets the number of active connections
+     * @returns The number of active connections
+     */
+    getConnectionCount(): number;
+}

package/dist/types/subsystems/AgentManager/AgentSettings.class.d.ts

@@ -0,0 +1,12 @@
+import { EmbodimentSettings } from './EmbodimentSettings.class';
+export declare class AgentSettings {
+    private _settings;
+    embodiments?: EmbodimentSettings;
+    private _ready;
+    constructor(agentId?: any);
+    init(agentId: any): Promise<void>;
+    ready(maxWait?: number): Promise<unknown>;
+    get(key: string): any;
+    set(key: string, value: any): void;
+    has(key: string): any;
+}

package/dist/types/subsystems/AgentManager/Component.service/ComponentConnector.d.ts

@@ -0,0 +1,17 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+export interface IComponentRequest {
+    register(componentName: string, componentInstance: any): Promise<void>;
+    get(componentName: string): Promise<any>;
+    getAll(): Promise<any>;
+}
+export declare abstract class ComponentConnector extends SecureConnector {
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract register(acRequest: AccessRequest, componentName: string, componentInstance: any): Promise<void>;
+    protected abstract get(acRequest: AccessRequest, componentName: string): Promise<any>;
+    protected abstract getAll(acRequest: AccessRequest): Promise<any>;
+    requester(candidate: AccessCandidate): IComponentRequest;
+}

package/dist/types/subsystems/AgentManager/Component.service/connectors/LocalComponentConnector.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 { ComponentConnector } from '../ComponentConnector';
+export declare class LocalComponentConnector extends ComponentConnector {
+    name: string;
+    private components;
+    constructor();
+    init(): Promise<void>;
+    protected register(acRequest: AccessRequest, componentName: string, componentInstance: any): Promise<void>;
+    protected get(acRequest: AccessRequest, componentName: string): Promise<any>;
+    protected getAll(acRequest: AccessRequest): Promise<any>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+}

package/dist/types/subsystems/AgentManager/Component.service/index.d.ts

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

package/dist/types/subsystems/AgentManager/EmbodimentSettings.class.d.ts

@@ -0,0 +1,8 @@
+export declare class EmbodimentSettings {
+    private _embodiments;
+    private _ready;
+    constructor(agentId: any);
+    init(agentId: any): Promise<void>;
+    ready(maxWait?: number): Promise<unknown>;
+    get(embodimentType: string, key?: string): any;
+}

package/dist/types/subsystems/AgentManager/ForkedAgent.class.d.ts

@@ -0,0 +1,15 @@
+import { IAgent } from '@sre/types/Agent.types';
+/**
+ * This class creates a forked agent from a parent agent branch, it allows running a sub-branch of the parent agent asynchrounously by providing a separate agent context
+ * We use composition instead of inheritance to avoid circular dependencies between Agent and ForkedAgent
+ */
+export declare class ForkedAgent {
+    private parent;
+    agent: IAgent;
+    get agentRequest(): any;
+    get components(): any;
+    get agentRuntime(): any;
+    get jobID(): any;
+    constructor(parent: IAgent, componentId: string);
+    process(path: string, input: any): Promise<any>;
+}

package/dist/types/subsystems/AgentManager/OSResourceMonitor.d.ts

@@ -0,0 +1,2 @@
+declare const OSResourceMonitor: any;
+export { OSResourceMonitor };

package/dist/types/subsystems/ComputeManager/Code.service/CodeConnector.d.ts

@@ -0,0 +1,58 @@
+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 { IAccessCandidate } from '@sre/types/ACL.types';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+export interface CodeInput {
+    code: string;
+    dependencies?: string;
+    files?: Record<string, string>;
+    inputs?: Record<string, any>;
+}
+export interface CodeConfig {
+    runtime: string;
+    timeout?: number;
+    memoryLimit?: number;
+    environment?: Record<string, string>;
+    platformConfig?: Record<string, any>;
+}
+export interface CodeExecutionResult {
+    output: any;
+    executionTime: number;
+    logs?: string[];
+    errors?: string[];
+    success: boolean;
+}
+export interface CodePreparationResult {
+    prepared: boolean;
+    errors?: string[];
+    warnings?: string[];
+    metadata?: Record<string, any>;
+}
+export interface CodeDeployment {
+    id: string;
+    status: 'deploying' | 'ready' | 'failed';
+    runtime: string;
+    createdAt: Date;
+    lastUsed?: Date;
+}
+export interface ICodeRequest {
+    prepare(input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    deploy(deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    execute(input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult>;
+    executeDeployment(deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult>;
+    listDeployments(): Promise<CodeDeployment[]>;
+    getDeployment(deploymentId: string): Promise<CodeDeployment | null>;
+    deleteDeployment(deploymentId: string): Promise<void>;
+}
+export declare abstract class CodeConnector extends SecureConnector {
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract prepare(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    protected abstract deploy(acRequest: AccessRequest, deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    protected abstract execute(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult>;
+    protected abstract executeDeployment(acRequest: AccessRequest, deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult>;
+    protected abstract listDeployments(acRequest: AccessRequest): Promise<CodeDeployment[]>;
+    protected abstract getDeployment(acRequest: AccessRequest, deploymentId: string): Promise<CodeDeployment | null>;
+    protected abstract deleteDeployment(acRequest: AccessRequest, deploymentId: string): Promise<void>;
+    requester(candidate: AccessCandidate): ICodeRequest;
+}

package/dist/types/subsystems/ComputeManager/Code.service/connectors/AWSLambdaCode.class.d.ts

@@ -0,0 +1,15 @@
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { CodeConfig, CodePreparationResult, CodeConnector, CodeInput, CodeDeployment, CodeExecutionResult } from '../CodeConnector';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+export declare class AWSLambdaCode extends CodeConnector {
+    name: string;
+    prepare(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult>;
+    deploy(acRequest: AccessRequest, deploymentId: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment>;
+    execute(acRequest: AccessRequest, input: CodeInput, config: CodeConfig): Promise<CodeExecutionResult>;
+    executeDeployment(acRequest: AccessRequest, deploymentId: string, inputs: Record<string, any>): Promise<CodeExecutionResult>;
+    listDeployments(acRequest: AccessRequest): Promise<CodeDeployment[]>;
+    getDeployment(acRequest: AccessRequest, deploymentId: string): Promise<CodeDeployment | null>;
+    deleteDeployment(acRequest: AccessRequest, deploymentId: string): Promise<void>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+}

package/dist/types/subsystems/ComputeManager/Code.service/index.d.ts

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

package/dist/types/subsystems/IO/CLI.service/CLIConnector.d.ts

@@ -0,0 +1,21 @@
+import { Connector } from '@sre/Core/Connector.class';
+export declare class CLIConnector extends Connector {
+    protected _settings?: any;
+    name: string;
+    params: any;
+    constructor(_settings?: any);
+    /**
+     * Parses the command line arguments, and returns the parsed arguments object
+     * if args is provided, it will only parse the provided args
+     * @param argv The command line arguments, usually process.argv
+     * @param args The arguments to parse
+     * @returns
+     */
+    parse(argv: string[], args?: string | string[]): Record<string, any>;
+    /**
+     * Get the parsed arguments as an object
+     * @param args The arguments to get
+     * @returns
+     */
+    get(args: string | string[]): {};
+}

package/dist/types/subsystems/IO/CLI.service/index.d.ts

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

package/dist/types/subsystems/IO/Log.service/LogConnector.d.ts

@@ -0,0 +1,17 @@
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+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 { AgentCallLog } from '@sre/types/AgentLogger.types';
+export interface ILogRequest {
+    log(logData: AgentCallLog, callId?: string): Promise<any>;
+    logTask(tasks: number, isUsingTestDomain: boolean): Promise<void>;
+}
+export declare abstract class LogConnector extends SecureConnector {
+    abstract id: string;
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    requester(candidate: AccessCandidate): ILogRequest;
+    protected abstract log(acRequest: AccessRequest, logData: AgentCallLog, callId?: string): Promise<any>;
+    protected abstract logTask(acRequest: AccessRequest, tasks: number, isUsingTestDomain: boolean): Promise<void>;
+}

package/dist/types/subsystems/IO/Log.service/connectors/ConsoleLog.class.d.ts

@@ -0,0 +1,12 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { LogConnector } from '../LogConnector';
+import { AgentCallLog } from '@sre/types/AgentLogger.types';
+export declare class ConsoleLog extends LogConnector {
+    id: string;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected log(acRequest: AccessRequest, logData: AgentCallLog, callId?: string): Promise<any>;
+    protected logTask(acRequest: AccessRequest, tasks: number, isUsingTestDomain: boolean): Promise<void>;
+    name: string;
+}

package/dist/types/subsystems/IO/Log.service/index.d.ts

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

package/dist/types/subsystems/IO/NKV.service/NKVConnector.d.ts

@@ -0,0 +1,33 @@
+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';
+import { StorageData } from '@sre/types/Storage.types';
+export interface INKVRequest {
+    get(namespace: string, key: string): Promise<StorageData>;
+    set(namespace: string, key: string, value: StorageData): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    exists(namespace: string, key: string): Promise<boolean>;
+    deleteAll(namespace: string): Promise<void>;
+    list(namespace: string): Promise<{
+        key: string;
+        data: StorageData;
+    }[]>;
+}
+/**
+ * NKV = Namespace-Key-Value Connector
+ */
+export declare abstract class NKVConnector extends SecureConnector {
+    requester(candidate: AccessCandidate): INKVRequest;
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract get(acRequest: AccessRequest, namespace: string, key: string): Promise<StorageData>;
+    protected abstract set(acRequest: AccessRequest, namespace: string, key: string, value: StorageData): Promise<void>;
+    protected abstract delete(acRequest: AccessRequest, namespace: string, key: string): Promise<void>;
+    protected abstract exists(acRequest: AccessRequest, namespace: string, key: string): Promise<boolean>;
+    protected abstract deleteAll(acRequest: AccessRequest, namespace: string): Promise<void>;
+    protected abstract list(acRequest: AccessRequest, namespace: string): Promise<{
+        key: string;
+        data: StorageData;
+    }[]>;
+}

package/dist/types/subsystems/IO/NKV.service/connectors/NKVRAM.class.d.ts

@@ -0,0 +1,43 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { NKVConnector } from '../NKVConnector';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { StorageData } from '@sre/types/Storage.types';
+export declare class NKVRAM extends NKVConnector {
+    protected _settings?: any;
+    name: string;
+    private storage;
+    private namespaces;
+    private accountConnector;
+    private cacheConnector;
+    constructor(_settings?: any);
+    key(...parts: string[]): string;
+    mdKey(...parts: string[]): string;
+    protected get(acRequest: AccessRequest, namespace: string, key: string): Promise<StorageData>;
+    protected set(acRequest: AccessRequest, namespace: string, key: string, value: any): Promise<void>;
+    protected delete(acRequest: AccessRequest, namespace: string, key: string): Promise<void>;
+    protected exists(acRequest: AccessRequest, namespace: string, key: string): Promise<boolean>;
+    list(acRequest: AccessRequest, namespace: string): Promise<{
+        key: string;
+        data: StorageData;
+    }[]>;
+    deleteAll(acRequest: AccessRequest, namespace: string): Promise<void>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    /**
+     * Get all keys matching a prefix (for internal use)
+     */
+    private getKeysByPrefix;
+    /**
+     * Clear all data (useful for testing)
+     */
+    clearAll(): void;
+    /**
+     * Get storage statistics
+     */
+    getStats(): {
+        totalKeys: number;
+        totalNamespaces: number;
+    };
+    static NamespaceAccessControl(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+    static Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+}

package/dist/types/subsystems/IO/NKV.service/connectors/NKVRedis.class.d.ts

@@ -0,0 +1,27 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { NKVConnector } from '../NKVConnector';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { StorageData } from '@sre/types/Storage.types';
+export declare class NKVRedis extends NKVConnector {
+    protected _settings?: any;
+    name: string;
+    private redisCacheConnector;
+    private accountConnector;
+    constructor(_settings?: any);
+    key(...parts: string[]): string;
+    mdKey(...parts: string[]): string;
+    protected get(acRequest: AccessRequest, namespace: string, key: string): Promise<StorageData>;
+    protected set(acRequest: AccessRequest, namespace: string, key: string, value: any): Promise<void>;
+    protected delete(acRequest: AccessRequest, namespace: string, key: string): Promise<void>;
+    protected exists(acRequest: AccessRequest, namespace: string, key: string): Promise<boolean>;
+    list(acRequest: AccessRequest, namespace: string): Promise<{
+        key: string;
+        data: StorageData;
+    }[]>;
+    deleteAll(acRequest: AccessRequest, namespace: string): Promise<void>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    private fetchKeysByPrefix;
+    static NamespaceAccessControl(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+    static Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+}

package/dist/types/subsystems/IO/NKV.service/index.d.ts

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

package/dist/types/subsystems/IO/Router.service/RouterConnector.d.ts

@@ -0,0 +1,11 @@
+import { Connector } from '@sre/Core/Connector.class';
+export type GenericRequestHandler = (...args: any[]) => void | Promise<void>;
+export declare abstract class RouterConnector extends Connector {
+    abstract baseUrl: string;
+    abstract get(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract post(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract put(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract delete(path: string, ...handlers: GenericRequestHandler[]): this;
+    abstract useFn(...handlers: GenericRequestHandler[]): this;
+    abstract use(path: string, ...handlers: GenericRequestHandler[]): this;
+}

package/dist/types/subsystems/IO/Router.service/connectors/ExpressRouter.class.d.ts

@@ -0,0 +1,21 @@
+import { Router } from 'express';
+import { RouterConnector, GenericRequestHandler } from '../RouterConnector';
+export declare class ExpressRouter extends RouterConnector {
+    protected _settings?: {
+        router: Router;
+        baseUrl: string;
+    };
+    private router;
+    baseUrl: string;
+    constructor(_settings?: {
+        router: Router;
+        baseUrl: string;
+    });
+    get(path: string, ...handlers: GenericRequestHandler[]): this;
+    post(path: string, ...handlers: GenericRequestHandler[]): this;
+    put(path: string, ...handlers: GenericRequestHandler[]): this;
+    delete(path: string, ...handlers: GenericRequestHandler[]): this;
+    useFn(...handlers: GenericRequestHandler[]): this;
+    use(path: string, ...handlers: GenericRequestHandler[]): this;
+    getRouter(): Router;
+}

package/dist/types/subsystems/IO/Router.service/connectors/NullRouter.class.d.ts

@@ -0,0 +1,12 @@
+import { RouterConnector, GenericRequestHandler } from '../RouterConnector';
+export declare class NullRouter extends RouterConnector {
+    protected _settings?: any;
+    baseUrl: string;
+    constructor(_settings?: any);
+    get(path: string, ...handlers: GenericRequestHandler[]): this;
+    post(path: string, ...handlers: GenericRequestHandler[]): this;
+    put(path: string, ...handlers: GenericRequestHandler[]): this;
+    delete(path: string, ...handlers: GenericRequestHandler[]): this;
+    useFn(...handlers: GenericRequestHandler[]): this;
+    use(path: string, ...handlers: GenericRequestHandler[]): this;
+}

package/dist/types/subsystems/IO/Router.service/index.d.ts

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

package/dist/types/subsystems/IO/Storage.service/SmythFS.class.d.ts

@@ -0,0 +1,49 @@
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { StorageMetadata } from '@sre/types/Storage.types';
+import { StorageConnector } from './StorageConnector';
+import { CacheConnector } from '@sre/MemoryManager/Cache.service/CacheConnector';
+export type TSmythFSURI = {
+    hash: string;
+    team: string;
+    path: string;
+};
+export declare class SmythFS {
+    private storage;
+    private cache;
+    private hash;
+    static instances: any;
+    private static generateInstanceHash;
+    static get Instance(): SmythFS;
+    static getInstance(storageProvider?: string | StorageConnector, cacheProvider?: string | CacheConnector): SmythFS;
+    private constructor();
+    getBaseUri(candidate: IAccessCandidate): string;
+    /**
+     * Reads a resource from smyth file system
+     * @param uri smythfs:// uri
+     * @param candidate
+     * @returns
+     */
+    read(uri: string, candidate?: IAccessCandidate): Promise<Buffer>;
+    write(uri: string, data: any, candidate?: IAccessCandidate, metadata?: StorageMetadata, ttl?: number): Promise<void>;
+    delete(uri: string, candidate?: IAccessCandidate): Promise<void>;
+    exists(uri: string, candidate?: IAccessCandidate): Promise<boolean>;
+    genTempUrl(uri: string, candidate?: IAccessCandidate, ttlSeconds?: number): Promise<string>;
+    destroyTempUrl(url: string, { delResource }?: {
+        delResource: boolean;
+    }): Promise<void>;
+    serveTempContent(req: any, res: any): Promise<void>;
+    /**
+     * Generates a public url for the resource
+     * @param uri
+     * @param candidate
+     * @returns
+     */
+    genResourceUrl(uri: string, candidate?: IAccessCandidate): Promise<string>;
+    destroyResourceUrl(url: string, { delResource }?: {
+        delResource: boolean;
+    }): Promise<void>;
+    serveResource(req: any, res: any): Promise<void>;
+    private URIParser;
+    private CaseSensitiveURL;
+    private toBuffer;
+}

package/dist/types/subsystems/IO/Storage.service/StorageConnector.d.ts

@@ -0,0 +1,30 @@
+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, IACL } from '@sre/types/ACL.types';
+import { StorageData, StorageMetadata } from '@sre/types/Storage.types';
+export interface IStorageRequest {
+    read(resourceId: string): Promise<StorageData>;
+    write(resourceId: string, value: StorageData, acl?: IACL, metadata?: StorageMetadata): Promise<void>;
+    delete(resourceId: string): Promise<void>;
+    exists(resourceId: string): Promise<boolean>;
+    getMetadata(resourceId: string): Promise<StorageMetadata | undefined>;
+    setMetadata(resourceId: string, metadata: StorageMetadata): Promise<void>;
+    getACL(resourceId: string): Promise<ACL | undefined>;
+    setACL(resourceId: string, acl: IACL): Promise<void>;
+    expire(resourceId: string, ttl: number): Promise<void>;
+}
+export declare abstract class StorageConnector extends SecureConnector {
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract read(acRequest: AccessRequest, resourceId: string): Promise<StorageData>;
+    protected abstract write(acRequest: AccessRequest, resourceId: string, value: StorageData, acl?: IACL, metadata?: StorageMetadata): Promise<void>;
+    protected abstract delete(acRequest: AccessRequest, resourceId: string): Promise<void>;
+    protected abstract exists(acRequest: AccessRequest, resourceId: string): Promise<boolean>;
+    protected abstract getMetadata(acRequest: AccessRequest, resourceId: string): Promise<StorageMetadata | undefined>;
+    protected abstract setMetadata(acRequest: AccessRequest, resourceId: string, metadata: StorageMetadata): Promise<void>;
+    protected abstract getACL(acRequest: AccessRequest, resourceId: string): Promise<ACL | undefined>;
+    protected abstract setACL(acRequest: AccessRequest, resourceId: string, acl: IACL): Promise<void>;
+    protected abstract expire(acRequest: AccessRequest, resourceId: string, ttl: number): Promise<void>;
+    requester(candidate: AccessCandidate): IStorageRequest;
+}