@yuuvis/client-core 0.6.5

package/lib/service/dms/dms.service.d.ts

@@ -0,0 +1,153 @@
+import { Observable } from 'rxjs';
+import { DmsObject } from '../../model/dms-object.model';
+import { HttpOptions } from '../backend/backend.interface';
+import { SearchResponse, SearchResult } from '../search/search.service.interface';
+import { CoreApiResponse, ObjectCopyOptions, ObjectDeleteOptions, ObjectDeleteResult, ObjectMoveOptions } from './dms.service.interface';
+import * as i0 from "@angular/core";
+/**
+ * Service for working with dms objects: create them, delete, etc.
+ */
+export declare class DmsService {
+    #private;
+    private triggerEvent;
+    /**
+     * Create new dms object(s). Providing an array of files here instead of one will create
+     * a new dms object for every file. In this case indexdata will shared across all files.
+     * @param objectTypeId The ID of the object type to be created
+     * @param indexdata Indexdata for the new object(s)
+     * @param files File(s) to create dms objects content(s) with
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     *
+     * @returns Array of IDs of the objects that have been created
+     */
+    createDmsObject(objectTypeId: string, indexdata: any, files: File[], label?: string, silent?: boolean): Observable<string[]>;
+    /**
+     * Delete a dms object.
+     * @param id ID of the object to be deleted
+     */
+    deleteDmsObject(id: string, silent?: boolean): Observable<any>;
+    /**
+     * Restore older version of a dms object.
+     * @param id ID of the object to be restored
+     * @param version version of the object to be restored
+     */
+    restoreDmsObject(id: string, version: number, silent?: boolean): Observable<any>;
+    /**
+     * Upload (add/replace) content to a dms object.
+     * @param objectId ID of the dms object to upload the file to
+     * @param file The file to be uploaded
+     */
+    uploadContent(objectId: string, file: File): Observable<any>;
+    /**
+     * Path of dms object content file.
+     * @param objectId ID of the dms object
+     * @param version version number of the dms object
+     */
+    getContentPath(objectId: string, version?: number): string;
+    /**
+     * Original API Path of dms object content file.
+     * @param objectId ID of the dms object
+     * @param version version number of the dms object
+     * @param rendition should return rendition path of the dms object
+     */
+    getFullContentPath(objectId: string, version?: number, rendition?: boolean): string;
+    getSlideURI(objectId: string, mimeType?: string): string | undefined;
+    /**
+     * Downloads the content of dms objects.
+     *
+     * @param DmsObject[] dmsObjects Array of dms objects to be downloaded
+     * @param withVersion should download specific version of the object
+     */
+    downloadContent(objects: DmsObject[], withVersion?: boolean): void;
+    /**
+     * Fetch a dms object.
+     * @param id ID of the object to be retrieved
+     * @param version Desired version of the object
+     */
+    getDmsObject(id: string, version?: number, silent?: boolean, requestOptions?: HttpOptions | undefined): Observable<DmsObject>;
+    /**
+     * Updates a tag on a dms object.
+     * @param id The ID of the object
+     * @param tag The tag to be updated
+     * @param value The tags new value
+     */
+    setDmsObjectTag(id: string, tag: string, value: any, silent?: boolean): Observable<any>;
+    /**
+     * Deletes a tag from a dms object.
+     * @param id The ID of the object
+     * @param tag The tag to be deleted
+     */
+    deleteDmsObjectTag(id: string, tag: string, silent?: boolean): Observable<any>;
+    /**
+     * Update indexdata of a dms object.
+     * @param id ID of the object to apply the data to
+     * @param data Indexdata to be applied
+     * @param silent flag to trigger DMS_OBJECT_UPDATED event
+     */
+    updateDmsObject(id: string, data: any, silent?: boolean): Observable<DmsObject>;
+    /**
+     * Updates given objects.
+     * @param objects the objects to updated
+     */
+    updateDmsObjects(objects: {
+        id: string;
+        data: {
+            [key: string]: any;
+        };
+    }[], silent?: boolean): Observable<DmsObject[]>;
+    /**
+     * Updates a tag on a dms object.
+     * @param ids List of IDs of objects
+     * @param tag The tag to be updated
+     * @param value The tags new value
+     */
+    updateDmsObjectsTag(ids: string[], tag: string, value: any, silent?: boolean): Observable<any>;
+    /**
+     * Moves given objects to a different folder.
+     * @param folderId the id of the new parent folder
+     * @param objects objects to be moved
+     * @param options options for the move operation
+     */
+    moveDmsObjects(targetFolderId: string | null, objects: DmsObject[], options?: ObjectMoveOptions): Observable<any>;
+    /**
+     * Copy given objects to a different folder. The objects will be copied with their indexdata referencing
+     * the existing content of the source object.
+     * @param targetFolderId The ID of the target folder
+     * @param objects The objects to be copied
+     * @param options options for the copy operation
+     */
+    copyDmsObjects(targetFolderId: string | null, objects: DmsObject[], options?: ObjectCopyOptions): Observable<CoreApiResponse>;
+    /**
+     * Get a bunch of dms objects.
+     * @param ids List of IDs of objects to be retrieved
+     */
+    getDmsObjects(ids: string[], silent?: boolean): Observable<DmsObject[]>;
+    /**
+     * Delete a bunch of dms objects.
+     * @param ids List of IDs of objects to be deleted
+     * @param options Options for the delete operation
+     * @returns Array of delete results.
+     */
+    deleteDmsObjects(objects: string[] | {
+        id: string;
+        subject: string;
+    }[], options?: ObjectDeleteOptions): Observable<ObjectDeleteResult[]>;
+    /**
+     * Fetch a dms object versions.
+     * @param id ID of the object to be retrieved
+     */
+    getDmsObjectVersions(id: string): Observable<DmsObject[]>;
+    getDmsObjectVersion(id: string, version: number): Observable<DmsObject>;
+    coreApiResponseToDmsObject(res: CoreApiResponse): DmsObject;
+    batchUpdateTag(ids: string[], tag: string, value: any): Observable<any[]>;
+    batchDeleteTag(ids: string[], tag: string): Observable<any[]>;
+    batchDelete(ids: string[]): Observable<any[]>;
+    batchGet(ids: string[]): Observable<any[]>;
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse: SearchResponse): SearchResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DmsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DmsService>;
+}

package/lib/service/dms/dms.service.interface.d.ts

@@ -0,0 +1,59 @@
+export interface ObjectDeleteOptions {
+    silent?: boolean;
+    waitForSearchConsistency?: boolean;
+    greedy?: boolean;
+}
+export interface ObjectDeleteResult {
+    id: string;
+    properties?: {
+        [key: string]: {
+            value: any;
+        };
+    };
+    _error?: ObjectDeleteError;
+}
+export interface ObjectDeleteError {
+    status: number;
+    message: string;
+}
+export interface ObjectMoveOptions {
+    waitForSearchConsistency?: boolean;
+    silent?: boolean;
+}
+export interface ObjectCopyOptions {
+    waitForSearchConsistency?: boolean;
+}
+export interface CoreApiObject {
+    properties: Record<string, CoreApiObjectProperty>;
+    contentStreams?: Partial<ContentStream>[];
+}
+export interface CoreApiObjectProperty {
+    value: unknown;
+}
+export interface ContentStream {
+    contentStreamId: string;
+    repositoryId: string;
+    digest: string;
+    fileName: string;
+    size: number;
+    archivePath?: string;
+    range?: string;
+    mimeType: string;
+}
+export interface CoreApiBatchResponse {
+    hasMoreItems: boolean;
+    numItems: number;
+    objects: CoreApiResponse[];
+    totalNumItems: number;
+}
+export interface CoreApiResponse {
+    properties: Record<string, CoreApiObjectProperty>;
+    contentStreams?: ContentStream[];
+    options: {
+        'system:response': {
+            httpStatusCode: number;
+            serviceErrorCode?: number;
+            message: string;
+        };
+    };
+}

package/lib/service/event/event.interface.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Triggerable and Subscribable events
+ */
+export interface YuvEvent {
+    /**
+     * type
+     */
+    type: string;
+    /**
+     * data to be passed along with the event
+     */
+    data?: any;
+}

package/lib/service/event/event.service.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+import { YuvEvent } from './event.interface';
+import * as i0 from "@angular/core";
+/**
+ * Service for providing triggered events
+ */
+export declare class EventService {
+    #private;
+    event$: Observable<YuvEvent>;
+    /**
+     * Trigger an global event
+     * @param type Type/key of the event
+     * @param data Data to be send along with the event
+     */
+    trigger(type: string, data?: any): void;
+    /**
+     * Listen on a triggered event
+     * @param types Type/key of the event
+     */
+    on(...types: string[]): Observable<YuvEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventService>;
+}

package/lib/service/event/events.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Events emitted by parts of the application
+ */
+export declare enum YuvEventType {
+    LOGOUT = "yuv.user.logout",
+    CLIENT_LOCALE_CHANGED = "yuv.user.locale.client.changed",
+    DMS_OBJECT_LOADED = "yuv.dms.object.loaded",
+    DMS_OBJECT_CREATED = "yuv.dms.object.created",
+    DMS_OBJECT_DELETED = "yuv.dms.object.deleted",
+    DMS_OBJECT_UPDATED = "yuv.dms.object.updated",
+    DMS_OBJECTS_MOVED = "yuv.dms.objects.moved"
+}

package/lib/service/idm/idm.interface.d.ts

@@ -0,0 +1,5 @@
+export interface OrganizationSetEntry {
+    id: string;
+    title: string;
+    type: 'user' | 'role';
+}

package/lib/service/idm/idm.service.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { OrganizationSetEntry } from './idm.interface';
+import * as i0 from "@angular/core";
+export declare class IdmService {
+    #private;
+    queryOrganizationEntity(term: string, targetTypes: string[], size?: number): Observable<OrganizationSetEntry[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdmService>;
+}

package/lib/service/logger/logger-console.service.d.ts

@@ -0,0 +1,20 @@
+import { ConfigService } from '../config/config.service';
+import { ILogger } from './logger.interface';
+import * as i0 from "@angular/core";
+/**
+ * @ignore
+ */
+export declare class LoggerConsoleService implements ILogger {
+    private config;
+    constructor(config: ConfigService);
+    private styles;
+    private apply;
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    private shouldLog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerConsoleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerConsoleService>;
+}

package/lib/service/logger/logger.d.ts

@@ -0,0 +1,17 @@
+import { ILogger } from './logger.interface';
+/**
+ * Set up the default logger.
+ * The default logger doesn't actually log anything;
+ * but, it provides the Dependency-Injection (DI) token that the rest of the
+ * application can use for dependency resolution. Each platform can then override
+ * this with a platform-specific logger implementation.
+ *
+ * @ignore
+ */
+export declare class Logger implements ILogger {
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+}

package/lib/service/logger/logger.interface.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface providing a default logger, that is used for the Dependency-Injection (DI) token.
+ */
+export interface ILogger {
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+}

package/lib/service/notification/notification.service.d.ts

@@ -0,0 +1,71 @@
+import * as i0 from "@angular/core";
+/**
+ * Shows a message after completing each action.
+ */
+export declare class NotificationService {
+    #private;
+    /**
+     * Set to true to suppress any notifications
+     */
+    silent: boolean;
+    /**
+     * Default Notofication Options
+     *
+     */
+    private options;
+    constructor();
+    /**
+     * Show info colored massage (blue)
+     *
+     * @param string title
+     * @param string msg
+     */
+    info(title: string, msg?: string): void;
+    /**
+     * Show success colored massage (green)
+     * @param string title
+     * @param string msg
+     */
+    success(title: string, msg?: string): void;
+    /**
+     * can not be in use
+     *
+     * @param string title
+     * @param string msg
+     */
+    wait(title: string, msg?: string): void;
+    /**
+     * Show error colored massage (red)
+     *
+     * @param string title
+     * @param string msg
+     */
+    error(title: string, msg?: string): void;
+    /**
+     * Show warning colored massage (yellow)
+     *
+     * @param string title
+     * @param string msg
+     */
+    warning(title: string, msg?: string): void;
+    /**
+     * Public wrapper for accessing the Toastr
+     *
+     * @param string title
+     * @param string msg
+     * @param string mode
+     * @param _options
+     */
+    private toast;
+    /**
+     * Accessing the toastr service
+     *
+     * @param string msg
+     * @param string title
+     * @param options
+     * @param string mode
+     */
+    private doToast;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}

package/lib/service/object-config/object-config.interface.d.ts

@@ -0,0 +1,62 @@
+import { ObjectTypeFieldInternalType } from "../system/object-form.interface";
+import { VirtualObjectType } from "../system/system.interface";
+/**
+ * Config defining the most important/interessting fields for
+ * a certain object type. They'll be used to render result lists
+ * as well as headers for onbjects of that type.
+ */
+export interface ObjectConfig {
+    objectTypeId: string;
+    icon?: ObjectConfigIcon;
+    title?: ObjectConfigProperty;
+    description?: ObjectConfigProperty;
+    meta?: ObjectConfigProperty;
+    aside?: ObjectConfigProperty;
+    actions?: ObjectConfigAction[];
+    badges?: ObjectConfigBadge[];
+}
+export interface ObjectConfigIcon {
+    svg: string;
+}
+export interface ObjectConfigAction {
+    id: string;
+}
+export interface ObjectConfigBadge {
+    label: string;
+}
+export interface ObjectConfigProperty {
+    label: string;
+    propertyName: string;
+}
+export interface StoredObjectConfig {
+    main: ObjectConfigRecord;
+    buckets: ObjectConfigBucket[];
+}
+export type ObjectConfigRecord = Record<string, ObjectConfig>;
+export interface ObjectConfigBucket {
+    id: string;
+    configs: ObjectConfigRecord;
+}
+export interface ResolvedObjectConfig {
+    id: string;
+    objectTypeId: string;
+    icon?: ResolvedObjectConfigItem;
+    title: ResolvedObjectConfigItem;
+    description?: ResolvedObjectConfigItem;
+    meta?: ResolvedObjectConfigItem;
+    aside?: ResolvedObjectConfigItem;
+    actions?: ObjectConfigAction[];
+    badges?: ObjectConfigBadge[];
+    instanceData?: Record<string, unknown>;
+}
+export interface ResolvedObjectConfigItem {
+    propertyName: string;
+    rendererType?: RendererType;
+    value?: any;
+    meta?: Record<string, any>;
+}
+export type RendererType = Partial<ObjectTypeFieldInternalType | string>;
+export interface ConfigTypeOption {
+    bucket?: string;
+    type: VirtualObjectType;
+}

package/lib/service/object-config/object-config.service.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { VirtualObjectType } from '../system/system.interface';
+import { ObjectConfig, ObjectConfigRecord, ResolvedObjectConfig } from './object-config.interface';
+import * as i0 from "@angular/core";
+/**
+ * Service managing the configuarions for object types.
+ * Configuration means that you can pick certain fields
+ * of an object type and assign them to a config object.
+ */
+export declare class ObjectConfigService {
+    #private;
+    OBJECT_CONFIG_STORAGE_KEY: string;
+    init(): Observable<any>;
+    getObjectConfigs$(bucket?: string, includeDefaults?: boolean): Observable<ObjectConfigRecord>;
+    /**
+     * Register default object configs. Apps can pre-define how their
+     * objects should be rendered.
+     * @param bucket Name of a bucket to bind configs to (usually the ID of the app) to
+     * separate the configs from other apps. If not provided configs will be saved for
+     * the global scope
+     */
+    registerDefaults(configs: ObjectConfigRecord, bucket?: string): void;
+    unregisterDefaults(configs: ObjectConfigRecord, bucket?: string): void;
+    /**
+     * Get object config for an object type.
+     * @param objectTypeId ID of the object type to get the config for
+     * @param bucket Optional bucket ID to fetch the config from. Buckets
+     * define separated areas to store/receive those configs. This way
+     * components/apps can store different object configs than the ones
+     * used accross the whole client application.
+     */
+    getObjectConfig(type: VirtualObjectType, bucket?: string): ObjectConfig;
+    saveObjectConfig(type: VirtualObjectType, config: ObjectConfig, bucket?: string): Observable<any>;
+    getDefaultConfig(objectTypeID: string): ObjectConfig;
+    getResolvedObjectConfig(data: Record<string, any>, type: VirtualObjectType, bucket?: string, includeDefaults?: boolean): ResolvedObjectConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectConfigService>;
+}

package/lib/service/pending-changes/pending-changes-component.interface.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Interface to be implemented by all components (state components) that are aware of pending changes
+ */
+export interface PendingChangesComponent {
+    hasPendingChanges: () => boolean;
+}

package/lib/service/pending-changes/pending-changes-guard.service.d.ts

@@ -0,0 +1,14 @@
+import { CanDeactivate } from '@angular/router';
+import { PendingChangesComponent } from './pending-changes-component.interface';
+import { PendingChangesService } from './pending-changes.service';
+import * as i0 from "@angular/core";
+/**
+ * Providing a `PendingChangesComponent`.
+ */
+export declare class PendingChangesGuard implements CanDeactivate<PendingChangesComponent> {
+    private pendingChanges;
+    constructor(pendingChanges: PendingChangesService);
+    canDeactivate(component: PendingChangesComponent): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PendingChangesGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PendingChangesGuard>;
+}

package/lib/service/pending-changes/pending-changes.service.d.ts

@@ -0,0 +1,57 @@
+import { Observable } from 'rxjs';
+import { PendingChangesComponent } from './pending-changes-component.interface';
+import * as i0 from "@angular/core";
+/**
+ * EditingObserver service is used to track changes made inside the application, that should prevent
+ * doing something or going somewhere before the changes are persisted or ignored. For example when
+ * the user starts editing form data and tries to navigate away before saving the changes, this service
+ * will take care of notifying the user.
+ *
+ * It is working kind of like a registry for ongoing tasks that need to be monitored. Every component
+ * that needs to be aware of changes to be persisted can start a task and finish it when everything is done.
+ *
+ * Other components can ask the service for pending tasks to know whether or not to execute an action
+ * (e.g. list component will subscribe and prevent selecting another list item, if changes to the previous one haven't be finished)
+ *
+ * app.component will prevent relevant route changes while tasks are pending.
+ */
+export declare class PendingChangesService {
+    #private;
+    tasks$: Observable<{
+        id: string;
+        message?: string;
+    }[]>;
+    /**
+     * Registers a task to be pending.
+     * @param message alert message
+     * @returns Unique id to be used for finishing this task
+     */
+    startTask(message: string): string;
+    /**
+     * Finishes a task
+     * @param id The id of the task to be finished. This is the one the component got from startTask()
+     */
+    finishTask(id: string): void;
+    /**
+     * Returns whether or not the service has pending tasks.
+     * If an id is provided, the method will check existence of one specific task.
+     *
+     * @param id The id of the task to be checked
+     * @returns
+     */
+    hasPendingTask(id?: string | string[]): boolean;
+    /**
+     * Returns whether or not the component|service has pending tasks.
+     * Checks via confirm dialog
+     * @param component
+     * @returns
+     */
+    check(component?: PendingChangesComponent): boolean;
+    checkForPendingTasks(taskIds: string | string[]): boolean;
+    /**
+     * Clear list of pending tasks
+     */
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PendingChangesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PendingChangesService>;
+}

package/lib/service/prediction/prediction.interface.d.ts

@@ -0,0 +1,18 @@
+export interface PredictionClassifyResult {
+    objectId: string;
+    properties: PredictionClassifyResultItem[];
+}
+export interface PredictionClassifyResultItem {
+    type: string;
+    probability: number;
+}
+export interface PredictionExtractResult {
+    objectId: string;
+    properties: Record<string, PredictionExtractResultItem[]>;
+}
+export interface PredictionExtractResultItem {
+    value: string;
+    probability: number;
+    boundingBox?: number[];
+    page?: number;
+}

package/lib/service/prediction/prediction.service.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { PredictionClassifyResult, PredictionExtractResult } from './prediction.interface';
+import * as i0 from "@angular/core";
+export declare class PredictionService {
+    #private;
+    classify(objectIDs: string[], schemaObjectTypeId?: string): Observable<Record<string, PredictionClassifyResult>>;
+    /**
+     * @param schemaObjectTypeId
+     * @param objectIDs
+     * @returns  Observable<Record<string, PredictionClassifyResult>> string is objectID
+     */
+    extract(schemaObjectTypeId: string, objectIDs: string[]): Observable<Record<string, PredictionExtractResult>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PredictionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PredictionService>;
+}

package/lib/service/search/search.service.d.ts

@@ -0,0 +1,46 @@
+import { Observable } from 'rxjs';
+import { AggregateResult, SearchQuery, SearchResponse, SearchResult } from './search.service.interface';
+import * as i0 from "@angular/core";
+export declare class SearchService {
+    #private;
+    static DEFAULT_QUERY_SIZE: number;
+    /**
+     * Execute a search query ans transform the result to a SearchResult object
+     * @param query The search query
+     * @returns Observable of a SearchResult
+     */
+    search(query: SearchQuery): Observable<SearchResult>;
+    /**
+     * Execute a raw search query and return the result as is.
+     * @param query The search query
+     * @returns Observable of the raw search result
+     */
+    searchRaw(query: SearchQuery): Observable<any>;
+    /**
+     * Search for objects in the dms using CMIS like SQL syntax.
+     * @param statement The query statement
+     * @param size The number of items to return
+     * @returns Observable of a SearchResult
+     */
+    searchCmis(statement: string, size?: number): Observable<SearchResult>;
+    /**
+     * Fetch aggragations for a given query.
+     * @param q The query
+     * @param aggregations List of aggregations to be fetched (e.g. `enaio:objectTypeId`
+     * to get an aggregation of object types)
+     */
+    aggregate(q: SearchQuery, aggregations: string[]): Observable<AggregateResult>;
+    /**
+     * Go to a page of a search result.
+     * @param searchResult The search result (that supports pagination)
+     * @param page The number of the page to go to
+     */
+    getPage(query: SearchQuery, page: number): Observable<SearchResult>;
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse: SearchResponse): SearchResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}