import * as i0 from '@angular/core';
import { Type, ViewContainerRef, ComponentRef, Injector, InjectionToken, AbstractType, Provider } from '@angular/core';
import { Observable } from 'rxjs';

/** Service to programmatically open file dialog. */
declare class PickerBrowserService {
    /**
     * Open file dialog to select files.
     * @param options picker options.
     * @returns A promise that resolves with the picked files or and empty array.
     */
    pickFiles(options: PickerBrowserOptions): Promise<File[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickerBrowserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PickerBrowserService>;
}
/** Picker options. */
interface PickerBrowserOptions {
    /** optional mime type of the files to select. (default *) */
    readonly accept?: string;
    /** allow multiple files (default true.) */
    readonly multiple?: boolean;
}

declare class ClipboardService {
    copy(data: string): Promise<void>;
    read(): Promise<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
}

declare class CompilerService {
    private readonly modules;
    render(options: RendererOptions): Promise<ComponentRef<any>>;
    resolveComponent(type: Type<any>, injector: Injector): Promise<{
        component: Type<any>;
        injector: Injector;
    }>;
    private renderComponent;
    private resolveModuleInfo;
    static ɵfac: i0.ɵɵFactoryDeclaration<CompilerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CompilerService>;
}
interface RendererOptions {
    type: Type<any>;
    inputs?: any;
    container: ViewContainerRef;
}
interface IDynamicModule {
    /** Reference to the main component of the module */
    component: Type<any>;
}

interface IDynamicService {
    injectable(): boolean;
}
declare class InjectorService {
    private readonly injector;
    get<T extends IDynamicService>(token: Type<any> | InjectionToken<any> | AbstractType<any>): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<InjectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InjectorService>;
}

declare class ResourceLoaderConfig {
    /**
     * If true, the document.baseURI will be used to build the url of the resource to load if the url is relative.
     */
    useDocumentBaseURI?: boolean;
}
/**
 *  An array of [type, url, attributes] tuple where:
 *  - `type` is the type of an asset to load `script`| `style`
 *  - `url` is the url to a style/script to load
 *  - `attributes` is a map of optional attributes to add to the element.
 */
declare type ResourceInfo = ['style' | 'script', string, Record<string, string>?];
/**
 * Services that dynamically inject scripts and styles elements to the DOM.
 */
declare class ResourceLoaderService {
    private readonly document;
    private readonly config;
    private readonly isBrowser;
    private readonly requests;
    waitForPendings(): Promise<void>;
    /**
     * Injects styles and scripts from given urls to the head of the DOM.
     * This method loads assets from same url once and the assets are
     * loaded in the same order that given.
     * @param resources Resources to load.
     */
    loadAllSync(resources: ResourceInfo[]): Observable<ResourceInfo[]>;
    /**
     * Injects styles and scripts from given urls to target place in DOM
     * This method loads style and script from same url once.
     * @param resources Resources to load.
     */
    loadAllAsync(resources: ResourceInfo[]): Observable<ResourceInfo[]>;
    private createRequests;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceLoaderService>;
}
declare const ResourceLoaderConfigProvider: (config: Partial<ResourceLoaderConfig>) => Provider;

export { ClipboardService, CompilerService, InjectorService, PickerBrowserService, ResourceLoaderConfig, ResourceLoaderConfigProvider, ResourceLoaderService };
export type { IDynamicModule, IDynamicService, PickerBrowserOptions, RendererOptions };