@smythos/sre 1.6.0 → 1.6.8

package/dist/types/Components/Triggers/GmailTrigger.class.d.ts

@@ -1,13 +0,0 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Trigger } from './Trigger.class';
-export declare class GmailTrigger extends Trigger {
-    init(): void;
-    process(input: any, config: any, agent: Agent): Promise<{
-        Payload: {};
-        Result: any;
-        _temp_result: any;
-        _error: any;
-        _in_progress: boolean;
-        _debug: string;
-    }>;
-}

package/dist/types/Components/Triggers/Trigger.class.d.ts

@@ -1,3 +0,0 @@
-import { Component } from '../Component.class';
-export declare class Trigger extends Component {
-}

package/dist/types/helpers/AIPerformanceAnalyzer.helper.d.ts

@@ -1,45 +0,0 @@
-import { AIComponentMetrics, AIAgentPerformanceReport, AIPerformanceBottleneck } from '@sre/types/Performance.types';
-/**
- * Advanced AI Performance Analyzer
- */
-export declare class AIPerformanceAnalyzer {
-    private behaviorAnalyzer;
-    private logger;
-    /**
-     * Generate comprehensive AI agent performance report
-     */
-    analyzeAgentPerformance(agentId: string, agentName: string, metrics: AIComponentMetrics[], timeWindow?: {
-        start: number;
-        end: number;
-    }): Promise<AIAgentPerformanceReport>;
-    /**
-     * Real-time bottleneck detection
-     */
-    detectRealTimeBottleneck(metric: AIComponentMetrics): Promise<AIPerformanceBottleneck | null>;
-    private calculateSummaryStats;
-    private analyzeComponentPerformance;
-    private detectBottlenecks;
-    private generateOptimizationRecommendations;
-    private analyzeAISpecificPatterns;
-    private analyzeTrends;
-    private calculatePerformanceGrade;
-    private findCriticalPath;
-    private findParallelizationOpportunities;
-    private classifyBottleneckType;
-    private generateBottleneckDescription;
-    private identifyRootCause;
-    private calculatePerformanceImpact;
-    private generateFixSuggestion;
-    private assessImplementationComplexity;
-    private estimateResolutionTime;
-    private estimatePerformanceGain;
-    private estimateCostReduction;
-    private getPrerequisites;
-    private analyzeComponentSequences;
-    private findDuplicatePrompts;
-    private findModelDowngradeOpportunities;
-    private findCachingOpportunities;
-    private findBatchingOpportunities;
-    private calculateDataFlowEfficiency;
-    private calculateInformationLossRate;
-}

package/dist/types/helpers/AIPerformanceCollector.helper.d.ts

@@ -1,111 +0,0 @@
-import { AIComponentMetrics, AIPerformanceConfig, MetricWindow } from '@sre/types/Performance.types';
-import { EventEmitter } from 'events';
-/**
- * Zero-overhead performance timer with AI-specific tracking
- */
-export declare class AIPerformanceTimer {
-    private componentName;
-    private agentId;
-    private configHash;
-    private startTime;
-    private startMemory;
-    private checkpoints;
-    private llmMetrics;
-    constructor(componentName: string, agentId: string, configHash: string);
-    /**
-     * Add checkpoint for detailed timing analysis
-     */
-    checkpoint(name: string): void;
-    /**
-     * Track LLM-specific metrics
-     */
-    trackLLM(llmData: {
-        model: string;
-        promptTokens: number;
-        completionTokens: number;
-        estimatedCost: number;
-        contextUtilization?: number;
-        qualityScore?: number;
-    }): void;
-    /**
-     * Complete timing and generate comprehensive metrics
-     */
-    finish(inputData?: any, outputData?: any, success?: boolean, errorType?: string, retryCount?: number): AIComponentMetrics;
-    private calculateDataSize;
-    private calculateComplexityScore;
-    private getObjectComplexity;
-    private calculateMemoryPressure;
-    private estimateCPUUsage;
-}
-/**
- * Main AI Performance Collector - Enterprise-grade monitoring system
- */
-export declare class AIPerformanceCollector extends EventEmitter {
-    private static instance;
-    private metricsBuffer;
-    private config;
-    private logger;
-    private activeTimers;
-    private eventSequence;
-    private batchBuffer;
-    private flushTimer?;
-    private constructor();
-    /**
-     * Get singleton instance with configuration
-     */
-    static getInstance(config?: AIPerformanceConfig): AIPerformanceCollector;
-    /**
-     * Start monitoring a component execution
-     */
-    startComponentExecution(componentName: string, agentId: string, config?: any): AIPerformanceTimer | null;
-    /**
-     * Record completed component execution
-     */
-    recordMetrics(agentId: string, metrics: AIComponentMetrics): void;
-    /**
-     * Get metrics for specific agent within time window
-     */
-    getAgentMetrics(agentId: string, window?: MetricWindow): AIComponentMetrics[];
-    /**
-     * Get aggregated metrics across all agents
-     */
-    getGlobalMetrics(window?: MetricWindow): AIComponentMetrics[];
-    /**
-     * Clear metrics for specific agent
-     */
-    clearAgentMetrics(agentId: string): void;
-    /**
-     * Get current system statistics
-     */
-    getSystemStats(): {
-        activeTimers: number;
-        totalMetrics: number;
-        memoryUsage: number;
-        eventBufferSize: number;
-    };
-    /**
-     * Update configuration at runtime
-     */
-    updateConfig(newConfig: Partial<AIPerformanceConfig>): void;
-    /**
-     * Export metrics for external monitoring systems
-     */
-    exportMetrics(format?: 'json' | 'prometheus' | 'csv'): string;
-    private shouldMonitorComponent;
-    private shouldSample;
-    private generateConfigHash;
-    private emitEvent;
-    private setupFlushTimer;
-    private checkPerformanceThresholds;
-    private formatPrometheusMetrics;
-    private formatCSVMetrics;
-    /**
-     * Graceful shutdown
-     */
-    private flushBatch;
-    shutdown(): Promise<void>;
-}
-/**
- * Default configuration for development
- */
-export declare const DEFAULT_AI_PERFORMANCE_CONFIG: AIPerformanceConfig;

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

@@ -1,211 +0,0 @@
-import { StorageConnector } from '@sre/IO/Storage.service/StorageConnector';
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
-import { StorageData, StorageMetadata } from '@sre/types/Storage.types';
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-export type AzureBlobConfig = {
-    storageAccountName: string;
-    storageAccountAccessKey: string;
-    blobContainerName: string;
-};
-export declare class AzureBlobStorage extends StorageConnector {
-    protected _settings: AzureBlobConfig;
-    name: string;
-    private blobServiceClient;
-    private containerClient;
-    private isInitialized;
-    private initializationPromise;
-    constructor(_settings: AzureBlobConfig);
-    private ensureInitialized;
-    private initialize;
-    /**
-     * Reads a blob's content from the Azure Storage container.
-     * This method fetches the entire blob content into a Buffer. If the specified
-     * blob does not exist, it gracefully returns undefined.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob to be read from the container.
-     * @returns {Promise<StorageData | undefined>} A promise that resolves with the blob's content as a Buffer (`StorageData`), or undefined if the blob is not found.
-     * @throws Throws an error if any other issue occurs during the download process (e.g., network issues, permissions problems).
-     */
-    read(acRequest: AccessRequest, resourceId: string): Promise<StorageData | undefined>;
-    /**
-     * Writes or overwrites a blob in the Azure Storage container.
-     *
-     * This method uploads data to a specified blob. It automatically handles the SmythOS
-     * Access Control List (ACL) by ensuring the writer is made the owner of the object.
-     * Any provided metadata is merged with this ACL and stored with the blob.
-     * If a blob with the same `resourceId` already exists, this operation will completely replace its content and metadata.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob to be written or overwritten.
-     * @param {StorageData} value - The content to be written to the blob, typically a Buffer.
-     * @param {IACL} [acl] - An optional Access Control List to apply to the blob. If not provided, a default ACL is generated.
-     * @param {StorageMetadata} [metadata] - Optional key-value metadata to associate with the blob, including properties like `ContentType`.
-     * @returns {Promise<void>} A promise that resolves when the upload operation is complete.
-     * @throws Throws an error if the upload fails due to network issues, invalid credentials, or other storage-related problems.
-     */
-    write(acRequest: AccessRequest, resourceId: string, value: StorageData, acl?: IACL, metadata?: StorageMetadata): Promise<void>;
-    /**
-     * Deletes a blob from the Azure Storage container.
-     *
-     * This method permanently removes the specified blob. The operation is idempotent,
-     * meaning it will complete successfully without error even if the blob does not
-     * already exist. This is useful for ensuring a resource is gone without needing to
-     * check for its existence first.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob to be deleted.
-     * @returns {Promise<void>} A promise that resolves when the delete operation is complete.
-     * @throws Throws an error if the deletion fails for reasons other than the blob not existing (e.g., network issues, permissions problems).
-     */
-    delete(acRequest: AccessRequest, resourceId: string): Promise<void>;
-    /**
-     * Checks for the existence of a blob in the Azure Storage container.
-     *
-     * This method efficiently verifies if a blob with the specified `resourceId` is
-     * present without downloading its content. It's the most performant way to
-     * check for a blob's presence before performing other operations.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob to check.
-     * @returns {Promise<boolean>} A promise that resolves with `true` if the blob exists, and `false` otherwise.
-     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
-     */
-    exists(acRequest: AccessRequest, resourceId: string): Promise<boolean>;
-    /**
-     * Retrieves the user-defined metadata for a specific blob.
-     *
-     * This method fetches the key-value metadata associated with a blob without
-     * downloading the blob's content. It's an efficient way to read custom
-     * information stored with an object. If the blob is not found, it returns undefined.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob whose metadata is to be retrieved.
-     * @returns {Promise<StorageMetadata | undefined>} A promise that resolves with the blob's metadata object, or undefined if the blob does not exist.
-     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
-     */
-    getMetadata(acRequest: AccessRequest, resourceId: string): Promise<StorageMetadata | undefined>;
-    /**
-     * Sets or updates the user-defined metadata for a specific blob.
-     *
-     * This method applies new metadata to an existing blob. It performs a "merge and
-     * update" operation: it first reads the blob's current metadata, then merges
-     * the provided metadata with it (new values overwrite existing ones).
-     * This operation does not affect the blob's content.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob whose metadata is to be updated.
-     * @param {StorageMetadata} metadata - An object containing the key-value pairs to set. These will be merged with any existing metadata.
-     * @returns {Promise<void>} A promise that resolves when the metadata has been successfully updated.
-     * @throws Throws an error if the blob does not exist, or if the update fails for other reasons (e.g., network issues).
-     */
-    setMetadata(acRequest: AccessRequest, resourceId: string, metadata: StorageMetadata): Promise<void>;
-    /**
-     * Retrieves the Access Control List (ACL) for a specific blob.
-     *
-     * This method fetches the blob's metadata and specifically extracts the
-     * SmythOS-native ACL object. It provides a direct way to inspect the
-     * permissions of a blob without downloading its content.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be retrieved.
-     * @returns {Promise<ACL | undefined>} A promise that resolves with the `ACL` object for the blob. Returns undefined if the blob does not exist or has no ACL.
-     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
-     */
-    getACL(acRequest: AccessRequest, resourceId: string): Promise<ACL | undefined>;
-    /**
-     * Sets or updates the Access Control List (ACL) for a specific blob.
-     *
-     * This method applies a new SmythOS ACL to an existing blob. It reads the blob's
-     * full metadata, replaces the ACL portion, and writes the updated metadata back.
-     * A crucial security feature of this method is that it automatically ensures the
-     * user/agent making the request always retains ownership of the blob.
-     *
-     * @param {AccessRequest} acRequest - The access request object, used to identify the user/agent to ensure they retain ownership.
-     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be updated.
-     * @param {IACL} acl - The new Access Control List object to apply to the blob.
-     * @returns {Promise<void>} A promise that resolves when the ACL has been successfully updated.
-     * @throws Throws an error if the blob does not exist or if the update fails for other reasons.
-     */
-    setACL(acRequest: AccessRequest, resourceId: string, acl: IACL): Promise<void>;
-    /**
-     * Determines the effective Access Control List (ACL) for a given resource.
-     *
-     * This crucial security method is called by the access control system to fetch a
-     * resource's ACL before making an authorization decision. If the resource does
-     * not exist (and thus has no ACL), this method dynamically generates a new ACL
-     * that grants 'Owner' access to the requesting candidate. This is the mechanism
-     * that allows authorized users to create new resources.
-     *
-     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be determined.
-     * @param {IAccessCandidate} candidate - The user or agent attempting to access the resource, used to grant ownership if the resource is new.
-     * @returns {Promise<ACL>} A promise that resolves with the existing ACL object if the blob is found, or a new ACL object granting ownership if the blob does not exist.
-     * @throws Throws an error if there is an unexpected issue fetching the blob's metadata (e.g., network issues).
-     */
-    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
-    /**
-     * Schedules a blob for automatic deletion after a specified time-to-live (TTL).
-     *
-     * This method applies a Blob Index Tag ('deleteAfterDays') to an existing blob.
-     * It does not delete the blob immediately. Instead, it relies on a pre-configured
-     * Lifecycle Management rule on the Azure Storage Account to automatically delete the
-     * blob after the specified number of days.
-     *
-     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
-     * @param {string} resourceId - The unique identifier (name) of the blob to schedule for deletion.
-     * @param {number} ttl - The time-to-live for the blob, in seconds. Must be a positive number.
-     * @returns {Promise<void>} A promise that resolves when the expiration tag has been successfully applied.
-     * @throws Throws an error if the blob does not exist, if the TTL is invalid, or if applying the tag fails.
-     */
-    expire(acRequest: AccessRequest, resourceId: string, ttl: number): Promise<void>;
-    /**
-     * Migrates legacy ACL metadata to the new structured format.
-     *
-     * This internal helper function checks for an outdated ACL format where permissions
-     * were stored in separate keys like `userid`, `teamid`, or `agentid`. If found,
-     * it converts them into the modern, structured `azure-acl` object, granting full
-     * ownership. This ensures seamless backward compatibility with older data.
-     *
-     * @param {Record<string, string>} metadata - The raw metadata object which may contain legacy ACL keys.
-     * @returns {Record<string, any>} The metadata object, with legacy keys converted into a new `azure-acl` property.
-     * @private
-     */
-    private _migrateMetadata;
-    /**
-     * Serializes the internal metadata object into a format compatible with Azure Blob Storage.
-     *
-     * This internal helper prepares the metadata for upload. It converts the `ACL` object
-     * into its serialized string representation and stringifies any other non-string
-     * metadata values. The `ContentType` property is intentionally excluded as it's
-     * handled separately in the blob's HTTP headers.
-     *
-     * @param {Record<string, any>} metadata - The internal metadata object, containing mixed-type values.
-     * @returns {Record<string, string>} A flat key-value object where all values are strings.
-     * @private
-     */
-    private _serializeAzureMetadata;
-    /**
-     * Deserializes a flat metadata object from Azure into the rich internal format.
-     *
-     * This internal helper processes the raw string-based metadata retrieved from a blob.
-     * It reconstructs the `ACL` object from its string representation and parses any
-     * other JSON-stringified values back into their original object/data types. It then
-     * calls the migration helper to ensure backward compatibility with legacy ACL formats.
-     *
-     * @param {Record<string, string>} metadata - The flat, string-only key-value metadata from the Azure SDK.
-     * @returns {Record<string, any>} The rich internal metadata object with complex data types restored.
-     * @private
-     */
-    private _deserializeAzureMetadata;
-    /**
-     * Private helper to fetch and deserialize metadata from Azure.
-     * @private
-     */
-    private _getAzureMetadata;
-    /**
-     * Private helper to serialize and write metadata to Azure.
-     * @private
-     */
-    private _setAzureMetadata;
-}

package/dist/types/subsystems/IO/VectorDB.service/connectors/WeaviateVectorDB.class.d.ts

@@ -1,187 +0,0 @@
-import { ACL } from '@sre/Security/AccessControl/ACL.class';
-import { IAccessCandidate } from '@sre/types/ACL.types';
-import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { VectorDBConnector, DeleteTarget } from '../VectorDBConnector';
-import { DatasourceDto, IStorageVectorDataSource, IVectorDataSourceDto, QueryOptions, VectorsResultData } from '@sre/types/VectorDB.types';
-import { TEmbeddings } from '../embed/BaseEmbedding';
-export type WeaviateConfig = {
-    /**
-     * The Weaviate instance URL
-     */
-    url: string;
-    /**
-     * The Weaviate API key (optional for open source)
-     */
-    apiKey?: string;
-    /**
-     * The class name to use for storing vectors
-     */
-    className?: string;
-    /**
-     * The embeddings model to use
-     */
-    embeddings: TEmbeddings;
-    /**
-     * Additional Weaviate client options
-     */
-    clientOptions?: {
-        timeout?: number;
-        headers?: Record<string, string>;
-    };
-};
-export declare class WeaviateVectorDB extends VectorDBConnector {
-    protected _settings: WeaviateConfig;
-    name: string;
-    id: string;
-    private client;
-    private className;
-    private cache;
-    private accountConnector;
-    private nkvConnector;
-    embedder: any;
-    constructor(_settings: WeaviateConfig);
-    /**
-     * @async
-     * @method getResourceACL
-     * @description Gets the ACL for a specific resource in Weaviate
-     * @param {string} resourceId - The resource identifier
-     * @param {IAccessCandidate} candidate - The access candidate
-     * @returns {Promise<ACL>} The ACL for the resource
-     * @throws {Error} If there's an error retrieving the ACL
-     */
-    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
-    /**
-     * @async
-     * @method getACL
-     * @description Gets the ACL for a specific namespace in Weaviate
-     * @param {AccessCandidate} candidate - The access candidate
-     * @param {string} preparedNs - The prepared namespace name
-     * @returns {Promise<IACL | null>} The ACL for the namespace or null if not found
-     * @throws {Error} If there's an error retrieving the ACL
-     */
-    private getACL;
-    /**
-     * @async
-     * @method createNamespace
-     * @description Creates a namespace in Weaviate by creating a class
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace name
-     * @param {object} metadata - Optional metadata
-     * @returns {Promise<void>}
-     * @throws {Error} If there's an error creating the namespace
-     */
-    protected createNamespace(acRequest: AccessRequest, namespace: string, metadata?: {
-        [key: string]: any;
-    }): Promise<void>;
-    /**
-     * @async
-     * @method deleteNamespace
-     * @description Deletes a namespace by removing the class
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace name
-     * @returns {Promise<void>}
-     * @throws {Error} If there's an error deleting the namespace
-     */
-    protected deleteNamespace(acRequest: AccessRequest, namespace: string): Promise<void>;
-    /**
-     * @async
-     * @method namespaceExists
-     * @description Checks if a namespace exists in Weaviate
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace name
-     * @returns {Promise<boolean>} True if namespace exists
-     * @throws {Error} If there's an error checking namespace existence
-     */
-    protected namespaceExists(acRequest: AccessRequest, namespace: string): Promise<boolean>;
-    /**
-     * @async
-     * @method search
-     * @description Performs vector search in Weaviate
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace to search in
-     * @param {string | number[]} query - The search query (text or vector)
-     * @param {QueryOptions} options - Search options
-     * @returns {Promise<VectorsResultData>} Search results
-     * @throws {Error} If there's an error performing the search
-     */
-    protected search(acRequest: AccessRequest, namespace: string, query: string | number[], options: QueryOptions): Promise<VectorsResultData>;
-    /**
-     * @async
-     * @method insert
-     * @description Inserts vectors into Weaviate
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace to insert into
-     * @param {IVectorDataSourceDto | IVectorDataSourceDto[]} source - The data to insert
-     * @returns {Promise<string[]>} Array of inserted IDs
-     * @throws {Error} If there's an error inserting data
-     */
-    protected insert(acRequest: AccessRequest, namespace: string, source: IVectorDataSourceDto | IVectorDataSourceDto[]): Promise<string[]>;
-    /**
-     * @async
-     * @method delete
-     * @description Deletes vectors from Weaviate
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace to delete from
-     * @param {DeleteTarget} deleteTarget - What to delete
-     * @returns {Promise<void>}
-     * @throws {Error} If there's an error deleting data
-     */
-    protected delete(acRequest: AccessRequest, namespace: string, deleteTarget: DeleteTarget): Promise<void>;
-    /**
-     * @async
-     * @method createDatasource
-     * @description Creates a datasource in Weaviate
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace
-     * @param {DatasourceDto} datasource - The datasource data
-     * @returns {Promise<IStorageVectorDataSource>} The created datasource
-     * @throws {Error} If there's an error creating the datasource
-     */
-    protected createDatasource(acRequest: AccessRequest, namespace: string, datasource: DatasourceDto): Promise<IStorageVectorDataSource>;
-    /**
-     * @async
-     * @method deleteDatasource
-     * @description Deletes a datasource from Weaviate
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace
-     * @param {string} datasourceId - The datasource ID
-     * @returns {Promise<void>}
-     * @throws {Error} If there's an error deleting the datasource
-     */
-    protected deleteDatasource(acRequest: AccessRequest, namespace: string, datasourceId: string): Promise<void>;
-    /**
-     * @async
-     * @method listDatasources
-     * @description Lists all datasources in a namespace
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace
-     * @returns {Promise<IStorageVectorDataSource[]>} Array of datasources
-     * @throws {Error} If there's an error listing datasources
-     */
-    protected listDatasources(acRequest: AccessRequest, namespace: string): Promise<IStorageVectorDataSource[]>;
-    /**
-     * @async
-     * @method getDatasource
-     * @description Gets a specific datasource
-     * @param {AccessRequest} acRequest - The access request
-     * @param {string} namespace - The namespace
-     * @param {string} datasourceId - The datasource ID
-     * @returns {Promise<IStorageVectorDataSource | undefined>} The datasource or undefined
-     * @throws {Error} If there's an error getting the datasource
-     */
-    protected getDatasource(acRequest: AccessRequest, namespace: string, datasourceId: string): Promise<IStorageVectorDataSource | undefined>;
-    /**
-     * @method buildWhereClause
-     * @description Builds a Weaviate where clause from filter options
-     * @param {any} filter - The filter object
-     * @returns {object} Weaviate where clause
-     */
-    private buildWhereClause;
-    /**
-     * @async
-     * @method stop
-     * @description Stops the Weaviate connector
-     * @returns {Promise<void>}
-     */
-    stop(): Promise<void>;
-}

package/dist/types/subsystems/PerformanceManager/Performance.service/PerformanceConnector.d.ts

@@ -1,102 +0,0 @@
-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 { AIComponentMetrics, AIAgentPerformanceReport, AIPerformanceEvent, AIPerformanceConfig, MetricWindow, ComponentBaseline, ExternalMonitoringExport } from '@sre/types/Performance.types';
-/**
- * Performance request interface for secure access
- */
-export interface IPerformanceRequest {
-    /** Store performance metrics for an agent */
-    storeMetrics(metrics: AIComponentMetrics[]): Promise<void>;
-    /** Retrieve metrics within a time window */
-    getMetrics(timeWindow?: MetricWindow): Promise<AIComponentMetrics[]>;
-    /** Generate comprehensive performance report */
-    generateReport(): Promise<AIAgentPerformanceReport>;
-    /** Clear stored metrics */
-    clearMetrics(): Promise<void>;
-    /** Get real-time performance events */
-    getEvents(since?: number): Promise<AIPerformanceEvent[]>;
-    /** Update performance monitoring configuration */
-    updateConfig(config: Partial<AIPerformanceConfig>): Promise<void>;
-    /** Export metrics in various formats */
-    exportMetrics(format: 'json' | 'prometheus' | 'csv'): Promise<string>;
-    /** Get component performance baselines */
-    getBaselines(): Promise<ComponentBaseline[]>;
-    /** Establish baseline for specific component */
-    establishBaseline(componentName: string): Promise<ComponentBaseline>;
-}
-/**
- * Abstract base class for performance connectors
- */
-export declare abstract class PerformanceConnector extends SecureConnector {
-    abstract id: string;
-    /**
-     * Get ACL for performance resources
-     */
-    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
-    /**
-     * Create secure requester interface scoped to access candidate
-     */
-    requester(candidate: AccessCandidate): IPerformanceRequest;
-    /**
-     * Store performance metrics with access control
-     */
-    protected abstract storeMetrics(accessRequest: AccessRequest, metrics: AIComponentMetrics[]): Promise<void>;
-    /**
-     * Retrieve metrics with time window filtering
-     */
-    protected abstract getMetrics(accessRequest: AccessRequest, timeWindow?: MetricWindow): Promise<AIComponentMetrics[]>;
-    /**
-     * Generate comprehensive performance report
-     */
-    protected abstract generateReport(accessRequest: AccessRequest): Promise<AIAgentPerformanceReport>;
-    /**
-     * Clear stored metrics
-     */
-    protected abstract clearMetrics(accessRequest: AccessRequest): Promise<void>;
-    /**
-     * Get performance events
-     */
-    protected abstract getEvents(accessRequest: AccessRequest, since?: number): Promise<AIPerformanceEvent[]>;
-    /**
-     * Update monitoring configuration
-     */
-    protected abstract updateConfig(accessRequest: AccessRequest, config: Partial<AIPerformanceConfig>): Promise<void>;
-    /**
-     * Export metrics in various formats
-     */
-    protected abstract exportMetrics(accessRequest: AccessRequest, format: 'json' | 'prometheus' | 'csv'): Promise<string>;
-    /**
-     * Get component baselines
-     */
-    protected abstract getBaselines(accessRequest: AccessRequest): Promise<ComponentBaseline[]>;
-    /**
-     * Establish baseline for component
-     */
-    protected abstract establishBaseline(accessRequest: AccessRequest, componentName: string): Promise<ComponentBaseline>;
-    /**
-     * Export to external monitoring systems
-     */
-    protected exportToExternal(accessRequest: AccessRequest, exportConfig: ExternalMonitoringExport): Promise<void>;
-    /**
-     * Perform health check on the connector
-     */
-    healthCheck(): Promise<{
-        status: 'healthy' | 'degraded' | 'unhealthy';
-        details: Record<string, any>;
-    }>;
-    /**
-     * Get connector statistics
-     */
-    getStats(): Promise<{
-        totalMetrics: number;
-        agentCount: number;
-        timeRange: {
-            start: number;
-            end: number;
-        };
-        storageSize: number;
-    }>;
-}