@neuralinnovations/dataisland-sdk 0.0.1-dev1 → 0.0.1-dev10

package/dist/dataisland-sdk.d.ts

@@ -0,0 +1,1594 @@
+declare module "src/middleware" {
+    /**
+     * DataIsland App request middleware.
+     */
+    export type Middleware = (req: Request, next: (req: Request) => Promise<Response>) => Promise<Response>;
+}
+declare module "src/internal/registry" {
+    export type Constructor<T> = new (...args: any[]) => T;
+    abstract class Provider {
+        abstract provide(): any | undefined;
+    }
+    export class RegistryItem<T> {
+        private readonly registry;
+        private readonly type;
+        constructor(registry: Map<Constructor<any>, Provider>, type: Constructor<T>);
+        asValue(value: T): void;
+        asProvider<T>(provider: () => T, oneTime?: boolean): void;
+        asFactory<T>(provider: () => T): void;
+        asSingleton<T>(provider: () => T): void;
+    }
+    export class Registry {
+        private readonly services;
+        constructor();
+        map<T>(type: Constructor<T>): RegistryItem<T>;
+        set<T>(type: Constructor<T>, provider: Provider): void;
+        get<T>(type: Constructor<T>): T | undefined;
+    }
+}
+declare module "src/disposable" {
+    /**
+     * Represents an object that can be disposed.
+     */
+    export interface Disposable {
+        dispose(): void;
+    }
+    /**
+     * Represents a lifetime.
+     */
+    export class Lifetime {
+        private readonly container;
+        constructor(container: DisposableContainer);
+        /**
+         * Define a new nested disposable to this lifetime.
+         */
+        defineNested(): DisposableContainer;
+        /**
+         * Shows whether this lifetime is disposed.
+         */
+        get isDisposed(): boolean;
+        /**
+         * Adds a disposable to this lifetime.
+         */
+        add(disposable: Disposable): this;
+        /**
+         * Adds a callback to this lifetime.
+         */
+        addCallback(callback: () => void, target?: unknown): this;
+    }
+    /**
+     * A container for disposables.
+     * Last added, first disposed.
+     * @example
+     * const container = new DisposableContainer();
+     * container.add(someDisposable);
+     * container.addCallback(() => console.log('disposed'));
+     * container.dispose();
+     */
+    export class DisposableContainer implements Disposable {
+        private _disposables;
+        private _isDisposed;
+        private _lifetime?;
+        /**
+         * Gets whether this container is disposed.
+         */
+        get isDisposed(): boolean;
+        /**
+         * Define new lifetime.
+         */
+        get lifetime(): Lifetime;
+        /**
+         * Adds a disposable to this container.
+         * @param disposable The disposable to add.
+         * @returns The disposable container.
+         */
+        add(disposable: Disposable): Disposable;
+        /**
+         * Adds a callback to be executed when this container is disposed.
+         * @param callback The callback to execute.
+         * @param target The target to bind the callback to.
+         * @returns The disposable container.
+         */
+        addCallback(callback: () => void, target?: unknown): Disposable;
+        /**
+         * Defines a nested disposable container.
+         */
+        defineNested(): DisposableContainer;
+        /**
+         * Disposes all disposables in this container. Last added, first disposed.
+         */
+        dispose(): void;
+        /**
+         * Throws an error if this container is disposed.
+         */
+        private _throwIfDisposed;
+    }
+    /**
+     * Creates a disposable.
+     * @param action The action to execute when disposed.
+     * @param target The target to bind the action to.
+     * @returns The disposable.
+     */
+    export function disposable(action: () => void, target: unknown): Disposable;
+}
+declare module "src/services/commandService" {
+    import { Service } from "src/services/service";
+    import { Context } from "src/context";
+    import { Constructor } from "src/internal/registry";
+    export abstract class CommandHandler<T> {
+        protected readonly context: Context;
+        constructor(context: Context);
+        resolve<T>(type: Constructor<T>): T | undefined;
+        abstract execute(message: T): Promise<void>;
+    }
+    export abstract class Command {
+    }
+    export class CommandService extends Service {
+        private readonly _registry;
+        private _lastPromise;
+        register<T extends Command>(messageType: Constructor<T>, commandFactory: (context: Context) => CommandHandler<T>): void;
+        execute<T extends Command>(message: T): Promise<void>;
+    }
+}
+declare module "src/context" {
+    import { type Constructor, type Registry } from "src/internal/registry";
+    import { type Lifetime } from "src/disposable";
+    import { Command } from "src/services/commandService";
+    /**
+     * DataIsland App context.
+     */
+    export class Context {
+        private readonly registry;
+        readonly lifetime: Lifetime;
+        readonly appName: string;
+        constructor(registry: Registry, lifetime: Lifetime, appName: string);
+        /**
+         * Resolve a service from the context.
+         * @param type of the service
+         */
+        resolve<T>(type: Constructor<T>): T | undefined;
+        /**
+         * Execute a command.
+         * @param command to execute
+         */
+        execute<T extends Command>(command: T): Promise<void>;
+    }
+}
+declare module "src/services/service" {
+    import { type Context } from "src/context";
+    import { type Constructor } from "src/internal/registry";
+    import { type DisposableContainer, type Lifetime } from "src/disposable";
+    export class ServiceContext {
+        readonly context: Context;
+        private readonly disposableContainer;
+        constructor(context: Context, disposableContainer: DisposableContainer);
+        get lifetime(): Lifetime;
+        resolve<T>(type: Constructor<T>): T | undefined;
+        onRegister: () => Promise<void>;
+        onStart: () => Promise<void>;
+        onUnregister: () => void;
+    }
+    export abstract class Service {
+        private readonly serviceContext;
+        resolve<T>(type: Constructor<T>): T | undefined;
+        get lifetime(): Lifetime;
+        get context(): Context;
+        constructor(serviceContext: ServiceContext);
+    }
+}
+declare module "src/services/middlewareService" {
+    import { Service } from "src/services/service";
+    import { type Middleware } from "src/middleware";
+    import { type Disposable } from "src/disposable";
+    export class MiddlewareService extends Service {
+        private _middlewares;
+        useMiddleware(middleware: Middleware): Disposable;
+        process(req: Request, next: (req: Request) => Promise<Response>): Promise<Response>;
+    }
+}
+declare module "src/credentials" {
+    import { type Lifetime } from "src/disposable";
+    import { type Context } from "src/context";
+    /**
+     * DataIsland App credential.
+     */
+    export abstract class CredentialBase {
+        abstract onRegister(lifetime: Lifetime, context: Context): void;
+    }
+    export class DefaultCredential extends CredentialBase {
+        onRegister(lifetime: Lifetime, context: Context): void;
+    }
+    export class BasicCredential extends CredentialBase {
+        readonly email: string;
+        readonly password: string;
+        constructor(email: string, password: string);
+        onRegister(lifetime: Lifetime, context: Context): void;
+    }
+    export class DebugCredential extends CredentialBase {
+        readonly token: string;
+        constructor(token: string);
+        onRegister(lifetime: Lifetime, context: Context): void;
+    }
+    export class BearerCredential extends CredentialBase {
+        readonly token: string;
+        constructor(token: string);
+        onRegister(lifetime: Lifetime, context: Context): void;
+    }
+}
+declare module "src/appBuilder" {
+    import type { Middleware } from "src/middleware";
+    import type { CredentialBase } from "src/credentials";
+    import type { Service, ServiceContext } from "src/services/service";
+    import type { Constructor } from "src/internal/registry";
+    import { CommandHandler, Command } from "src/services/commandService";
+    import { Context } from "src/context";
+    /**
+     * DataIsland App builder.
+     */
+    export abstract class AppBuilder {
+        /**
+         * Set custom data.
+         */
+        abstract get env(): Record<string, any>;
+        /**
+         * Add a middleware to the app.
+         */
+        abstract registerMiddleware(middleware: Middleware): AppBuilder;
+        /**
+         * Host of the app.
+         */
+        abstract useHost(host: string): AppBuilder;
+        /**
+         * GDPR compliant
+         */
+        abstract useAutomaticDataCollectionEnabled(value: boolean): AppBuilder;
+        /**
+         * Credential of the app.
+         */
+        abstract useCredential(credential: CredentialBase): AppBuilder;
+        /**
+         * Register a service to the app.
+         * @param type
+         * @param factory
+         */
+        abstract registerService<T extends Service>(type: Constructor<T>, factory: (context: ServiceContext) => T): AppBuilder;
+        /**
+         * Register a command to the app.
+         * @param messageType
+         * @param commandFactory
+         */
+        abstract registerCommand<T extends Command>(messageType: Constructor<T>, commandFactory: ((context: Context) => CommandHandler<T>) | ((context: Context) => (context: Context) => Promise<void>)): AppBuilder;
+    }
+}
+declare module "src/events" {
+    import { type Disposable } from "src/disposable";
+    export interface Input<EventType, DataType> {
+        type?: EventType;
+        data: DataType;
+    }
+    export interface Event<EventType, DataType> extends Input<EventType, DataType> {
+        unsubscribe: () => void;
+    }
+    export interface EventSubscriber<EventType, DataType> {
+        subscribe: (callback: (event: Event<EventType, DataType>) => void, type?: EventType) => Disposable;
+    }
+    export class EventDispatcher<EventType, DataType> implements EventSubscriber<EventType, DataType> {
+        private _listeners;
+        dispatch(input: Input<EventType, DataType>): void;
+        subscribe(callback: (event: Event<EventType, DataType>) => void, type?: EventType): Disposable;
+    }
+}
+declare module "src/dto/workspacesResponse" {
+    import { WorkspaceId } from "src/storages/workspaces/workspaces";
+    import { FileId } from "src/storages/files/file";
+    export interface WorkspaceProfileDto {
+        name: string;
+        description: string;
+    }
+    export interface WorkspaceDto {
+        id: WorkspaceId;
+        createdAt: number;
+        modifiedAt: number;
+        profile: WorkspaceProfileDto;
+    }
+    export interface WorkspacesResponse {
+        workspaces: WorkspaceDto[];
+    }
+    export interface FileUrlDto {
+        url: string;
+    }
+    export interface FileProgressDto {
+        file_id: FileId;
+        file_parts_count: number;
+        completed_parts_count: number;
+        success: boolean;
+        error?: string;
+    }
+    export interface FileDto {
+        id: string;
+        createdAt: number;
+        modifiedAt: number;
+        name: string;
+        description: string;
+        url: string;
+        hash: string;
+        organizationId: string;
+        workspaceId: string;
+        isProcessedSuccessfully: boolean;
+    }
+    export interface FileListResponse {
+        files: FileDto[];
+        totalFilesCount: number;
+        filesPerPage: number;
+    }
+}
+declare module "src/storages/files/file" {
+    import { FileProgressDto } from "src/dto/workspacesResponse";
+    export type FileId = string;
+    /**
+     * File.
+     */
+    export abstract class File {
+        /**
+         * File id.
+         */
+        abstract get id(): FileId;
+        /**
+         * File name.
+         */
+        abstract get name(): string;
+        /**
+         * Get temporary url.
+         */
+        abstract url(): Promise<string>;
+        /**
+         * Get file status.
+         */
+        abstract status(): Promise<FileProgressDto>;
+    }
+}
+declare module "src/storages/files/filesPage" {
+    import { File } from "src/storages/files/file";
+    /**
+     * Files page.
+     */
+    export abstract class FilesPage {
+        /**
+         * Get files.
+         */
+        abstract get files(): File[];
+        /**
+         * Get pages count.
+         */
+        abstract get pages(): number;
+        /**
+         * Get total count.
+         */
+        abstract get total(): number;
+        /**
+         * Get current page.
+         */
+        abstract get page(): number;
+    }
+}
+declare module "src/storages/files/files" {
+    import { EventDispatcher } from "src/events";
+    import { File, FileId } from "src/storages/files/file";
+    import { FilesPage } from "src/storages/files/filesPage";
+    /**
+     * Files event.
+     */
+    export enum FilesEvent {
+        ADDED = "added",
+        REMOVED = "removed"
+    }
+    /**
+     * Upload file.
+     */
+    export type UploadFile = globalThis.File;
+    /**
+     * Files storage.
+     */
+    export abstract class Files extends EventDispatcher<FilesEvent, File> {
+        /**
+         * Upload file.
+         */
+        abstract upload(file: UploadFile): Promise<File>;
+        /**
+         * Delete file.
+         * @param id
+         */
+        abstract delete(id: FileId): Promise<void>;
+        /**
+         * Query files.
+         */
+        abstract query(query: string, page: number, limit: number): Promise<FilesPage>;
+    }
+}
+declare module "src/storages/workspaces/workspace" {
+    import { EventDispatcher } from "src/events";
+    import { Files } from "src/storages/files/files";
+    import { WorkspaceId } from "src/storages/workspaces/workspaces";
+    import { Organization } from "src/storages/organizations/organization";
+    /**
+     * Workspace event.
+     */
+    export enum WorkspaceEvent {
+        CHANGED = "changed"
+    }
+    /**
+     * Workspace.
+     */
+    export abstract class Workspace extends EventDispatcher<WorkspaceEvent, Workspace> {
+        /**
+         * Organization.
+         */
+        abstract get organization(): Organization;
+        /**
+         * Workspace id.
+         */
+        abstract get id(): WorkspaceId;
+        /**
+         * Workspace name.
+         */
+        abstract get name(): string;
+        /**
+         * Workspace description.
+         */
+        abstract get description(): string;
+        /**
+         * Workspace files.
+         */
+        abstract get files(): Files;
+        /**
+         * Change workspace name and description.
+         */
+        abstract change(name: string, description: string): Promise<void>;
+    }
+}
+declare module "src/storages/workspaces/workspaces" {
+    import { EventDispatcher } from "src/events";
+    import { Workspace } from "src/storages/workspaces/workspace";
+    export type WorkspaceId = string;
+    /**
+     * Workspaces event.
+     */
+    export enum WorkspacesEvent {
+        ADDED = "added",
+        REMOVED = "removed"
+    }
+    /**
+     * Organization's workspaces.
+     */
+    export abstract class Workspaces extends EventDispatcher<WorkspacesEvent, Workspace> {
+        /**
+         * Workspaces.
+         */
+        abstract get collection(): ReadonlyArray<Workspace>;
+        /**
+         * Get workspace by id.
+         * @param id
+         */
+        abstract get(id: WorkspaceId): Workspace;
+        /**
+         * Try to get workspace by id.
+         * @param id
+         */
+        abstract tryGet(id: WorkspaceId): Workspace | undefined;
+        /**
+         * Check if workspace exists.
+         * @param id
+         */
+        abstract contains(id: WorkspaceId): boolean;
+        /**
+         * Create workspace.
+         */
+        abstract create(name: string, description: string, regulation?: {
+            isCreateNewGroup: boolean;
+            newGroupName: string;
+            groupIds: string[];
+        }): Promise<Workspace>;
+        /**
+         * Delete workspace.
+         */
+        abstract delete(id: WorkspaceId): Promise<void>;
+    }
+}
+declare module "src/dto/userInfoResponse" {
+    import { WorkspaceDto } from "src/dto/workspacesResponse";
+    export interface UserInfoResponse {
+        adminInOrganization: string[];
+        organizations: OrganizationDto[];
+        user: UserDto;
+    }
+    export interface UserDto {
+        id: string;
+        isDeleted: boolean;
+        created_at: number;
+        modified_at: number;
+        profile: ProfileDto;
+        settings?: UserSettings | null;
+    }
+    export interface ProfileDto {
+        name: string;
+        email: string;
+    }
+    export interface UserSettings {
+        activeOrganizationId: string;
+        activeWorkspaceId: string;
+    }
+    export interface OrganizationProfileDto {
+        name: string;
+        description: string;
+    }
+    export interface OrganizationDto {
+        id: string;
+        createdAt: number;
+        modifiedAt: number;
+        membersCount: number;
+        profile: OrganizationProfileDto;
+    }
+    export interface OrganizationWorkspaces extends OrganizationDto {
+        workspaces: WorkspaceDto[];
+    }
+    export interface MembersResponse {
+        members: UserDto;
+    }
+}
+declare module "src/dto/accessGroupResponse" {
+    import { UserDto } from "src/dto/userInfoResponse";
+    export interface PermitsDto {
+        isAdmin: boolean;
+    }
+    export interface RegulationDto {
+        isRegulateOrganization: boolean;
+        regulateWorkspaceIds: string[];
+    }
+    export interface AccessGroupDto {
+        id: string;
+        name: string;
+        type: number;
+        createdAt: number;
+        modifiedAt: number;
+        organizationId: string;
+        permits: PermitsDto;
+        regulation: RegulationDto;
+        membersCount: number;
+    }
+    export interface AccessGroupResponse {
+        group: AccessGroupDto;
+        members: UserDto[];
+    }
+    export interface AccessGroupsResponse {
+        groups: AccessGroupDto[];
+    }
+}
+declare module "src/storages/groups/groups" {
+    import { AccessGroupDto } from "src/dto/accessGroupResponse";
+    import { UserDto } from "src/dto/userInfoResponse";
+    import { WorkspaceDto } from "src/dto/workspacesResponse";
+    import { EventDispatcher } from "src/events";
+    import { OrganizationId } from "src/storages/organizations/organizations";
+    import { Organization } from "src/storages/organizations/organization";
+    /**
+     * Group id.
+     */
+    export type GroupId = string;
+    /**
+     * Group event.
+     */
+    export enum GroupEvent {
+        ADDED = "added",
+        REMOVED = "removed",
+        UPDATED = "updated"
+    }
+    /**
+     * Group.
+     */
+    export abstract class Group extends EventDispatcher<GroupEvent, Group> {
+        /**
+         * Group id.
+         */
+        abstract get id(): GroupId;
+        /**
+         * Group information.
+         */
+        abstract get group(): AccessGroupDto;
+        /**
+         * Group members.
+         */
+        abstract get members(): UserDto[];
+        /**
+         * Group workspaces.
+         */
+        abstract getWorkspaces(): Promise<WorkspaceDto[]>;
+        /**
+         * Set workspaces.
+         */
+        abstract setWorkspaces(workspaces: string[]): Promise<void>;
+        /**
+         * Set name.
+         */
+        abstract setName(name: string): Promise<void>;
+        /**
+         * Set permits.
+         */
+        abstract setPermits(permits: {
+            isAdmin: boolean;
+        }): Promise<void>;
+        /**
+         * Set members.
+         */
+        abstract setMembersIds(members: string[]): Promise<void>;
+    }
+    /**
+     * Groups storage.
+     */
+    export abstract class Groups extends EventDispatcher<GroupEvent, Group> {
+        /**
+         * Organization.
+         */
+        abstract get organization(): Organization;
+        /**
+         * Create new group.
+         * @param name
+         * @param organizationId
+         * @param permits
+         * @param memberIds
+         */
+        abstract create(name: string, organizationId: OrganizationId, permits: {
+            isAdmin: boolean;
+        }, memberIds: string[]): Promise<Group>;
+        /**
+         * Get group by id.
+         * @param id
+         */
+        abstract get(id: GroupId): Group | undefined;
+        /**
+         * delete group by id.
+         * @param id
+         */
+        abstract delete(id: GroupId): Promise<void>;
+    }
+}
+declare module "src/dto/chatResponse" {
+    export interface SourceDto {
+        id: string;
+        name: string;
+        url: string;
+        content: string;
+        page: number;
+    }
+    export interface AnswerDto {
+        id: string;
+        chatId: string;
+        question: string;
+        context: string;
+        sources: SourceDto[];
+        timestamp: number;
+    }
+    export interface ChatDto {
+        id: string;
+        name: string;
+        createdAt: number;
+        modifiedAt: number;
+        userId: string;
+        organizationId: string;
+        workspaceId: string;
+        answers: AnswerDto[];
+    }
+    export interface ChatListResponse {
+        chats: ChatDto[];
+    }
+    export enum AnswerStatus {
+        RUNNING = 0,
+        SUCCESS = 1,
+        CANCELED = 2,
+        FAIL = 3
+    }
+    export interface AnswerStepDto {
+        id: string;
+        type: StepType;
+        status: StepStatus;
+        start_at: string;
+        end_at: string;
+        tokens: string[];
+        sources: SourceDto[];
+    }
+    export interface FetchAnswerResponse {
+        id: string;
+        status: AnswerStatus;
+        steps: AnswerStepDto[];
+    }
+    export interface FetchTokensResponse {
+        id: string;
+        step_id: string;
+        step_status: number;
+        step_tokens: string[];
+    }
+    export interface AnswerSourcesResponse {
+        chat_uid: string;
+        uid: string;
+        step_id: string;
+        sources: SourceDto[];
+    }
+    export enum StepStatus {
+        RUNNING = 0,
+        SUCCESS = 1,
+        FAIL = 2,
+        CANCELED = 3
+    }
+    export enum StepType {
+        PREPARE = 0,
+        SOURCES = 1,
+        GENERATE_ANSWER = 6,
+        FINALIZE_RESULT = 9,
+        DONE = 10
+    }
+    export class StepTypeInfo {
+        static hasTokens(type: StepType): boolean;
+        static hasSources(type: StepType): boolean;
+    }
+}
+declare module "src/storages/chats/answer" {
+    import { AnswerStatus, FetchTokensResponse, SourceDto, StepType } from "src/dto/chatResponse";
+    export type AnswerId = string;
+    export type StepId = string;
+    export abstract class Answer {
+        /**
+         * Answer id.
+         */
+        abstract get id(): AnswerId;
+        /**
+         * Answer status.
+         */
+        abstract get status(): AnswerStatus;
+        /**
+         * Answer sources.
+         */
+        abstract sources(type: StepType): Promise<SourceDto[]>;
+        /**
+         * Fetch answer.
+         */
+        abstract fetch(): Promise<void>;
+        /**
+         * Fetch answer.
+         */
+        abstract fetchTokens(type: StepType, tokenStartAt: number): Promise<FetchTokensResponse>;
+        /**
+         * Cancel answer
+         */
+        abstract cancel(): Promise<void>;
+    }
+}
+declare module "src/storages/chats/chat" {
+    import { Answer } from "src/storages/chats/answer";
+    import { Organization } from "src/storages/organizations/organization";
+    export type ChatId = string;
+    export enum ChatAnswerType {
+        SHORT = "short",
+        LONG = "long"
+    }
+    export abstract class Chat {
+        /**
+         * Organization.
+         */
+        abstract get organization(): Organization;
+        /**
+         * Chat id.
+         */
+        abstract get id(): ChatId;
+        /**
+         * Chat name.
+         */
+        abstract get name(): string;
+        /**
+         * Answers list.
+         */
+        abstract get collection(): ReadonlyArray<Answer>;
+        /**
+         * Ask new question in chat.
+         */
+        abstract ask(message: string, answerType: ChatAnswerType): Promise<Answer>;
+    }
+}
+declare module "src/storages/chats/chats" {
+    import { EventDispatcher } from "src/events";
+    import { Chat, ChatId } from "src/storages/chats/chat";
+    import { Organization } from "src/storages/organizations/organization";
+    export enum ChatsEvent {
+        ADDED = "added",
+        REMOVED = "removed"
+    }
+    /**
+     * Chats storage.
+     */
+    export abstract class Chats extends EventDispatcher<ChatsEvent, Chat> {
+        /**
+         * Organization.
+         */
+        abstract get organization(): Organization;
+        /**
+         * Chats list.
+         */
+        abstract get collection(): ReadonlyArray<Chat>;
+        /**
+         * Create new chat.
+         */
+        abstract create(): Promise<Chat>;
+        /**
+         * Get chat by id.
+         * @param id
+         */
+        abstract get(id: ChatId): Chat;
+        /**
+         * Try to get chat by id.
+         * @param id
+         */
+        abstract tryGet(id: ChatId): Chat | undefined;
+        /**
+         * Delete chat.
+         * @param id
+         */
+        abstract delete(id: ChatId): Promise<void>;
+    }
+}
+declare module "src/storages/organizations/organization" {
+    import { Workspaces } from "src/storages/workspaces/workspaces";
+    import { OrganizationId } from "src/storages/organizations/organizations";
+    import { GroupId, Groups } from "src/storages/groups/groups";
+    import { Chats } from "src/storages/chats/chats";
+    /**
+     * Organization.
+     */
+    export abstract class Organization {
+        /**
+         * Organization id.
+         */
+        abstract get id(): OrganizationId;
+        /**
+         * Organization name.
+         */
+        abstract get name(): string;
+        /**
+         * Organization description.
+         */
+        abstract get description(): string;
+        /**
+         * Workspaces.
+         */
+        abstract get workspaces(): Workspaces;
+        /**
+         * Chats.
+         */
+        abstract get chats(): Chats;
+        /**
+         * Groups.
+         */
+        abstract get accessGroups(): Groups;
+        /**
+         * Create invite link
+         */
+        abstract createInviteLink(emails: string[], accessGroups: GroupId[]): Promise<void>;
+    }
+}
+declare module "src/storages/organizations/organizations" {
+    import { EventDispatcher } from "src/events";
+    import { Organization } from "src/storages/organizations/organization";
+    /**
+     * Organization id.
+     */
+    export type OrganizationId = string;
+    /**
+     * Organization event.
+     */
+    export enum OrganizationsEvent {
+        ADDED = "added",
+        REMOVED = "removed",
+        CURRENT_CHANGED = "currentChanged"
+    }
+    /**
+     * Organizations storage.
+     */
+    export abstract class Organizations extends EventDispatcher<OrganizationsEvent, Organization> {
+        /**
+         * User's organizations.
+         */
+        abstract get collection(): ReadonlyArray<Organization>;
+        /**
+         * Current organization.
+         */
+        abstract get current(): OrganizationId;
+        abstract set current(value: OrganizationId);
+        /**
+         * Get organization by id.
+         */
+        abstract get(id: OrganizationId): Organization;
+        /**
+         * Try to get organization by id.
+         * @param id
+         */
+        abstract tryGet(id: OrganizationId): Organization | undefined;
+        /**
+         * Create new organization.
+         */
+        abstract create(name: string, description: string): Promise<Organization>;
+        /**
+         * Delete organization.
+         */
+        abstract delete(id: OrganizationId): Promise<void>;
+    }
+}
+declare module "src/storages/user/userProfile" {
+    import { EventDispatcher } from "src/events";
+    export type UserId = string;
+    export enum UserEvent {
+        CHANGED = "changed"
+    }
+    export abstract class UserProfile extends EventDispatcher<UserEvent, UserProfile> {
+        /**
+         * User id.
+         */
+        abstract get id(): UserId;
+        /**
+         * User name.
+         */
+        abstract get name(): string;
+        /**
+         * User email.
+         */
+        abstract get email(): string;
+        /**
+         * Is user deleted.
+         */
+        abstract get isDeleted(): boolean;
+        /**
+         * Created at.
+         */
+        abstract get createdAt(): Date;
+        /**
+         * Modified at.
+         */
+        abstract get modifiedAt(): Date;
+    }
+}
+declare module "src/dataIslandApp" {
+    import type { Lifetime } from "src/disposable";
+    import type { CredentialBase } from "src/credentials";
+    import { Context } from "src/context";
+    import type { Constructor } from "src/internal/registry";
+    import { Organizations } from "src/storages/organizations/organizations";
+    import { UserProfile } from "src/storages/user/userProfile";
+    /**
+     * DataIsland App instance.
+     */
+    export abstract class DataIslandApp {
+        /**
+         * The name of this app.
+         */
+        abstract get name(): string;
+        /**
+         * The host of this app.
+         */
+        abstract get host(): string;
+        /**
+         * The automaticDataCollectionEnabled of this app.
+         */
+        abstract get automaticDataCollectionEnabled(): boolean;
+        /**
+         * The lifetime of this app.
+         */
+        abstract get lifetime(): Lifetime;
+        /**
+         * The credential of this app.
+         */
+        abstract get credential(): CredentialBase | undefined;
+        abstract set credential(value: CredentialBase);
+        /**
+         * The context of this app.
+         */
+        abstract get context(): Context;
+        /**
+         * User's organizations.
+         */
+        abstract get organizations(): Organizations;
+        /**
+         * User's profile.
+         */
+        abstract get userProfile(): UserProfile;
+        /**
+         * Resolve a service from the app.
+         * @param type
+         */
+        abstract resolve<T>(type: Constructor<T>): T | undefined;
+    }
+}
+declare module "src/unitTest" {
+    export enum UnitTest {
+        DO_NOTHING = 0,
+        DO_NOT_START = 1,
+        DO_NOT_PRINT_INITIALIZED_LOG = 2,
+        DEFAULT = 3
+    }
+    export type UnitTestProfileSyncAction = () => void;
+    export type UnitTestProfileAsyncAction = () => Promise<void>;
+    export const appTest: (unitTest: UnitTest | undefined, func: UnitTestProfileSyncAction | UnitTestProfileAsyncAction) => Promise<void>;
+    export const appTestCurrent: () => UnitTest;
+    export const isUnitTest: (mask: UnitTest) => boolean;
+}
+declare module "src/internal/appBuilder.impl" {
+    import { AppBuilder } from "src/appBuilder";
+    import { type CredentialBase } from "src/credentials";
+    import type { Middleware } from "src/middleware";
+    import { type Service, type ServiceContext } from "src/services/service";
+    import { type Constructor } from "src/internal/registry";
+    import { Command, CommandHandler } from "src/services/commandService";
+    import { Context } from "src/context";
+    export class AppBuilderImplementation extends AppBuilder {
+        envData: Record<string, any>;
+        host: string;
+        automaticDataCollectionEnabled: boolean;
+        credential: CredentialBase;
+        middlewares: Middleware[];
+        services: Array<[Constructor<any>, (context: ServiceContext) => Service]>;
+        commands: Array<[
+            Constructor<any>,
+            (context: Context) => CommandHandler<any>
+        ]>;
+        get env(): Record<string, any>;
+        useHost(host: string): AppBuilder;
+        useAutomaticDataCollectionEnabled(value: boolean): AppBuilder;
+        useCredential(credential: CredentialBase): AppBuilder;
+        registerMiddleware(middleware: Middleware): AppBuilder;
+        registerService<T extends Service>(type: Constructor<T>, factory: (context: ServiceContext) => T): AppBuilder;
+        registerCommand<T extends Command>(messageType: Constructor<T>, commandFactory: (context: Context) => CommandHandler<T>): AppBuilder;
+    }
+}
+declare module "src/services/credentialService" {
+    import { type CredentialBase } from "src/credentials";
+    import { Service } from "src/services/service";
+    export class CredentialService extends Service {
+        private _credentialDispose?;
+        private _credential?;
+        get credential(): CredentialBase | undefined;
+        useCredential(credential: CredentialBase): void;
+    }
+}
+declare module "src/services/requestBuilder" {
+    export class RequestBuilder {
+        private readonly _url;
+        private readonly _request;
+        private readonly _headers;
+        private readonly _searchParams;
+        constructor(_url: URL, _request: (req: Request) => Promise<Response>);
+        header(name: string, value: string): RequestBuilder;
+        headers(headers?: [string, string][] | Record<string, string> | Headers): RequestBuilder;
+        searchParam(name: string, value: string): RequestBuilder;
+        searchParams(searchParams?: Map<string, string>): RequestBuilder;
+        sendPostFormData(body: FormData): Promise<Response>;
+        sendPostJson(body: object | null | undefined): Promise<Response>;
+        sendGet(): Promise<Response>;
+        sendDelete(): Promise<Response>;
+        sendPutJson(body: object | null | undefined): Promise<Response>;
+    }
+}
+declare module "src/services/rpcService" {
+    import { Service, type ServiceContext } from "src/services/service";
+    import { RequestBuilder } from "src/services/requestBuilder";
+    /**
+     * Options for the RpcService.
+     */
+    export interface RequestOptions {
+        searchParams?: Map<string, string>;
+        headers?: [string, string][] | Record<string, string> | Headers;
+    }
+    /**
+     * RPC service.
+     */
+    export class RpcService extends Service {
+        /**
+         * Host of the RPC service.
+         * It is not used if you use the `urlBuilder` option.
+         */
+        readonly host: string;
+        /**
+         * Options for the RpcService.
+         */
+        private readonly options?;
+        constructor(serviceContext: ServiceContext, 
+        /**
+         * Host of the RPC service.
+         * It is not used if you use the `urlBuilder` option.
+         */
+        host: string, 
+        /**
+         * Options for the RpcService.
+         */
+        options?: {
+            urlBuilder?: ((path: string) => URL) | undefined;
+            fetchMethod?: ((uri: Request) => Promise<Response>) | undefined;
+        } | undefined);
+        /**
+         * Request method.
+         */
+        request(req: Request): Promise<Response>;
+        /**
+         * Build URL.
+         * @param path
+         */
+        buildUrl(path: string): URL;
+        /**
+         * Create a request builder.
+         * @param path
+         */
+        requestBuilder(path: string): RequestBuilder;
+        /**
+         * Send a GET request.
+         * @param path
+         * @param options
+         */
+        get(path: string, options?: RequestOptions): Promise<Response>;
+        /**
+         * Send a POST request.
+         * @param path
+         * @param body JSON object
+         * @param options
+         */
+        post(path: string, body: object | null | undefined, options?: RequestOptions): Promise<Response>;
+        /**
+         * Send a PUT request.
+         * @param path
+         * @param body JSON object
+         * @param options
+         */
+        put(path: string, body: object | null | undefined, options?: RequestOptions): Promise<Response>;
+        /**
+         * Send a DELETE request.
+         * @param path
+         * @param options
+         */
+        delete(path: string, options?: RequestOptions): Promise<Response>;
+    }
+}
+declare module "src/services/responseUtils" {
+    export class ResponseUtils {
+        static isOk(response?: Response | null): boolean;
+        static isFail(response?: Response | null): boolean;
+        static throwError(message: string, response: Response | undefined | null): Promise<void>;
+    }
+}
+declare module "src/storages/files/file.impl" {
+    import { Context } from "src/context";
+    import { Disposable } from "src/disposable";
+    import { FileDto, FileProgressDto } from "src/dto/workspacesResponse";
+    import { File } from "src/storages/files/file";
+    export class FileImpl extends File implements Disposable {
+        private readonly context;
+        private _isDisposed;
+        private _content?;
+        constructor(context: Context);
+        initFrom(file: FileDto): File;
+        get isDisposed(): boolean;
+        dispose(): void;
+        get id(): string;
+        get name(): string;
+        url(): Promise<string>;
+        status(): Promise<FileProgressDto>;
+    }
+}
+declare module "src/storages/files/files.impl" {
+    import { Context } from "src/context";
+    import { Disposable } from "src/disposable";
+    import { Files, UploadFile } from "src/storages/files/files";
+    import { WorkspaceImpl } from "src/storages/workspaces/workspace.impl";
+    import { File } from "src/storages/files/file";
+    import { FilesPage } from "src/storages/files/filesPage";
+    export class FilesPageImpl extends FilesPage implements Disposable {
+        private _isDisposed;
+        files: File[];
+        total: number;
+        filesPerPage: number;
+        page: number;
+        get pages(): number;
+        get isDisposed(): boolean;
+        dispose(): void;
+    }
+    export class FilesImpl extends Files {
+        private readonly workspace;
+        private readonly context;
+        constructor(workspace: WorkspaceImpl, context: Context);
+        filesList?: FilesPage;
+        upload(file: any): Promise<File>;
+        delete(id: string): Promise<void>;
+        query(query: string, page: number, limit: number): Promise<FilesPage>;
+        /**
+         * Delete organization.
+         * @param id
+         */
+        internalDeleteFile(id: string): Promise<void>;
+        internalQuery(query: string, page: number, limit: number): Promise<FilesPage>;
+        internalUpload(file: UploadFile): Promise<File>;
+    }
+}
+declare module "src/storages/workspaces/workspace.impl" {
+    import { Context } from "src/context";
+    import { Files } from "src/storages/files/files";
+    import { Workspace } from "src/storages/workspaces/workspace";
+    import { OrganizationImpl } from "src/storages/organizations/organization.impl";
+    import { WorkspaceDto } from "src/dto/workspacesResponse";
+    export class WorkspaceImpl extends Workspace {
+        readonly organization: OrganizationImpl;
+        readonly context: Context;
+        private _isMarkAsDeleted;
+        private _workspace?;
+        private readonly _files;
+        constructor(organization: OrganizationImpl, context: Context);
+        get id(): string;
+        get name(): string;
+        get description(): string;
+        get files(): Files;
+        change(name: string, description: string): Promise<void>;
+        initFrom(workspace: WorkspaceDto): Promise<void>;
+        get isMarkAsDeleted(): boolean;
+        markToDelete(): void;
+    }
+}
+declare module "src/storages/workspaces/workspaces.impl" {
+    import { WorkspaceId, Workspaces } from "src/storages/workspaces/workspaces";
+    import { OrganizationImpl } from "src/storages/organizations/organization.impl";
+    import { Context } from "src/context";
+    import { Workspace } from "src/storages/workspaces/workspace";
+    import { OrganizationId } from "src/storages/organizations/organizations";
+    export class WorkspacesImpl extends Workspaces {
+        private readonly organization;
+        private readonly context;
+        private readonly _workspaces;
+        constructor(organization: OrganizationImpl, context: Context);
+        get collection(): readonly Workspace[];
+        get(id: string): Workspace;
+        tryGet(id: string): Workspace | undefined;
+        contains(id: string): boolean;
+        /**
+         * Create workspace.
+         * @param name
+         * @param description
+         * @param regulation
+         */
+        create(name: string, description: string, regulation?: {
+            isCreateNewGroup: boolean;
+            newGroupName: string;
+            groupIds: string[];
+        }): Promise<Workspace>;
+        /**
+         * Delete workspace.
+         * @param id
+         */
+        delete(id: WorkspaceId): Promise<void>;
+        initFrom(organizationId: OrganizationId): Promise<void>;
+    }
+}
+declare module "src/storages/groups/groups.impl" {
+    import { Context } from "src/context";
+    import { Disposable } from "src/disposable";
+    import { AccessGroupDto } from "src/dto/accessGroupResponse";
+    import { UserDto } from "src/dto/userInfoResponse";
+    import { WorkspaceDto } from "src/dto/workspacesResponse";
+    import { Group, GroupId, Groups } from "src/storages/groups/groups";
+    import { OrganizationImpl } from "src/storages/organizations/organization.impl";
+    import { OrganizationId } from "src/storages/organizations/organizations";
+    import { Organization } from "src/storages/organizations/organization";
+    export class GroupImpl extends Group implements Disposable {
+        private readonly context;
+        readonly organization: Organization;
+        private _isDisposed;
+        private _content?;
+        private _members?;
+        constructor(context: Context, organization: Organization);
+        initFrom(id: GroupId): Promise<Group>;
+        get id(): GroupId;
+        get group(): AccessGroupDto;
+        getWorkspaces(): Promise<WorkspaceDto[]>;
+        get members(): UserDto[];
+        setName(name: string): Promise<void>;
+        setPermits(permits: {
+            isAdmin: boolean;
+        }): Promise<void>;
+        setWorkspaces(workspaces: string[]): Promise<void>;
+        setMembersIds(members: string[]): Promise<void>;
+        get isDisposed(): boolean;
+        dispose(): void;
+    }
+    export class GroupsImpl extends Groups {
+        readonly organization: OrganizationImpl;
+        private readonly context;
+        private _groups;
+        constructor(organization: OrganizationImpl, context: Context);
+        initialize(): Promise<void>;
+        create(name: string, organizationId: OrganizationId, permits: {
+            isAdmin: boolean;
+        }, memberIds: string[]): Promise<Group>;
+        get(id: GroupId): Group | undefined;
+        delete(id: GroupId): Promise<void>;
+        /**
+         * Init access groups.
+         */
+        internalInit(): Promise<void>;
+        internalCreate(name: string, organizationId: OrganizationId, permits: {
+            isAdmin: boolean;
+        }, memberIds: string[]): Promise<Group>;
+        /**
+         * Delete group.
+         * @param id
+         */
+        internalDeleteGroup(id: GroupId): Promise<void>;
+    }
+}
+declare module "src/storages/chats/answer.impl" {
+    import { Context } from "src/context";
+    import { AnswerDto, AnswerStatus, FetchTokensResponse, SourceDto, StepType } from "src/dto/chatResponse";
+    import { Answer, AnswerId } from "src/storages/chats/answer";
+    import { Chat } from "src/storages/chats/chat";
+    export class AnswerImpl extends Answer {
+        private readonly chat;
+        private readonly context;
+        private _content?;
+        private _steps?;
+        private _status?;
+        private _id?;
+        constructor(chat: Chat, context: Context);
+        initFromData(answer: AnswerDto): Promise<AnswerImpl>;
+        initFromId(id: AnswerId): Promise<AnswerImpl>;
+        get id(): string;
+        get status(): AnswerStatus;
+        private getStep;
+        sources(type: StepType): Promise<SourceDto[]>;
+        fetch(): Promise<void>;
+        fetchTokens(type: StepType, token_start_at: number): Promise<FetchTokensResponse>;
+        cancel(): Promise<void>;
+    }
+}
+declare module "src/storages/chats/chat.impl" {
+    import { Chat, ChatAnswerType } from "src/storages/chats/chat";
+    import { Disposable } from "src/disposable";
+    import { Answer } from "src/storages/chats/answer";
+    import { ChatDto } from "src/dto/chatResponse";
+    import { Context } from "src/context";
+    import { Organization } from "src/storages/organizations/organization";
+    export class ChatImpl extends Chat implements Disposable {
+        private readonly context;
+        readonly organization: Organization;
+        private _isDisposed;
+        private readonly _answers;
+        private _content?;
+        constructor(context: Context, organization: Organization);
+        initFrom(chat: ChatDto): Promise<ChatImpl>;
+        get id(): string;
+        get name(): string;
+        get collection(): readonly Answer[];
+        get isDisposed(): boolean;
+        ask(message: string, answerType: ChatAnswerType): Promise<Answer>;
+        dispose(): void;
+    }
+}
+declare module "src/storages/chats/chats.impl" {
+    import { Context } from "src/context";
+    import { OrganizationImpl } from "src/storages/organizations/organization.impl";
+    import { OrganizationId } from "src/storages/organizations/organizations";
+    import { Chat } from "src/storages/chats/chat";
+    import { Chats } from "src/storages/chats/chats";
+    export class ChatsImpl extends Chats {
+        readonly organization: OrganizationImpl;
+        private readonly context;
+        private readonly _chats;
+        constructor(organization: OrganizationImpl, context: Context);
+        initFrom(organizationId: OrganizationId): Promise<void>;
+        get collection(): readonly Chat[];
+        get(id: string): Chat;
+        tryGet(id: string): Chat | undefined;
+        create(): Promise<Chat>;
+        delete(id: string): Promise<void>;
+    }
+}
+declare module "src/storages/organizations/organization.impl" {
+    import { OrganizationId } from "src/storages/organizations/organizations";
+    import { Disposable } from "src/disposable";
+    import { OrganizationDto } from "src/dto/userInfoResponse";
+    import { Workspaces } from "src/storages/workspaces/workspaces";
+    import { Context } from "src/context";
+    import { Organization } from "src/storages/organizations/organization";
+    import { Groups } from "src/storages/groups/groups";
+    import { Chats } from "src/storages/chats/chats";
+    export class OrganizationImpl extends Organization implements Disposable {
+        private readonly context;
+        private _isDisposed;
+        private _isAdmin;
+        private _content?;
+        private readonly _workspaces;
+        private readonly _accessGroups;
+        private readonly _chats;
+        constructor(context: Context);
+        initFrom(content: OrganizationDto, isAdmin: boolean): Promise<OrganizationImpl>;
+        get isAdmin(): boolean;
+        get isDisposed(): boolean;
+        dispose(): void;
+        get id(): OrganizationId;
+        get name(): string;
+        get description(): string;
+        get workspaces(): Workspaces;
+        get accessGroups(): Groups;
+        get chats(): Chats;
+        createInviteLink(emails: string[], accessGroups: string[]): Promise<void>;
+    }
+}
+declare module "src/storages/organizations/organizations.impl" {
+    import { OrganizationId, Organizations } from "src/storages/organizations/organizations";
+    import { OrganizationImpl } from "src/storages/organizations/organization.impl";
+    import { OrganizationDto, UserSettings } from "src/dto/userInfoResponse";
+    import { Context } from "src/context";
+    import { Organization } from "src/storages/organizations/organization";
+    export class OrganizationsImpl extends Organizations {
+        readonly context: Context;
+        constructor(context: Context);
+        organizations: OrganizationImpl[];
+        currentOrganizationId?: OrganizationId;
+        get collection(): readonly Organization[];
+        get current(): OrganizationId;
+        set current(value: OrganizationId);
+        get(id: OrganizationId): Organization;
+        tryGet(id: OrganizationId): Organization | undefined;
+        contains(id: OrganizationId): boolean;
+        create(name: string, description: string): Promise<Organization>;
+        delete(id: string): Promise<void>;
+        /**
+         * Delete organization.
+         * @param id
+         */
+        internalDeleteOrganization(id: OrganizationId): Promise<void>;
+        /**
+         * Create organization.
+         * @param name
+         * @param description
+         */
+        internalCreateOrganization(name: string, description: string): Promise<OrganizationImpl>;
+        /**
+         * Init organizations from user profile.
+         * @param adminInOrganization
+         * @param organizations
+         * @param settings
+         */
+        internalInitFrom(adminInOrganization: string[], organizations: OrganizationDto[], settings: UserSettings | null | undefined): Promise<void>;
+    }
+}
+declare module "src/services/organizationService" {
+    import { Service } from "src/services/service";
+    import { Organizations } from "src/storages/organizations/organizations";
+    import { OrganizationDto, UserSettings } from "src/dto/userInfoResponse";
+    export class OrganizationService extends Service {
+        private _impl?;
+        private get impl();
+        get organizations(): Organizations;
+        initFrom(adminInOrganization: string[], organizations: OrganizationDto[], settings?: UserSettings | null): Promise<void>;
+    }
+}
+declare module "src/storages/user/userProfile.impl" {
+    import { UserProfile } from "src/storages/user/userProfile";
+    import { UserInfoResponse } from "src/dto/userInfoResponse";
+    export class UserProfileImpl extends UserProfile {
+        private content?;
+        get id(): string;
+        get name(): string;
+        get email(): string;
+        get isDeleted(): boolean;
+        get createdAt(): Date;
+        get modifiedAt(): Date;
+        initFrom(content: UserInfoResponse): void;
+    }
+}
+declare module "src/services/userProfileService" {
+    import { Service } from "src/services/service";
+    import { UserProfile } from "src/storages/user/userProfile";
+    export class UserProfileService extends Service {
+        private readonly impl;
+        get userProfile(): UserProfile;
+        fetch(): Promise<void>;
+    }
+}
+declare module "src/commands/startCommandHandler" {
+    import { CommandHandler, Command } from "src/services/commandService";
+    export class StartCommand extends Command {
+    }
+    export class StartCommandHandler extends CommandHandler<StartCommand> {
+        execute(message: StartCommand): Promise<void>;
+    }
+}
+declare module "src/internal/app.impl" {
+    import { type AppBuilder } from "src/appBuilder";
+    import { type Constructor } from "src/internal/registry";
+    import { Context } from "src/context";
+    import { type Lifetime } from "src/disposable";
+    import { type CredentialBase } from "src/credentials";
+    import { DataIslandApp } from "src/dataIslandApp";
+    import { Organizations } from "src/storages/organizations/organizations";
+    import { UserProfile } from "src/storages/user/userProfile";
+    export class DataIslandAppImpl extends DataIslandApp {
+        readonly name: string;
+        private _host;
+        private _automaticDataCollectionEnabled;
+        private readonly _registry;
+        private readonly _context;
+        private readonly _disposable;
+        constructor(name: string);
+        get context(): Context;
+        get credential(): CredentialBase | undefined;
+        set credential(value: CredentialBase);
+        get lifetime(): Lifetime;
+        resolve: <T>(type: Constructor<T>) => T | undefined;
+        get automaticDataCollectionEnabled(): boolean;
+        get host(): string;
+        get organizations(): Organizations;
+        get userProfile(): UserProfile;
+        initialize(setup: ((builder: AppBuilder) => Promise<void>) | undefined): Promise<void>;
+    }
+}
+declare module "src/internal/createApp.impl" {
+    import { type AppBuilder } from "src/appBuilder";
+    import { DataIslandApp } from "src/dataIslandApp";
+    export function _createApp(name: string, setup?: (builder: AppBuilder) => Promise<void>): Promise<DataIslandApp>;
+}
+declare module "src/index" {
+    import { type AppBuilder } from "src/appBuilder";
+    import { type DataIslandApp } from "src/dataIslandApp";
+    export * from "src/events";
+    export * from "src/disposable";
+    export * from "src/credentials";
+    export * from "src/dataIslandApp";
+    export * from "src/appBuilder";
+    export * from "src/context";
+    export * from "src/middleware";
+    export * from "src/storages/organizations/organizations";
+    export * from "src/storages/organizations/organization";
+    export * from "src/storages/workspaces/workspaces";
+    export * from "src/storages/workspaces/workspace";
+    export * from "src/storages/groups/groups";
+    export * from "src/storages/user/userProfile";
+    export * from "src/storages/files/files";
+    export * from "src/storages/files/file";
+    export * from "src/storages/files/filesPage";
+    export * from "src/storages/chats/chats";
+    export * from "src/storages/chats/chat";
+    /**
+     * Current SDK version.
+     */
+    export const SDK_VERSION: string;
+    /**
+     * Default DataIsland App name.
+     */
+    export const DEFAULT_NAME = "[DEFAULT]";
+    /**
+     * Default DataIsland App host.
+     */
+    export const DEFAULT_HOST = "https://api.dataisland.com.ua";
+    /**
+     * Returns a list of DataIsland App instances.
+     */
+    export function dataIslandInstances(): DataIslandApp[];
+    /**
+     * Returns a DataIsland App instance.
+     * @param name Optional The name of the app.
+     * @param setup Optional setup function.
+     * @returns A DataIsland App instance.
+     * @example
+     * ```js
+     * import { dataIslandApp, DEFAULT_NAME } from '@neuralinnovations/dataisland-sdk'
+     *
+     * const app = await dataIslandApp(DEFAULT_NAME, builder => {
+     *  builder.useHost("https://dataisland.com.ua")
+     *  builder.useAutomaticDataCollectionEnabled(true)
+     *  builder.useCredential(new BasicCredential("email", "password"))
+     *  })
+     * ```
+     */
+    export function dataIslandApp(name?: string, setup?: (builder: AppBuilder) => Promise<void>): Promise<DataIslandApp>;
+    export { File } from "src/storages/files/file";
+    export { FilesPage } from "src/storages/files/filesPage";
+}