@c8y/ngx-components/register-device/index.d.ts

Angular modules for Cumulocity IoT applications

import * as i0 from '@angular/core';
import { AfterViewInit, OnDestroy, ChangeDetectorRef, OnInit, TemplateRef, Type, Injector, InjectionToken } from '@angular/core';
import { FormlyFormOptions, FormlyFieldConfig } from '@ngx-formly/core';
import * as i3 from '@c8y/ngx-components';
import { AlertService, IRealtimeDeviceBootstrap, TenantUiService, GainsightService, FeatureCacheService, C8yStepper, DeviceBootstrapRealtimeService, ModalService, OptionsService, C8yJSONSchema, AppStateService, ExtensionFactory, ExtensionPointWithoutStateForPlugins, PluginsResolveService, GenericHookType, GenericHookOptions } from '@c8y/ngx-components';
import { FormGroup } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Subject, BehaviorSubject, Observable } from 'rxjs';
import { IDeviceRegistrationLimit, IDeviceRegistration, Paging, DeviceRegistrationService, IDeviceRegistrationCreate, DeviceRegistrationStatus, TenantService, InventoryService, IDeviceRegistrationBulkResult, DeviceRegistrationBulkService, ApplicationService, FetchClient, IResult } from '@c8y/client';
import * as i4 from '@angular/router';
import { Router, ActivatedRoute } from '@angular/router';
import { CdkStep } from '@angular/cdk/stepper';
import { BsModalRef, BsModalService } from 'ngx-bootstrap/modal';
import * as i1 from 'ngx-bootstrap/dropdown';
import * as i2 from 'ngx-bootstrap/popover';
import { TranslateService } from '@ngx-translate/core';
import { JSONSchema7 } from 'json-schema';
import * as _c8y_ngx_components_register_device from '@c8y/ngx-components/register-device';

declare class RegisterDeviceService {
    private router;
    private deviceRegService;
    private alertService;
    readonly _loading: Subject<boolean>;
    readonly _limit: BehaviorSubject<IDeviceRegistrationLimit>;
    readonly _deviceRegistrationRequests: BehaviorSubject<{
        data: IDeviceRegistration[];
        paging?: Paging<IDeviceRegistration>;
    }>;
    readonly deviceRegistrationRequests$: Observable<{
        data: IDeviceRegistration[];
        paging?: Paging<IDeviceRegistration>;
    }>;
    readonly loading$: Observable<boolean>;
    readonly limit$: Observable<IDeviceRegistrationLimit>;
    paging: Paging<IDeviceRegistration>;
    private readonly deviceRegUrl;
    private endSubscriptions;
    constructor(router: Router, deviceRegService: DeviceRegistrationService, alertService: AlertService);
    isDeviceRegistration(): boolean;
    internalListUpdate(deviceRequests: IDeviceRegistration[], pagingObject?: Paging<IDeviceRegistration>): void;
    onDeviceBootstrap(bsData: IRealtimeDeviceBootstrap): void;
    list(pageSize?: number): void;
    createMultiple(newDeviceRequests: IDeviceRegistrationCreate[]): Observable<{
        success: IDeviceRegistration[];
        failed: IDeviceRegistration[];
    }>;
    remove(id: string): void;
    accept(request: IDeviceRegistration): void;
    acceptAll(): void;
    limit(): void;
    getRequestByStatus(status: DeviceRegistrationStatus): IDeviceRegistration[];
    ngOnDestroy(): void;
    private updateStatusById;
    private removeDeviceRegistrationRequestById;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterDeviceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegisterDeviceService>;
}

interface GeneralDeviceRegistrationModelType {
    id: string;
    tenant?: {
        id: string;
    };
    group?: {
        id: string;
        name?: string;
    };
    oneTimePassword?: string;
}
declare class GeneralDeviceRegistrationComponent implements AfterViewInit, OnDestroy {
    private tenantUIService;
    private tenantService;
    private registerDeviceService;
    private inventoryService;
    private cd;
    bsModalRef: BsModalRef;
    private gainsightService;
    private featureCacheService;
    readonly MANAGEMENT = "management";
    readonly FILTER: object;
    useEST$: BehaviorSubject<boolean>;
    certificateAuthorityFeatureEnabled: Observable<boolean>;
    form: FormGroup<{}>;
    model: {
        devicesToCreate: GeneralDeviceRegistrationModelType[];
    };
    options: FormlyFormOptions;
    PRODUCT_EXPERIENCE: {
        EVENT: string;
        COMPONENT: string;
        RESULT: {
            SUCCESS: string;
            FAILURE: string;
        };
    };
    isLoading$: Observable<boolean>;
    success: {
        id: string;
    }[];
    failed: {
        id: string;
        message?: string;
        details?: any;
    }[];
    fields: FormlyFieldConfig[];
    result: Promise<void>;
    private onSuccessfulClosing;
    private onCancel;
    private destroy$;
    private lastCreatedDevices;
    constructor(tenantUIService: TenantUiService, tenantService: TenantService, registerDeviceService: RegisterDeviceService, inventoryService: InventoryService, cd: ChangeDetectorRef, bsModalRef: BsModalRef, gainsightService: GainsightService, featureCacheService: FeatureCacheService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    registerDevice(eventObject: {
        stepper: C8yStepper;
        step: CdkStep;
    }): void;
    fixErrors(event: {
        stepper: C8yStepper;
        step: CdkStep;
    }, failedRequests: any): void;
    close(): void;
    cancel(): void;
    private create;
    private canLoadTenants$;
    private getTenants$;
    private getGroups$;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralDeviceRegistrationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GeneralDeviceRegistrationComponent, "c8y-general-device-registration", never, {}, {}, never, never, true, never>;
}

declare class GeneralDeviceRegistrationService {
    private modalService;
    open(initialState?: Partial<GeneralDeviceRegistrationComponent>): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralDeviceRegistrationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GeneralDeviceRegistrationService>;
}

declare class GeneralDeviceRegistrationButtonComponent {
    private registrationService;
    constructor(registrationService: GeneralDeviceRegistrationService);
    open(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralDeviceRegistrationButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GeneralDeviceRegistrationButtonComponent, "c8y-general-device-registration-button", never, {}, {}, never, never, true, never>;
}

declare class DeviceRegistrationViewComponent implements OnInit, OnDestroy {
    private registerDeviceService;
    private bootstrapRealtimeService;
    private tenantUiService;
    private modalService;
    private translateService;
    private optionsService;
    private activatedRoute;
    private generalRegistration;
    deviceRequests$: Observable<{
        data: IDeviceRegistration[];
        paging?: Paging<IDeviceRegistration>;
    }>;
    limit$: Observable<IDeviceRegistrationLimit>;
    limitReachedInfo$: Observable<string>;
    requireSecurityToken: boolean;
    isManagementTenant: boolean;
    isLoading: boolean;
    gridOrList: 'interact-list' | 'interact-grid';
    status: typeof DeviceRegistrationStatus;
    readonly statusProps: {
        [DeviceRegistrationStatus.WAITING_FOR_CONNECTION]: {
            label: "Waiting for connection";
            icon: string;
            cls: string;
        };
        [DeviceRegistrationStatus.PENDING_ACCEPTANCE]: {
            label: "Pending acceptance";
            icon: string;
            cls: string;
        };
        [DeviceRegistrationStatus.ACCEPTED]: {
            label: "Accepted";
            icon: string;
            cls: string;
        };
        [DeviceRegistrationStatus.BLOCKED]: {
            label: "Blocked";
            icon: string;
            cls: string;
        };
    };
    private unsubscribe$;
    private readonly _securityTokenPolicy;
    constructor(registerDeviceService: RegisterDeviceService, bootstrapRealtimeService: DeviceBootstrapRealtimeService, tenantUiService: TenantUiService, modalService: ModalService, translateService: TranslateService, optionsService: OptionsService, activatedRoute: ActivatedRoute, generalRegistration: GeneralDeviceRegistrationService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    updateList(data: any): void;
    handleQueryParams(): Promise<void>;
    delete(id: string): Promise<void>;
    accept(request: IDeviceRegistration): void;
    acceptAll(): void;
    canAcceptAll(): boolean;
    loadAll(): void;
    displayMode(listClass: 'interact-list' | 'interact-grid'): void;
    setRequireSecurityToken(): Promise<void>;
    setIsManagementTenant(): Promise<void>;
    shouldShowSecurityTokenInput(data: IDeviceRegistration): boolean;
    showTokenInputBasedOnSecurityMode(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceRegistrationViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeviceRegistrationViewComponent, "c8y-device-registration-view", never, {}, {}, never, never, true, never>;
}

interface BulkFileExample {
    title: string;
    description: string;
    url: URL;
}
interface BulkDescription {
    exampleFileUrls: BulkFileExample[];
    title: string;
}
interface BulkResult {
    operationId: string;
    sourceDeviceId: string;
    message: string;
}
interface BulkFailedResult {
    error: string;
    message: string;
}

declare class BulkDeviceRegistrationModalComponent {
    private jsonschema;
    private deviceRegistrationService;
    private registerDeviceService;
    private bsModalRef;
    private gainsightService;
    private featureCacheService;
    private translateService;
    stepper: C8yStepper;
    message: string;
    success: boolean;
    pending: boolean;
    result: IDeviceRegistrationBulkResult;
    failedResult: BulkFailedResult;
    form: FormGroup<{}>;
    model: {};
    template: FormlyFieldConfig[];
    certificateAuthorityFeatureEnabled: rxjs.Observable<boolean>;
    constructor(jsonschema: C8yJSONSchema, deviceRegistrationService: DeviceRegistrationBulkService, registerDeviceService: RegisterDeviceService, bsModalRef: BsModalRef, gainsightService: GainsightService, featureCacheService: FeatureCacheService, translateService: TranslateService);
    ngOnInit(): void;
    upload(): void;
    downloadSimple(): void;
    downloadFull(): void;
    downloadEst(): void;
    download(headers: string[], fileName: string): void;
    complete(): void;
    cancel(): void;
    private getFile;
    static ɵfac: i0.ɵɵFactoryDeclaration<BulkDeviceRegistrationModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BulkDeviceRegistrationModalComponent, "bulk-device-registration", never, {}, {}, never, never, true, never>;
}

interface ApplicationExtension {
    name: string;
    description: string;
    type: string;
}
interface ExtensibleDeviceRegistrationProvider extends ApplicationExtension {
    contextPath: string;
}

declare class BulkDeviceRegistrationButtonComponent {
    private modalService;
    bulkProvidersMetaData: Promise<ExtensibleDeviceRegistrationProvider[]>;
    constructor(modalService: BsModalService);
    click(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BulkDeviceRegistrationButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BulkDeviceRegistrationButtonComponent, "extensible-device-registration-component", never, {}, {}, never, never, true, never>;
}

declare class BaseExtensibleDeviceRegistrationService {
    protected applicationService: ApplicationService;
    protected stateService: AppStateService;
    constructor(applicationService: ApplicationService, stateService: AppStateService);
    protected getMetadataUrl(contextPath: string): string;
    protected getServiceBaseUrl(contextPath: string): string;
    protected getDeviceRegistrationProviders(bulk: boolean): Promise<ExtensibleDeviceRegistrationProvider[]>;
    private listMicroservicesByUser;
    private getProvidersFromManifestExtensions;
    private getProvidersFromExtensions;
    private appSupportingExtensibleDeviceRegistrationForm;
}

interface ExtensibleDeviceRegistrationSchema {
    title: string;
    description?: string;
    pages?: JSONSchema7[];
}

declare class ExtensibleDeviceRegistrationService extends BaseExtensibleDeviceRegistrationService {
    protected applicationService: ApplicationService;
    protected stateService: AppStateService;
    private client;
    constructor(applicationService: ApplicationService, stateService: AppStateService, client: FetchClient);
    getSchema(contextPath: string): Promise<ExtensibleDeviceRegistrationSchema>;
    getDeviceRegistrationProviders(): Promise<ExtensibleDeviceRegistrationProvider[]>;
    registerDevice(contextPath: string, model: any): Promise<IResult<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleDeviceRegistrationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ExtensibleDeviceRegistrationService>;
}

declare class ExtensibleDeviceRegistrationButtonComponent implements OnInit {
    private deviceRegistrationService;
    private modalService;
    providersMetaData: Promise<ExtensibleDeviceRegistrationProvider[]>;
    constructor(deviceRegistrationService: ExtensibleDeviceRegistrationService, modalService: BsModalService);
    ngOnInit(): void;
    click(providerMetaData: ExtensibleDeviceRegistrationProvider): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleDeviceRegistrationButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExtensibleDeviceRegistrationButtonComponent, "extensible-device-registration-provider", never, {}, {}, never, never, true, never>;
}

declare class ExtensibleDeviceRegistrationModalComponent implements OnInit {
    bsModalRef: BsModalRef;
    private jsonschema;
    private registrationService;
    title: string;
    loadingErrorMessage: string;
    pages: FormlyFieldConfig[][];
    labels: string[];
    contextPath: string;
    constructor(bsModalRef: BsModalRef, jsonschema: C8yJSONSchema, registrationService: ExtensibleDeviceRegistrationService);
    ngOnInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleDeviceRegistrationModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExtensibleDeviceRegistrationModalComponent, "extensible-device-registration-modal", never, {}, {}, never, never, true, never>;
}

declare class ExtensibleDeviceRegistrationStepperComponent implements OnInit {
    private customProviderService;
    private registerDeviceService;
    private bsModalRef;
    private gainsightService;
    message: string;
    errorMessage: string;
    pendingStatus: boolean;
    forms: FormGroup[];
    model: any;
    stepper: C8yStepper;
    contextPath: string;
    labels: string[];
    steps: FormlyFieldConfig[][];
    private readonly SERVER_ERROR;
    private readonly SUCCESSFUL_REGISTRATION;
    private readonly NO_CONNECTION;
    constructor(customProviderService: ExtensibleDeviceRegistrationService, registerDeviceService: RegisterDeviceService, bsModalRef: BsModalRef, gainsightService: GainsightService);
    ngOnInit(): void;
    save(): Promise<void>;
    close(): void;
    complete(): void;
    goToFirstStep(): void;
    isRegistrationStep(): boolean;
    finalStepStatus(): string;
    private handleError;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleDeviceRegistrationStepperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExtensibleDeviceRegistrationStepperComponent, "c8y-extensible-device-registration-stepper", never, { "contextPath": { "alias": "contextPath"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BulkExtensibleDeviceRegistrationService extends BaseExtensibleDeviceRegistrationService {
    protected applicationService: ApplicationService;
    protected stateService: AppStateService;
    private client;
    constructor(applicationService: ApplicationService, stateService: AppStateService, client: FetchClient);
    getDeviceRegistrationProviders(): Promise<ExtensibleDeviceRegistrationProvider[]>;
    getBulkDescription(contextPath: string): Promise<BulkDescription>;
    upload(csv: File, contextPath: any): Promise<IResult<BulkResult>>;
    getBulkUrl(contextPath: string): string;
    private createBinaryRequestBody;
    static ɵfac: i0.ɵɵFactoryDeclaration<BulkExtensibleDeviceRegistrationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BulkExtensibleDeviceRegistrationService>;
}

declare class ExtensibleBulkDeviceRegistrationModalComponent implements OnInit {
    private jsonschema;
    private bulkExtensibleDeviceRegistrationService;
    private registerDeviceService;
    private bsModalRef;
    private gainsightService;
    stepper: C8yStepper;
    title: string;
    examples: BulkFileExample[];
    message: string;
    success: boolean;
    loadingError: boolean;
    pending: boolean;
    contextPath: string;
    result: BulkResult | BulkFailedResult;
    form: FormGroup<{}>;
    model: {};
    template: FormlyFieldConfig[];
    constructor(jsonschema: C8yJSONSchema, bulkExtensibleDeviceRegistrationService: BulkExtensibleDeviceRegistrationService, registerDeviceService: RegisterDeviceService, bsModalRef: BsModalRef, gainsightService: GainsightService);
    ngOnInit(): Promise<void>;
    upload(): Promise<void>;
    getFile(model: any): any;
    complete(): void;
    cancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleBulkDeviceRegistrationModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExtensibleBulkDeviceRegistrationModalComponent, "extensible-device-registration-modal-component", never, {}, {}, never, never, true, never>;
}

declare class ExtensibleBulkDeviceRegistrationButtonComponent implements OnInit {
    private bulkExtensibleDeviceRegistrationService;
    private modalService;
    bulkProvidersMetaData: Promise<ExtensibleDeviceRegistrationProvider[]>;
    constructor(bulkExtensibleDeviceRegistrationService: BulkExtensibleDeviceRegistrationService, modalService: BsModalService);
    ngOnInit(): void;
    click(contextPath: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleBulkDeviceRegistrationButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExtensibleBulkDeviceRegistrationButtonComponent, "extensible-device-registration-component", never, {}, {}, never, never, true, never>;
}

/**
 * A register device item is the entry point to define
 * a specific registration flow.
 */
interface RegisterDeviceItem {
    /**
     * Angular template used for Content Projection
     */
    template: TemplateRef<any> | Type<any> | Element;
    /**
     * Ordering of the device registration possibilities (high number first)
     */
    priority: number;
    /**
     * Category of registration
     */
    category: 'bulk' | 'single';
}
/**
 * Factory to implement if used in a hook for Multi Provider extension.
 */
type RegisterDeviceFactory = ExtensionFactory<RegisterDeviceItem>;

/**
 * An extension HOOK can use either a pure value:
 * ```typescript
 *  { provide: HOOK_X, useValue: { ...hookValue }, multi: true }
 * ```
 *
 * Or an array to directly register multiple:
 * ```typescript
 *  { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }
 * ```
 *
 * Or an ExtensionFactory which allows to define a get() function. This function
 * gets called on each navigation with the current route and can return values
 * async (observable or promise).
 * ```typescript
 *  { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }
 * ```
 */
type RegisterDeviceExtension = RegisterDeviceItem | RegisterDeviceItem[] | ExtensionFactory<RegisterDeviceItem>;
/**
 * A hook to use for Multi Provider extension.
 * @deprecated Consider using the `hookDeviceRegistration` function instead.
 */
declare const HOOK_DEVICE_REGISTRATION: InjectionToken<RegisterDeviceExtension>;
/**
 * You can either provide a single `RegisterDeviceExtension` as parameter:
 * ```typescript
 *  hookDeviceRegistration(...)
 * ```
 *
 * Or an array to directly register multiple:
 * ```typescript
 *  hookDeviceRegistration([...])
 * ```
 *
 * Or you provide an Service that implements `ExtensionFactory<RegisterDeviceExtension>`
 * ```typescript
 *  export class MyDeviceRegistrationFactory implements ExtensionFactory<RegisterDeviceExtension> {...}
 *  ...
 *  hookDeviceRegistration(MyDeviceRegistrationFactory)
 * ```
 * A typed alternative to `HOOK_DEVICE_REGISTRATION`.
 * @param registration The `RegisterDeviceExtension`'s or `ExtensionFactory` to be provided.
 * @returns An `Provider` to be provided in your module.
 */
declare function hookDeviceRegistration(registration: GenericHookType<RegisterDeviceExtension>, options?: Partial<GenericHookOptions>): i0.ValueProvider | i0.ClassProvider | i0.ExistingProvider;
/**
 * A service which defines device registration options.
 */
declare class RegisterDeviceExtensionService extends ExtensionPointWithoutStateForPlugins<RegisterDeviceItem> {
    private router;
    constructor(rootInjector: Injector, router: Router, plugins: PluginsResolveService);
    protected setupItemsObservable(): Observable<RegisterDeviceItem[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterDeviceExtensionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegisterDeviceExtensionService>;
}

declare class RegisterDeviceDropdownComponent {
    private registerDeviceExtensionService;
    private registerDeviceService;
    single$: Observable<_c8y_ngx_components_register_device.RegisterDeviceItem[]>;
    bulk$: Observable<_c8y_ngx_components_register_device.RegisterDeviceItem[]>;
    limit$: Observable<boolean>;
    constructor(registerDeviceExtensionService: RegisterDeviceExtensionService, registerDeviceService: RegisterDeviceService);
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterDeviceDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RegisterDeviceDropdownComponent, "c8y-register-device-dropdown", never, {}, {}, never, never, true, never>;
}

declare class RegisterDeviceModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterDeviceModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RegisterDeviceModule, never, [typeof i1.BsDropdownModule, typeof i2.PopoverModule, typeof i3.CommonModule, typeof i3.CoreModule, typeof i3.StepperModule, typeof i3.DynamicFormsModule, typeof i4.RouterModule, typeof DeviceRegistrationViewComponent, typeof GeneralDeviceRegistrationComponent, typeof GeneralDeviceRegistrationButtonComponent, typeof BulkDeviceRegistrationModalComponent, typeof BulkDeviceRegistrationButtonComponent, typeof ExtensibleDeviceRegistrationButtonComponent, typeof ExtensibleDeviceRegistrationModalComponent, typeof ExtensibleDeviceRegistrationStepperComponent, typeof ExtensibleBulkDeviceRegistrationModalComponent, typeof ExtensibleBulkDeviceRegistrationButtonComponent, typeof RegisterDeviceDropdownComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RegisterDeviceModule>;
}

declare class DeviceRegistrationFactory implements RegisterDeviceFactory {
    get(): RegisterDeviceItem[];
    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceRegistrationFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceRegistrationFactory>;
}

export { DeviceRegistrationFactory, GeneralDeviceRegistrationButtonComponent, GeneralDeviceRegistrationComponent, GeneralDeviceRegistrationService, HOOK_DEVICE_REGISTRATION, RegisterDeviceExtensionService, RegisterDeviceModule, RegisterDeviceService, hookDeviceRegistration };
export type { RegisterDeviceExtension, RegisterDeviceFactory, RegisterDeviceItem };
//# sourceMappingURL=index.d.ts.map