@smythos/sre 1.5.0

package/dist/types/subsystems/LLMManager/LLM.service/connectors/Anthropic.class.d.ts

@@ -0,0 +1,68 @@
+import EventEmitter from 'events';
+import Anthropic from '@anthropic-ai/sdk';
+import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TAnthropicRequestBody } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+export declare class AnthropicConnector extends LLMConnector {
+    name: string;
+    private validImageMimeTypes;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<TAnthropicRequestBody>;
+    protected reportUsage(usage: Anthropic.Messages.Usage & {
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+    }, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: {
+            name: string;
+            description: string;
+            input_schema: {
+                type: "object";
+                properties: Record<string, unknown>;
+                required: string[];
+            };
+        }[];
+    } | {
+        tools?: undefined;
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock & {
+            thinkingBlocks?: {
+                type: string;
+                thinking: string;
+            }[];
+        };
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: any): any;
+    private prepareBody;
+    private prepareBodyForThinkingRequest;
+    private prepareMessages;
+    private prepareSystemPrompt;
+    /**
+     * Determines if thinking mode should be used based on model capabilities and parameters.
+     */
+    private shouldUseThinkingMode;
+    private getValidImageFiles;
+    private getImageData;
+}

package/dist/types/subsystems/LLMManager/LLM.service/connectors/Bedrock.class.d.ts

@@ -0,0 +1,46 @@
+import { ConverseCommandInput, TokenUsage } from '@aws-sdk/client-bedrock-runtime';
+import EventEmitter from 'events';
+import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+export declare class BedrockConnector extends LLMConnector {
+    name: string;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<ConverseCommandInput>;
+    protected reportUsage(usage: TokenUsage & {
+        cacheReadInputTokenCount: number;
+        cacheWriteInputTokenCount: number;
+    }, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: any[];
+        toolChoice: string;
+    } | {
+        tools?: undefined;
+        toolChoice?: undefined;
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[];
+}

package/dist/types/subsystems/LLMManager/LLM.service/connectors/Echo.class.d.ts

@@ -0,0 +1,18 @@
+import { LLMConnector } from '../LLMConnector';
+import EventEmitter from 'events';
+import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMParams } from '@sre/types/LLM.types';
+export declare class EchoConnector extends LLMConnector {
+    name: string;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<any>;
+    enhancePrompt(prompt: string, config: any): string;
+    postProcess(response: any): any;
+    protected reportUsage(usage: any, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): void;
+}

package/dist/types/subsystems/LLMManager/LLM.service/connectors/GoogleAI.class.d.ts

@@ -0,0 +1,57 @@
+import EventEmitter from 'events';
+import { UsageMetadata } from '@google/generative-ai';
+import { TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, APIKeySource, TLLMParams, ILLMRequestFuncParams, TLLMChatResponse, TGoogleAIRequestBody } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+type UsageMetadataWithThoughtsToken = UsageMetadata & {
+    thoughtsTokenCount: number;
+};
+export declare class GoogleAIConnector extends LLMConnector {
+    name: string;
+    private validMimeTypes;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<any>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<TGoogleAIRequestBody>;
+    protected reportUsage(usage: UsageMetadataWithThoughtsToken, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: any;
+        output_tokens: number;
+        input_tokens_audio: any;
+        input_tokens_cache_read: number;
+        input_tokens_cache_write: number;
+        reasoning_tokens: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+        tier: string;
+    };
+    formatToolsConfig({ toolDefinitions, toolChoice }: {
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: any;
+        toolChoice: {
+            type: string;
+        };
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[];
+    private prepareMessages;
+    private prepareMessagesWithFiles;
+    private prepareMessagesWithTools;
+    private prepareMessagesWithTextQuery;
+    private sanitizeFunctionName;
+    private uploadFile;
+    private getValidFiles;
+    private getFileData;
+}
+export {};

package/dist/types/subsystems/LLMManager/LLM.service/connectors/Groq.class.d.ts

@@ -0,0 +1,55 @@
+import Groq from 'groq-sdk';
+import EventEmitter from 'events';
+import { TLLMMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMParams } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+type ChatCompletionCreateParams = {
+    model: string;
+    messages: any;
+    max_tokens?: number;
+    temperature?: number;
+    stop?: string[];
+    top_p?: number;
+    tools?: any;
+    tool_choice?: string;
+    stream?: boolean;
+};
+export declare class GroqConnector extends LLMConnector {
+    name: string;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionCreateParams>;
+    protected reportUsage(usage: Groq.Completions.CompletionUsage & {
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+    }, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: any[];
+        tool_choice: string;
+    } | {
+        tools?: undefined;
+        tool_choice?: undefined;
+    };
+    getConsistentMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[];
+}
+export {};

package/dist/types/subsystems/LLMManager/LLM.service/connectors/OpenAI.class.d.ts

@@ -0,0 +1,92 @@
+import EventEmitter from 'events';
+import OpenAI from 'openai';
+import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, TLLMMessageRole, APIKeySource, ILLMRequestFuncParams, TOpenAIRequestBody, TLLMChatResponse } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+export declare class OpenAIConnector extends LLMConnector {
+    name: string;
+    private validImageMimeTypes;
+    private validDocumentMimeTypes;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected imageGenRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<OpenAI.ImagesResponse>;
+    protected imageEditRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<OpenAI.ImagesResponse>;
+    private processImageData;
+    private getValidDocumentFiles;
+    private processDocumentData;
+    protected reqBodyAdapter(params: TLLMParams): Promise<TOpenAIRequestBody>;
+    protected reportUsage(usage: OpenAI.Completions.CompletionUsage & {
+        input_tokens?: number;
+        output_tokens?: number;
+        input_tokens_details?: {
+            cached_tokens?: number;
+        };
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+        cost?: number;
+    }, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        cost: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: OpenAI.Chat.Completions.ChatCompletionTool[];
+        tool_choice: string;
+    } | {
+        tools?: undefined;
+        tool_choice?: undefined;
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: any): {
+        role: TLLMMessageRole;
+        content?: string | {
+            text: string;
+        }[] | Array<import("@anthropic-ai/sdk/resources").TextBlockParam | import("@anthropic-ai/sdk/resources").ImageBlockParam | import("@anthropic-ai/sdk/resources").ToolUseBlockParam | import("@anthropic-ai/sdk/resources").ToolResultBlockParam>;
+        parts?: {
+            text?: string;
+            functionCall?: {
+                name: string;
+                args: string;
+            };
+            functionResponse?: {
+                name: string;
+                response: {
+                    name: string;
+                    content: string;
+                };
+            };
+        }[];
+        tool_calls?: ToolData[];
+    }[];
+    private getValidImageFiles;
+    private getImageData;
+    private getDocumentData;
+    private getWebSearchTool;
+    private validateTokenLimit;
+    private getProvider;
+    private prepareBodyForWebSearchRequest;
+    private prepareBodyForImageGenRequest;
+    private prepareBodyForImageEditRequest;
+    private prepareBody;
+    private prepareMessages;
+}

package/dist/types/subsystems/LLMManager/LLM.service/connectors/Perplexity.class.d.ts

@@ -0,0 +1,86 @@
+import EventEmitter from 'events';
+import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, TLLMMessageRole, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+type ChatCompletionParams = {
+    model: string;
+    messages: any[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    response_format?: {
+        type: string;
+    };
+};
+type TUsage = {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
+    reasoning_tokens?: number;
+};
+export declare class PerplexityConnector extends LLMConnector {
+    name: string;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionParams>;
+    protected reportUsage(usage: TUsage, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        reasoning_tokens: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: any[];
+        tool_choice: string;
+    } | {
+        tools?: undefined;
+        tool_choice?: undefined;
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: any): {
+        role: TLLMMessageRole;
+        content?: string | {
+            text: string;
+        }[] | Array<import("@anthropic-ai/sdk/resources").TextBlockParam | import("@anthropic-ai/sdk/resources").ImageBlockParam | import("@anthropic-ai/sdk/resources").ToolUseBlockParam | import("@anthropic-ai/sdk/resources").ToolResultBlockParam>;
+        parts?: {
+            text?: string;
+            functionCall?: {
+                name: string;
+                args: string;
+            };
+            functionResponse?: {
+                name: string;
+                response: {
+                    name: string;
+                    content: string;
+                };
+            };
+        }[];
+        tool_calls?: ToolData[];
+    }[];
+}
+export {};

package/dist/types/subsystems/LLMManager/LLM.service/connectors/VertexAI.class.d.ts

@@ -0,0 +1,38 @@
+import { type UsageMetadata } from '@google-cloud/vertexai';
+import EventEmitter from 'events';
+import { TLLMParams, APIKeySource, ILLMRequestFuncParams, TGoogleAIRequestBody } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+export declare class VertexAIConnector extends LLMConnector {
+    name: string;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<any>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<TGoogleAIRequestBody>;
+    protected reportUsage(usage: UsageMetadata & {
+        cachedContentTokenCount?: number;
+    }, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_read: number;
+        input_tokens_cache_write: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): void;
+    getConsistentMessages(messages: any): {
+        role: import("@sre/types/LLM.types").TLLMMessageRole;
+        parts: any[];
+    }[];
+}

package/dist/types/subsystems/LLMManager/LLM.service/index.d.ts

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

package/dist/types/subsystems/LLMManager/ModelsProvider.service/ModelsProviderConnector.d.ts

@@ -0,0 +1,36 @@
+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 { IAccessCandidate } from '@sre/types/ACL.types';
+import { TCustomLLMModel, TLLMModel, TLLMModelsList } from '@sre/types/LLM.types';
+import { LocalCache } from '@sre/helpers/LocalCache.helper';
+export interface IModelsProviderRequest {
+    getModels(): Promise<any>;
+    getMaxContextTokens(model: string, hasAPIKey?: boolean): Promise<number>;
+    addModels(models: TLLMModelsList): Promise<void>;
+    getModelInfo(model: string | TLLMModel | TCustomLLMModel, hasAPIKey?: boolean): Promise<TLLMModel>;
+    getModelId(model: string | TLLMModel | TCustomLLMModel): Promise<string>;
+    getProvider(model: string | TLLMModel | TCustomLLMModel): Promise<string>;
+    isStandardLLM(model: string | TLLMModel | TCustomLLMModel): Promise<boolean>;
+    adjustMaxCompletionTokens(model: string | TLLMModel | TCustomLLMModel, maxCompletionTokens: number, hasAPIKey?: boolean): Promise<number>;
+    getMaxContextTokens(model: string | TLLMModel | TCustomLLMModel, hasAPIKey?: boolean): Promise<number>;
+    getMaxCompletionTokens(model: string | TLLMModel | TCustomLLMModel, hasAPIKey?: boolean): Promise<number>;
+    validateTokensLimit({ model, promptTokens, completionTokens, hasAPIKey, }: {
+        model: string | TLLMModel | TCustomLLMModel;
+        promptTokens: number;
+        completionTokens: number;
+        hasAPIKey?: boolean;
+    }): Promise<void>;
+}
+export declare abstract class ModelsProviderConnector extends SecureConnector {
+    protected static localCache: LocalCache<unknown, unknown>;
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    abstract getModels(acRequest: AccessRequest): Promise<TLLMModelsList>;
+    abstract addModels(acRequest: AccessRequest, models: TLLMModelsList): Promise<void>;
+    requester(candidate: AccessCandidate): IModelsProviderRequest;
+    protected getModelInfo(acRequest: AccessRequest, models: TLLMModelsList, model: string | TLLMModel | TCustomLLMModel, hasAPIKey?: boolean): Promise<TLLMModel>;
+    protected getModelId(acRequest: AccessRequest, models: TLLMModelsList, model: string | TLLMModel | TCustomLLMModel): Promise<string>;
+    protected getProvider(acRequest: AccessRequest, models: TLLMModelsList, model: string | TLLMModel | TCustomLLMModel): Promise<string>;
+    protected getCustomModels(candidate: IAccessCandidate): Promise<Record<string, any>>;
+}

package/dist/types/subsystems/LLMManager/ModelsProvider.service/connectors/SmythModelsProvider.class.d.ts

@@ -0,0 +1,39 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ModelsProviderConnector } from '../ModelsProviderConnector';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { TLLMModelsList } from '@sre/types/LLM.types';
+type SmythModelsProviderConfig = {
+    /**
+     * The models to be used.
+     *
+     * If a string is provided, it will be used as the directory name to load the models from.
+     * If a TLLMModelsList is provided, it will be used as the models to be used.
+     *
+     */
+    models?: string | TLLMModelsList;
+    /**
+     * The mode to be used.
+     *
+     * If 'append' is used, the models will be appended to the existing models.
+     * If 'replace' is used, the existing models will be replaced with the new models.
+     */
+    mode?: 'merge' | 'replace';
+};
+export declare class SmythModelsProvider extends ModelsProviderConnector {
+    protected _settings?: SmythModelsProviderConfig;
+    name: string;
+    private models;
+    constructor(_settings?: SmythModelsProviderConfig);
+    start(): Promise<void>;
+    addModels(acRequest: AccessRequest, models: TLLMModelsList): Promise<void>;
+    getModels(acRequest: AccessRequest): Promise<any>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    private reindexModels;
+    private scanDirectoryForModels;
+    private getValidModels;
+    private isValidSingleModel;
+    private isValidModel;
+    private initDirWatcher;
+}
+export {};

package/dist/types/subsystems/LLMManager/ModelsProvider.service/index.d.ts

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