@rentman/rm-core 2.0.6 → 2.0.7

package/dist/src/models/CollectionResourceOptions.d.ts

@@ -1,27 +1,27 @@
-import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { ConversionMap, ItemType, OnChangeFunction } from '../types';
-export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
-export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isInitialCall: boolean) => void;
-export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
-export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
-export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
-export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
-    editItems: boolean;
-    remoteItems: boolean;
-    editCollection: boolean;
-    enableSave: boolean;
-    callOnAddWithInitialItems: boolean;
-    /**
-     * @deprecated
-     * You should use itemResource.onChange and compare previous.id with fields.id
-     */
-    onItemsCreated: OnItemsCreatedCallback;
-    onChange: OnChangeFunction;
-    onAdd: CollectionResourceOnAddCallback<ItemTypeType>;
-    onRemove: CollectionResourceCallback<ItemTypeType>;
-    onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
-    onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;
-    resourceKey: string | null;
-    custom: any;
-    constructor(values: CollectionResourceOptionsInterface<ItemTypeType>);
-}
+import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
+import { ConversionMap, ItemType, OnChangeFunction } from '../types';
+export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isInitialCall: boolean) => void;
+export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
+export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
+export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
+export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
+    editItems: boolean;
+    remoteItems: boolean;
+    editCollection: boolean;
+    enableSave: boolean;
+    callOnAddWithInitialItems: boolean;
+    /**
+     * @deprecated
+     * You should use itemResource.onChange and compare previous.id with fields.id
+     */
+    onItemsCreated: OnItemsCreatedCallback;
+    onChange: OnChangeFunction;
+    onAdd: CollectionResourceOnAddCallback<ItemTypeType>;
+    onRemove: CollectionResourceCallback<ItemTypeType>;
+    onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
+    onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;
+    resourceKey: string | null;
+    custom: any;
+    constructor(values: CollectionResourceOptionsInterface<ItemTypeType>);
+}

package/dist/src/models/CollectionViewResource.d.ts

@@ -1,7 +1,7 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { CollectionResourceFactory } from '../factories';
-import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
-import { ItemType } from '../types';
-export declare class CollectionViewResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
-    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transactionCache: TransactionCache);
-}
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { CollectionResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
+import { ItemType } from '../types';
+export declare class CollectionViewResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
+    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transactionCache: TransactionCache);
+}

package/dist/src/models/EditResource.d.ts

@@ -1,16 +1,16 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap, ItemType, PromiseInterface } from '../types';
-export declare class EditResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
-    protected localCopies: Array<FieldMap<ItemTypeType>>;
-    fields: FieldMap<ItemTypeType>;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
-    isNew(): boolean;
-    copyFields(destination?: FieldMap<ItemTypeType>): FieldMap<ItemTypeType>;
-    /**
-     * @description
-     * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
-     */
-    setFields(values: FieldMap<ItemTypeType>): PromiseInterface<this>;
-}
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
+import { FieldMap, ItemType, PromiseInterface } from '../types';
+export declare class EditResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
+    protected localCopies: Array<FieldMap<ItemTypeType>>;
+    fields: FieldMap<ItemTypeType>;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
+    isNew(): boolean;
+    copyFields(destination?: FieldMap<ItemTypeType>): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
+     */
+    setFields(values: FieldMap<ItemTypeType>): PromiseInterface<this>;
+}

package/dist/src/models/ItemEntry.d.ts

@@ -1,19 +1,19 @@
-import { ColumnSet } from '../classes';
-import { ItemEntryFactory } from '../factories';
-import { ItemId, ItemType } from '../types';
-export declare class ItemEntry<ItemTypeType extends ItemType = any> {
-    private factory;
-    itemType: ItemTypeType;
-    itemId: ItemId;
-    columns: ColumnSet<ItemTypeType>;
-    id: number;
-    reloadQueued: boolean;
-    constructor(factory: ItemEntryFactory, itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
-    queueReload(): this;
-    isLocal(): boolean;
-    isLockable(): boolean;
-    toJSON(): {
-        id: number;
-        columns: ColumnSet<ItemTypeType>;
-    };
-}
+import { ColumnSet } from '../classes';
+import { ItemEntryFactory } from '../factories';
+import { ItemId, ItemType } from '../types';
+export declare class ItemEntry<ItemTypeType extends ItemType = any> {
+    private factory;
+    itemType: ItemTypeType;
+    itemId: ItemId;
+    columns: ColumnSet<ItemTypeType>;
+    id: number;
+    reloadQueued: boolean;
+    constructor(factory: ItemEntryFactory, itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
+    queueReload(): this;
+    isLocal(): boolean;
+    isLockable(): boolean;
+    toJSON(): {
+        id: number;
+        columns: ColumnSet<ItemTypeType>;
+    };
+}

package/dist/src/models/ItemEntryOptions.d.ts

@@ -1,9 +1,9 @@
-import { ApiRequestColumnMap, ApiRequestColumns, EntryParentNull } from '../types';
-export declare type ItemEntryOptionsInterface = Partial<ItemEntryOptions>;
-export declare class ItemEntryOptions {
-    columns: ApiRequestColumns;
-    parent: EntryParentNull;
-    templateOptions: any;
-    templateColumns: ApiRequestColumnMap;
-    constructor(values: ItemEntryOptionsInterface);
-}
+import { ApiRequestColumnMap, ApiRequestColumns, EntryParentNull } from '../types';
+export declare type ItemEntryOptionsInterface = Partial<ItemEntryOptions>;
+export declare class ItemEntryOptions {
+    columns: ApiRequestColumns;
+    parent: EntryParentNull;
+    templateOptions: any;
+    templateColumns: ApiRequestColumnMap;
+    constructor(values: ItemEntryOptionsInterface);
+}

package/dist/src/models/ItemResource.d.ts

@@ -1,87 +1,87 @@
-import { TransactionCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResourceOptions } from '../models';
-import { EntryParentNull, FieldMap, ItemType, ResponseColumn } from '../types';
-export declare abstract class ItemResource<ItemTypeType extends ItemType = any> {
-    protected readonly factory: ItemResourceFactory;
-    readonly entry: ItemEntry<ItemTypeType>;
-    readonly options: ItemResourceOptions<ItemResource<ItemTypeType>>;
-    protected readonly _isNew: boolean;
-    protected readonly transaction: TransactionCache;
-    columns: {
-        [columnId: string]: ResponseColumn;
-    };
-    fields: Readonly<FieldMap<ItemTypeType>>;
-    initial: Readonly<FieldMap<ItemTypeType>>;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemResource<ItemTypeType>>, _isNew: boolean, transaction: TransactionCache);
-    onConstruct(): void;
-    /**
-     * Fetches the ItemResource's parent with the current fields
-     *
-     * ----------------
-     *
-     * @remark
-     * Use this if you need to get the parent after an item has been deleted
-     */
-    getParent(fromInitial?: boolean): EntryParentNull;
-    /**
-     * @deprecated
-     * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead
-     */
-    callOnChange(previous: FieldMap<ItemTypeType>): void;
-    /**
-     * @description
-     * Utility function to easily check if a field is changed.
-     * Will return `false` if the field is changed
-     *
-     * @example
-     * onChange: (
-     *     itemResource,
-     *     previous,
-     *     compareItemField
-     * ) {
-     *     if (!compareItemField('columnId')) {
-     *         processItem(itemResource);
-     *     }
-     * }
-     */
-    compareItemField(columnId: keyof FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): boolean;
-    hasChanges(): boolean;
-    setTransactionParameters(parameters: any): void;
-    /**
-     * @description
-     * 'isNew' means that the {@link ItemEntry ItemEntry} is a local item and that this resource was created when the {@link ItemEntry ItemEntry} was first created
-     */
-    isNew(): boolean;
-    isLocal(): boolean;
-    /**
-     * @description
-     * Removes the reference to the {@link ItemResource ItemResource} from the {@link TransactionCache TransactionCache}, so that the OnChange callback won't be called anymore.
-     *
-     * Warning:
-     * This doesn't revert any changes made to the item, in order to revert the changes you should use {@link TransactionItemHandler.clearItemEntry TransactionItemHandler.clearItemEntry}
-     */
-    clearResource(): void;
-    toJSON(): {
-        columns: string[];
-        fields: Readonly<FieldMap<ItemTypeType>>;
-        entry: ItemEntry<ItemTypeType>;
-    };
-    /**
-     * @description
-     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
-     *
-     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
-     */
-    getDerivedValue<T extends any = any>(columnPath: string[] | string): T | undefined;
-    /**
-     * @description
-     * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
-     *
-     * ---------------------
-     *
-     * @remark
-     * Assumes the derived item's values are already cached
-     */
-    getDerivedValues(columnPath: string[]): Readonly<FieldMap> | undefined;
-}
+import { TransactionCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResourceOptions } from '../models';
+import { EntryParentNull, FieldMap, ItemType, ResponseColumn } from '../types';
+export declare abstract class ItemResource<ItemTypeType extends ItemType = any> {
+    protected readonly factory: ItemResourceFactory;
+    readonly entry: ItemEntry<ItemTypeType>;
+    readonly options: ItemResourceOptions<ItemResource<ItemTypeType>>;
+    protected readonly _isNew: boolean;
+    protected readonly transaction: TransactionCache;
+    columns: {
+        [columnId: string]: ResponseColumn;
+    };
+    fields: Readonly<FieldMap<ItemTypeType>>;
+    initial: Readonly<FieldMap<ItemTypeType>>;
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemResource<ItemTypeType>>, _isNew: boolean, transaction: TransactionCache);
+    onConstruct(): void;
+    /**
+     * Fetches the ItemResource's parent with the current fields
+     *
+     * ----------------
+     *
+     * @remark
+     * Use this if you need to get the parent after an item has been deleted
+     */
+    getParent(fromInitial?: boolean): EntryParentNull;
+    /**
+     * @deprecated
+     * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead
+     */
+    callOnChange(previous: FieldMap<ItemTypeType>): void;
+    /**
+     * @description
+     * Utility function to easily check if a field is changed.
+     * Will return `false` if the field is changed
+     *
+     * @example
+     * onChange: (
+     *     itemResource,
+     *     previous,
+     *     compareItemField
+     * ) {
+     *     if (!compareItemField('columnId')) {
+     *         processItem(itemResource);
+     *     }
+     * }
+     */
+    compareItemField(columnId: keyof FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): boolean;
+    hasChanges(): boolean;
+    setTransactionParameters(parameters: any): void;
+    /**
+     * @description
+     * 'isNew' means that the {@link ItemEntry ItemEntry} is a local item and that this resource was created when the {@link ItemEntry ItemEntry} was first created
+     */
+    isNew(): boolean;
+    isLocal(): boolean;
+    /**
+     * @description
+     * Removes the reference to the {@link ItemResource ItemResource} from the {@link TransactionCache TransactionCache}, so that the OnChange callback won't be called anymore.
+     *
+     * Warning:
+     * This doesn't revert any changes made to the item, in order to revert the changes you should use {@link TransactionItemHandler.clearItemEntry TransactionItemHandler.clearItemEntry}
+     */
+    clearResource(): void;
+    toJSON(): {
+        columns: string[];
+        fields: Readonly<FieldMap<ItemTypeType>>;
+        entry: ItemEntry<ItemTypeType>;
+    };
+    /**
+     * @description
+     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
+     *
+     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
+     */
+    getDerivedValue<T extends any = any>(columnPath: string[] | string): T | undefined;
+    /**
+     * @description
+     * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
+     *
+     * ---------------------
+     *
+     * @remark
+     * Assumes the derived item's values are already cached
+     */
+    getDerivedValues(columnPath: string[]): Readonly<FieldMap> | undefined;
+}

package/dist/src/models/ItemResourceOptions.d.ts

@@ -1,9 +1,9 @@
-import { OnChangeFunction } from '../types';
-import { ItemResource } from './ItemResource';
-export declare type ItemResourceOptionsInterface<ItemResourceType extends ItemResource<any> = ItemResource<any>> = Partial<ItemResourceOptions<ItemResourceType>>;
-export declare class ItemResourceOptions<ItemResourceType extends ItemResource<any> = ItemResource<any>> {
-    edit: boolean;
-    remote: boolean;
-    onChange: OnChangeFunction<ItemResourceType>;
-    constructor(values: ItemResourceOptionsInterface<ItemResourceType>);
-}
+import { OnChangeFunction } from '../types';
+import { ItemResource } from './ItemResource';
+export declare type ItemResourceOptionsInterface<ItemResourceType extends ItemResource<any> = ItemResource<any>> = Partial<ItemResourceOptions<ItemResourceType>>;
+export declare class ItemResourceOptions<ItemResourceType extends ItemResource<any> = ItemResource<any>> {
+    edit: boolean;
+    remote: boolean;
+    onChange: OnChangeFunction<ItemResourceType>;
+    constructor(values: ItemResourceOptionsInterface<ItemResourceType>);
+}

package/dist/src/models/LocalViewResource.d.ts

@@ -1,7 +1,7 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
-import { ItemType } from '../types';
-export declare class LocalViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
-}
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
+import { ItemType } from '../types';
+export declare class LocalViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
+}

package/dist/src/models/RemoteViewResource.d.ts

@@ -1,7 +1,7 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
-import { ItemType } from '../types';
-export declare class RemoteViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<RemoteViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
-}
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
+import { ItemType } from '../types';
+export declare class RemoteViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<RemoteViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
+}

package/dist/src/models/Template.d.ts

@@ -1,11 +1,11 @@
-import { ColumnSet } from '../classes';
-import { TemplateFactory } from '../factories';
-import { ApiResponse, FieldMap, ItemType, ResponseColumnItemTypeMap } from '../types';
-export declare class Template<ItemTypeType extends ItemType = any> {
-    itemType: ItemTypeType;
-    response: ApiResponse;
-    fields: FieldMap<ItemTypeType>;
-    responseColumns: ResponseColumnItemTypeMap;
-    columns: ColumnSet<ItemTypeType>;
-    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalColumns: ResponseColumnItemTypeMap);
-}
+import { ColumnSet } from '../classes';
+import { TemplateFactory } from '../factories';
+import { ApiResponse, FieldMap, ItemType, ResponseColumnItemTypeMap } from '../types';
+export declare class Template<ItemTypeType extends ItemType = any> {
+    itemType: ItemTypeType;
+    response: ApiResponse;
+    fields: FieldMap<ItemTypeType>;
+    responseColumns: ResponseColumnItemTypeMap;
+    columns: ColumnSet<ItemTypeType>;
+    constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalColumns: ResponseColumnItemTypeMap);
+}

package/dist/src/models/ViewResource.d.ts

@@ -1,8 +1,8 @@
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
-import { FieldMap, ItemType } from '../types';
-export declare abstract class ViewResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
-    fields: Readonly<FieldMap<ItemTypeType>>;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
-}
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ItemResourceFactory } from '../factories';
+import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
+import { FieldMap, ItemType } from '../types';
+export declare abstract class ViewResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
+    fields: Readonly<FieldMap<ItemTypeType>>;
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
+}

package/dist/src/models/index.d.ts

@@ -1,15 +1,15 @@
-export * from './ItemEntryOptions';
-export * from './ItemResourceOptions';
-export * from './ItemEntry';
-export * from './ItemResource';
-export * from './ViewResource';
-export * from './EditResource';
-export * from './CollectionEntryOptions';
-export * from './CollectionResourceOptions';
-export * from './CollectionEntry';
-export * from './CollectionResource';
-export * from './CollectionViewResource';
-export * from './CollectionEditResource';
-export * from './Template';
-export * from './RemoteViewResource';
-export * from './LocalViewResource';
+export * from './ItemEntryOptions';
+export * from './ItemResourceOptions';
+export * from './ItemEntry';
+export * from './ItemResource';
+export * from './ViewResource';
+export * from './EditResource';
+export * from './CollectionEntryOptions';
+export * from './CollectionResourceOptions';
+export * from './CollectionEntry';
+export * from './CollectionResource';
+export * from './CollectionViewResource';
+export * from './CollectionEditResource';
+export * from './Template';
+export * from './RemoteViewResource';
+export * from './LocalViewResource';