@smythos/sre 1.5.0

package/dist/types/Components/ImageGenerator.class.d.ts

@@ -0,0 +1,17 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import Joi from 'joi';
+import { Component } from './Component.class';
+export declare class ImageGenerator extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        _error: string;
+        _debug: string;
+        Output?: undefined;
+    } | {
+        Output: any;
+        _debug: string;
+        _error?: undefined;
+    }>;
+}

package/dist/types/Components/JSONFilter.class.d.ts

@@ -0,0 +1,13 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class JSONFilter extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Output: {};
+        _error: any;
+        _debug: string;
+    }>;
+}

package/dist/types/Components/LLMAssistant.class.d.ts

@@ -0,0 +1,19 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class LLMAssistant extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Response: any;
+    } | {
+        Response: any;
+        _error: string;
+        _debug: string;
+    } | {
+        _error: any;
+        _debug: string;
+        Response?: undefined;
+    }>;
+}

package/dist/types/Components/LogicAND.class.d.ts

@@ -0,0 +1,7 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class LogicAND extends Component {
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+}

package/dist/types/Components/LogicAtLeast.class.d.ts

@@ -0,0 +1,9 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class LogicAtLeast extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+}

package/dist/types/Components/LogicAtMost.class.d.ts

@@ -0,0 +1,9 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class LogicAtMost extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+}

package/dist/types/Components/LogicOR.class.d.ts

@@ -0,0 +1,7 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class LogicOR extends Component {
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+}

package/dist/types/Components/LogicXOR.class.d.ts

@@ -0,0 +1,7 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class LogicXOR extends Component {
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+}

package/dist/types/Components/MCPClient.class.d.ts

@@ -0,0 +1,17 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class MCPClient extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        _error: string;
+        _debug: string;
+        Output?: undefined;
+    } | {
+        Output: any;
+        _debug: string;
+        _error?: undefined;
+    }>;
+}

package/dist/types/Components/PromptGenerator.class.d.ts

@@ -0,0 +1,19 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+export declare class PromptGenerator extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Reply: any;
+    } | {
+        Reply: any;
+        _error: string;
+        _debug: string;
+    } | {
+        _error: any;
+        _debug: string;
+        Reply?: undefined;
+    }>;
+}

package/dist/types/Components/ScrapflyWebScrape.class.d.ts

@@ -0,0 +1,30 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import Joi from 'joi';
+export declare class ScrapflyWebScrape extends Component {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+    scrapeURL(url: any, data: any, key: any): Promise<{
+        content: any;
+        success: boolean;
+        url: any;
+        cost: any;
+        error?: undefined;
+    } | {
+        content: any;
+        success: boolean;
+        error: any;
+        url: any;
+        cost: number;
+    }>;
+    extractUrls(input: any): any[];
+    isValidUrl(urlString: string): boolean;
+    protected reportUsage({ urlsScraped, agentId, teamId, totalCredits, }: {
+        urlsScraped: number;
+        agentId: string;
+        teamId: string;
+        totalCredits: number;
+    }): void;
+}

package/dist/types/Components/TavilyWebSearch.class.d.ts

@@ -0,0 +1,31 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import Joi from 'joi';
+export declare class TavilyWebSearch extends Component {
+    protected schema: {
+        name: string;
+        description: string;
+        inputs: {
+            SearchQuery: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        outputs: {
+            Results: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+    };
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+    protected reportUsage({ agentId, teamId }: {
+        agentId: string;
+        teamId: string;
+    }): void;
+}

package/dist/types/Components/index.d.ts

@@ -0,0 +1,74 @@
+import { Component } from './Component.class';
+import { APIEndpoint } from './APIEndpoint.class';
+import { APIOutput } from './APIOutput.class';
+import { PromptGenerator } from './PromptGenerator.class';
+import { APICall } from './APICall/APICall.class';
+import { FSleep } from './FSleep.class';
+import { FHash } from './FHash.class';
+import { FEncDec } from './FEncDec.class';
+import { FTimestamp } from './FTimestamp.class';
+import { DataSourceLookup } from './DataSourceLookup.class';
+import { DataSourceIndexer } from './DataSourceIndexer.class';
+import { DataSourceCleaner } from './DataSourceCleaner.class';
+import { JSONFilter } from './JSONFilter.class';
+import { LogicAND } from './LogicAND.class';
+import { LogicOR } from './LogicOR.class';
+import { LogicXOR } from './LogicXOR.class';
+import { LogicAtLeast } from './LogicAtLeast.class';
+import { LogicAtMost } from './LogicAtMost.class';
+import { AgentPlugin } from './AgentPlugin.class';
+import { LLMAssistant } from './LLMAssistant.class';
+import { Async } from './Async.class';
+import { Await } from './Await.class';
+import { ForEach } from './ForEach.class';
+import { HuggingFace } from './HuggingFace.class';
+import { GPTPlugin } from './GPTPlugin.class';
+import { Classifier } from './Classifier.class';
+import { FSign } from './FSign.class';
+import { GenAILLM } from './GenAILLM.class';
+import { FileStore } from './FileStore.class';
+import { ScrapflyWebScrape } from './ScrapflyWebScrape.class';
+import { TavilyWebSearch } from './TavilyWebSearch.class';
+import { ComponentHost } from './ComponentHost.class';
+import { ImageGenerator } from './ImageGenerator.class';
+import { MCPClient } from './MCPClient.class';
+export declare const ComponentInstances: {
+    Component: Component;
+    Note: Component;
+    APIEndpoint: APIEndpoint;
+    APIOutput: APIOutput;
+    PromptGenerator: PromptGenerator;
+    LLMPrompt: PromptGenerator;
+    APICall: APICall;
+    FSleep: FSleep;
+    FHash: FHash;
+    FEncDec: FEncDec;
+    FSign: FSign;
+    FTimestamp: FTimestamp;
+    DataSourceLookup: DataSourceLookup;
+    DataSourceIndexer: DataSourceIndexer;
+    DataSourceCleaner: DataSourceCleaner;
+    JSONFilter: JSONFilter;
+    LogicAND: LogicAND;
+    LogicOR: LogicOR;
+    LogicXOR: LogicXOR;
+    LogicAtLeast: LogicAtLeast;
+    LogicAtMost: LogicAtMost;
+    AgentPlugin: AgentPlugin;
+    LLMAssistant: LLMAssistant;
+    Async: Async;
+    Await: Await;
+    ForEach: ForEach;
+    HuggingFace: HuggingFace;
+    GPTPlugin: GPTPlugin;
+    Classifier: Classifier;
+    GenAILLM: GenAILLM;
+    FileStore: FileStore;
+    WebSearch: TavilyWebSearch;
+    WebScrape: ScrapflyWebScrape;
+    TavilyWebSearch: TavilyWebSearch;
+    ScrapflyWebScrape: ScrapflyWebScrape;
+    ComponentHost: ComponentHost;
+    ImageGenerator: ImageGenerator;
+    MCPClient: MCPClient;
+};

package/dist/types/Core/AgentProcess.helper.d.ts

@@ -0,0 +1,36 @@
+import { Agent } from '@sre/AgentManager/Agent.class';
+import { AgentRequest } from '@sre/AgentManager/AgentRequest.class';
+import { TAgentProcessParams } from '@sre/types/Agent.types';
+export declare class AgentProcess {
+    private agentData;
+    private agentVersion?;
+    agent: Agent;
+    private _loadPromise;
+    private constructor();
+    private initAgent;
+    ready(): Promise<any>;
+    static load(agentData: any, agentVersion?: string): AgentProcess;
+    /**
+     * Run the agent process
+     * @param reqConfig - The request configuration
+     * @param callback - The callback function is used if we want to send status data, meta information, or stream response progressively.
+     * Note: even if the response is streamed through the callback, the response is still returned as a single object in the response.data field.
+     * @returns The result of the agent process
+     */
+    run(reqConfig: TAgentProcessParams | Array<string> | AgentRequest, callback?: (data: any) => void): Promise<{
+        status?: number;
+        data: any;
+    }>;
+    reset(): void;
+    private parseReqConfig;
+    private parseCLI;
+    post(path: string, input?: any, headers?: any): Promise<{
+        status?: number;
+        data: any;
+    }>;
+    get(path: string, query?: any, headers?: any): Promise<{
+        status?: number;
+        data: any;
+    }>;
+    readDebugState(stateId: string, reqConfig: TAgentProcessParams | Array<string> | AgentRequest): Promise<any>;
+}

package/dist/types/Core/Connector.class.d.ts

@@ -0,0 +1,34 @@
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+export declare class Connector<TRequest = any> {
+    protected _settings?: any;
+    name: string;
+    started: boolean;
+    private _interactionHandler;
+    private _readyPromise;
+    private static lCache;
+    get settings(): any;
+    get interactionHandler(): () => void;
+    get valid(): boolean;
+    constructor(_settings?: any);
+    /**
+     * If the connector is interactive, The connector initializer will wait for start() method to complete before loading the next connector
+     */
+    protected setInteraction(handler: () => void): void;
+    /**
+     * Creates a new instance of the current class using the provided settings.
+     * This method can be called on both Connector instances and its subclasses.
+     * This is used when we need to create a connector instance with a specific configuration (for example with user provided keys)
+     *
+     * @param settings - Configuration settings for the new instance.
+     * @returns A new instance of the current class.
+     */
+    instance(settings: any): this;
+    static isValid(connector: Connector): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    ready(): Promise<boolean>;
+    requester(candidate: AccessCandidate): TRequest;
+    user(candidate: AccessCandidate | string): TRequest;
+    team(teamId: string): TRequest;
+    agent(agentId: string): TRequest;
+}

package/dist/types/Core/ConnectorsService.d.ts

@@ -0,0 +1,64 @@
+import { TConnectorService, TServiceRegistry } from '@sre/types/SRE.types';
+import { Connector } from './Connector.class';
+import { StorageConnector } from '@sre/IO/Storage.service/StorageConnector';
+import { CacheConnector } from '@sre/MemoryManager/Cache.service/CacheConnector';
+import { LLMConnector } from '@sre/LLMManager/LLM.service/LLMConnector';
+import { VaultConnector } from '@sre/Security/Vault.service/VaultConnector';
+import { AccountConnector } from '@sre/Security/Account.service/AccountConnector';
+import { AgentDataConnector } from '@sre/AgentManager/AgentData.service/AgentDataConnector';
+import { VectorDBConnector } from '@sre/IO/VectorDB.service/VectorDBConnector';
+import { CLIConnector } from '@sre/IO/CLI.service/CLIConnector';
+import { NKVConnector } from '@sre/IO/NKV.service/NKVConnector';
+import { RouterConnector } from '@sre/IO/Router.service/RouterConnector';
+import { ManagedVaultConnector } from '@sre/Security/ManagedVault.service/ManagedVaultConnector';
+import { LogConnector } from '@sre/IO/Log.service/LogConnector';
+import { ComponentConnector } from '@sre/AgentManager/Component.service/ComponentConnector';
+import { ModelsProviderConnector } from '@sre/LLMManager/ModelsProvider.service/ModelsProviderConnector';
+export declare class ConnectorService {
+    static Connectors: {};
+    static ConnectorInstances: any;
+    static get ready(): boolean;
+    static get service(): TServiceRegistry;
+    /**
+     * Allows SRE services to register their connectors, a registered conector can then be initialized and used by SRE or its services
+     * @param connectorType
+     * @param connectorName
+     * @param connectorConstructor
+     * @returns
+     */
+    static register(connectorType: TConnectorService, connectorName: string, connectorConstructor: any): void;
+    /**
+     * The init method instantiates a connector and starts it, a connector cannot be used before it is initialized
+     * Usually the initialization phase happens during the SRE startup, but some connectors can be initialized later if they are not mandatory for the SRE to start
+     *
+     *
+     * @param connectorType
+     * @param connectorName
+     * @param settings
+     * @param isDefault
+     * @returns
+     */
+    static init(connectorType: TConnectorService, connectorName: string, connectorId?: string, settings?: any, isDefault?: boolean): Connector<any>;
+    static _stop(): Promise<void>;
+    static getInstance<T>(connectorType: TConnectorService, connectorName?: string): T;
+    static getStorageConnector(name?: string): StorageConnector;
+    static getCacheConnector(name?: string): CacheConnector;
+    static getVectorDBConnector(name?: string): VectorDBConnector;
+    static getNKVConnector(name?: string): NKVConnector;
+    static getLLMConnector(name?: string): LLMConnector;
+    static getVaultConnector(name?: string): VaultConnector;
+    static getManagedVaultConnector(name?: string): ManagedVaultConnector;
+    static getAccountConnector(name?: string): AccountConnector;
+    static getAgentDataConnector(name?: string): AgentDataConnector;
+    static getCLIConnector(name?: string): CLIConnector;
+    static getLogConnector(name?: string): LogConnector;
+    static getComponentConnector(name?: string): ComponentConnector;
+    static getModelsProviderConnector(name?: string): ModelsProviderConnector;
+    static hasInstance(connectorType: TConnectorService, connectorName?: string): any;
+    static getRouterConnector(name?: string): RouterConnector;
+}
+export declare abstract class ConnectorServiceProvider {
+    abstract register(): any;
+    init(): void;
+    constructor();
+}

package/dist/types/Core/DummyConnector.d.ts

@@ -0,0 +1,4 @@
+/**
+ * DummyConnector is a placeholder for unimplemented connectors, it logs a warning when a method is called in order to help developers identify missing connectors
+ */
+export declare const DummyConnector: any;

package/dist/types/Core/HookService.d.ts

@@ -0,0 +1,27 @@
+type HookCallback = (...args: any[]) => void;
+export declare class HookService {
+    /**
+     * Register a new hook callback for a given hook name
+     * @param hookName The name of the hook to register
+     * @param callback The callback function to execute when the hook is triggered
+     */
+    static register(hookName: string, callback: HookCallback): void;
+    static trigger(hookName: string, ...args: any[]): void;
+}
+/**
+ * Decorator function that executes registered hooks before the decorated method
+ * @param hookName The name of the hook to trigger
+ */
+export declare function hook(hookName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Decorator function that executes registered hooks asynchronously before the decorated method
+ * @param hookName The name of the hook to trigger
+ */
+export declare function hookAsync(hookName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Decorator function that executes registered hooks asynchronously before the decorated method
+ * @param hookName The name of the hook to trigger
+ * @param contextFn Optional function to extract additional context from the class instance
+ */
+export declare function hookAsyncWithContext(hookName: string, contextFn?: (instance: any) => Record<string, any>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export {};

package/dist/types/Core/SmythRuntime.class.d.ts

@@ -0,0 +1,28 @@
+import { SREConfig } from '@sre/types/SRE.types';
+export declare class SmythRuntime {
+    started: boolean;
+    private _smythDir;
+    get smythDir(): string;
+    private _readyPromise;
+    private _readyResolve;
+    private defaultConfig;
+    protected constructor();
+    protected static instance?: SmythRuntime;
+    static get Instance(): SmythRuntime;
+    private _initializing;
+    get initializing(): boolean;
+    private _initialized;
+    init(_config?: SREConfig): SmythRuntime;
+    /**
+     * This function tries to auto configure, or fixes the provided configuration
+     *
+     * FIXME: The current version does not actually auto configure SRE, it just fixes the provided configuration for now
+     * TODO: Implement auto configuration based on present environment variables and auto-detected configs
+     * @param config
+     */
+    private autoConf;
+    ready(): Promise<boolean>;
+    private _stopping;
+    _stop(): Promise<void>;
+}
+export declare const SRE: SmythRuntime;

package/dist/types/Core/SystemEvents.d.ts

@@ -0,0 +1,12 @@
+import { SmythLLMUsage, SmythTaskUsage } from '@sre/types/LLM.types';
+import { TServiceRegistry } from '@sre/types/SRE.types';
+import { EventEmitter } from 'events';
+export type SystemEventMap = {
+    'SRE:Booted': [TServiceRegistry];
+    'SRE:Initialized': [];
+    'USAGE:LLM': [SmythLLMUsage];
+    'USAGE:API': any;
+    'USAGE:TASK': [SmythTaskUsage];
+};
+declare const SystemEvents: EventEmitter<SystemEventMap>;
+export { SystemEvents };

package/dist/types/Core/boot.d.ts

@@ -0,0 +1 @@
+export declare function boot(): void;

package/dist/types/config.d.ts

@@ -0,0 +1,11 @@
+declare const config: {
+    env: {
+        LOG_LEVEL: string;
+        LOG_FILTER: string;
+        NODE_ENV: string;
+    };
+    agent: {
+        ENDPOINT_PREFIX: string;
+    };
+};
+export default config;

package/dist/types/constants.d.ts

@@ -0,0 +1,79 @@
+export declare const REQUEST_METHODS: string[];
+export declare const REQUEST_CONTENT_TYPES: {
+    none: string;
+    urlEncodedFormData: string;
+    multipartFormData: string;
+    json: string;
+    text: string;
+    xml: string;
+    binary: string;
+};
+export declare enum EMBODIMENT_TYPES {
+    ChatBot = "chatBot",
+    ChatGPT = "chatGPT"
+}
+export declare const ERR_MSG_INVALID_IMAGE_SOURCE = "Please provide a valid Image Source. Supported image sources are: HTTP(S) URL, Base64 string, Data URL, Output Image from other component(s).";
+export declare const ERR_MSG_INVALID_BINARY = "Please provide a valid data that is either a Blob, SmythFileObject (Binary Output from any Component), ArrayBuffer, Buffer, Base64 string, Data URL, or HTTP(s) URL";
+export declare const ERR_MSG_MAX_DEPTH = "The maximum depth has been exceeded for the provided array or object.";
+export declare const ERR_MSG_MAX_ARRAY_SIZE = "The maximum array size has been exceeded for the provided array.";
+export declare const ERR_MSG_MAX_OBJECT_SIZE = "The maximum object size has been exceeded for the provided object.";
+export declare const MAX_DEPTH = 10;
+export declare const MAX_OBJECT_SIZE = 1000;
+export declare const MAX_ARRAY_SIZE = 1000;
+export declare const MAX_FILE_SIZE: number;
+export declare const MAX_FILE_COUNT = 10;
+export declare const DEFAULT_MAX_TOKENS_FOR_LLM = 2048;
+export declare const S3_DAILY_PURGE_LIFECYCLE_TAG = "ExpirationPolicy=DeleteDaily";
+export declare const S3_WEEKLY_PURGE_LIFECYCLE_TAG = "ExpirationPolicy=DeleteWeekly";
+export declare const S3_MONTHLY_PURGE_LIFECYCLE_TAG = "ExpirationPolicy=DeleteMonthly";
+export declare const TOOL_USE_DEFAULT_MODEL = "gpt-4o-mini";
+export declare const COMP_NAMES: {
+    apiCall: string;
+    code: string;
+    llmPrompt: string;
+    visionLLM: string;
+};
+export declare const JSON_RESPONSE_INSTRUCTION = "\nRespond ONLY with a valid, parsable JSON object. Follow these strict guidelines:\n1. The response must begin with '{' and end with '}'.\n2. Use double quotes for all keys and string values.\n3. Do not include any explanations, markdown, or text outside the JSON object.\n4. Do not use newlines or indentation within the JSON structure.\n5. For single-key responses, use the format: {\"result\": \"your content here\"}\n6. For multiple keys, use: {\"key1\": \"value1\", \"key2\": \"value2\", ...}\n\nExample of a valid response:\n{\"result\": \"This is a valid JSON response without any extra text.\"}\n";
+export declare const SUPPORTED_MIME_TYPES_MAP: {
+    OpenAI: {
+        image: string[];
+        imageGen: string[];
+        document: string[];
+    };
+    TogetherAI: {
+        image: string[];
+    };
+    Anthropic: {
+        image: string[];
+    };
+    GoogleAI: {
+        image: string[];
+        video: string[];
+        audio: string[];
+        document: string[];
+    };
+    Groq: {
+        image: string[];
+    };
+};
+export declare const DEFAULT_SMYTHOS_LLM_PROVIDERS_SETTINGS: {
+    openai: {
+        enabled: boolean;
+    };
+    anthropic: {
+        enabled: boolean;
+    };
+    googleai: {
+        enabled: boolean;
+    };
+    togetherai: {
+        enabled: boolean;
+    };
+    groq: {
+        enabled: boolean;
+    };
+    xai: {
+        enabled: boolean;
+    };
+};
+export declare const BUILT_IN_MODEL_PREFIX = "smythos/";

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

@@ -0,0 +1,33 @@
+import { Readable } from 'stream';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+export declare class BinaryInput {
+    private _name?;
+    mimetype?: string;
+    private candidate?;
+    private size;
+    private url;
+    private _ready;
+    private _readyPromise;
+    private _source;
+    private _uploading;
+    constructor(data: BinaryInput | Buffer | ArrayBuffer | Blob | string | Record<string, any>, _name?: string, mimetype?: string, candidate?: IAccessCandidate);
+    ready(): Promise<any>;
+    private load;
+    private getUrlInfo;
+    static from(data: any, name?: string, mimetype?: string, candidate?: IAccessCandidate): BinaryInput;
+    upload(candidate: IAccessCandidate, ttl?: number): Promise<void>;
+    getJsonData(candidate: IAccessCandidate, ttl?: number): Promise<{
+        mimetype: string;
+        size: number;
+        url: string;
+        name: string;
+    }>;
+    readData(candidate: IAccessCandidate): Promise<Buffer<ArrayBufferLike>>;
+    getName(): Promise<string>;
+    getBuffer(): Promise<Buffer<ArrayBufferLike>>;
+    /**
+     * Creates a read stream from the binary data.
+     * Uses temporary files to reduce memory usage for large files.
+     */
+    getReadStream(): Promise<Readable>;
+}