@telia-ace/knowledge-widget-types-grid 1.0.1

package/lib/data/legacy-conversion.d.ts

@@ -0,0 +1,75 @@
+import { ContactMethodType as ContactMethod } from '@telia-ace/knowledge-widget-adapters';
+import { Category, DialogItem, Guide, Notification, NotificationList, Tag } from '@telia-ace/knowledge-widget-core';
+import { DataError, ServiceClientQueryType } from './data-client';
+export declare type MatchResult = {
+    guides: Guide[];
+    matches: number;
+    topNotifications: Notification[];
+    middleNotifications: Notification[];
+    bottomNotifications: Notification[];
+    notificationLists: NotificationList[];
+    tags: Tag[];
+    byCategory: {
+        id: string;
+        guides: Guide[];
+        matches: number;
+    }[];
+};
+export declare type TagsResult = Tag[];
+export declare type CategoriesResult = {
+    categories: Category[];
+    matches: number;
+};
+export declare type NotificationResults = Pick<MatchResult, 'topNotifications' | 'middleNotifications' | 'bottomNotifications' | 'notificationLists'>;
+export declare type GuideResult = {
+    guide: {
+        id: string;
+        title: string;
+        body: string;
+        modified: string;
+        modifiedBy: string | null;
+        publishedBy: string | null;
+        published: string;
+        connection: string;
+        categories: number[];
+        hasHandover: boolean;
+        allowFeedback: boolean;
+        seoMetaDescription: string | null;
+        seoAllowIndex: boolean | null;
+        perspective: string | null;
+        perspectives: {
+            [key: string]: string;
+        };
+        translations?: {
+            [key: string]: string;
+        };
+    };
+    related: Guide[];
+    dialog: DialogItem[];
+    contactMethods: ContactMethod[];
+    tags: Tag[];
+    error?: DataError;
+};
+export declare type ContactsResult = {
+    categories: Category[];
+    contactMethods: ContactMethod[];
+    topNotifications: Notification[];
+    middleNotifications: Notification[];
+    bottomNotifications: Notification[];
+    notificationLists: NotificationList[];
+};
+export declare type SubmissionResult = {
+    contactMethod?: ContactMethod;
+    valid: boolean;
+};
+export declare const formatLegacyData: (type: ServiceClientQueryType, data: any) => Tag[] | MatchResult | CategoriesResult | ContactMethod | GuideResult | ContactsResult | {
+    topNotifications: Notification[];
+    middleNotifications: Notification[];
+    bottomNotifications: Notification[];
+    notificationLists: NotificationList[];
+} | {
+    topNotifications?: undefined;
+    middleNotifications?: undefined;
+    bottomNotifications?: undefined;
+    notificationLists?: undefined;
+};

package/lib/data/legacy-conversion.js

@@ -0,0 +1,308 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLegacyData = void 0;
+var knowledge_widget_core_1 = require("@telia-ace/knowledge-widget-core");
+var widget_forms_1 = require("@telia-ace/widget-forms");
+var data_client_1 = require("./data-client");
+var convertLegacySymbol = function (symbol) {
+    if (symbol) {
+        var Type = symbol.Type, Content = symbol.Content;
+        if (Type && Content) {
+            return { type: Type, content: Content };
+        }
+    }
+};
+var mapLegacyCategoriesRecursively = function (categories) {
+    return categories.map(function (c) {
+        var category = {
+            id: c.Id.toString(),
+            title: c.Name,
+            symbol: convertLegacySymbol(c.DefaultIcon),
+            activeSymbol: c.ActiveIcon && convertLegacySymbol(c.ActiveIcon),
+            description: c.Description || (c.Attributes && c.Attributes.description) || '',
+            matches: c.GuidesCount,
+        };
+        if (c.Children && c.Children.length) {
+            category.items = mapLegacyCategoriesRecursively(c.Children);
+        }
+        return category;
+    });
+};
+var mapNotices = function (source, type) {
+    return source
+        .filter(function (_a) {
+        var Type = _a.Type;
+        return Type === type;
+    })
+        .map(function (_a) {
+        var Id = _a.Id, Title = _a.Title, Body = _a.Body;
+        return ({
+            id: Id.toString(),
+            title: Title,
+            body: Body,
+        });
+    });
+};
+var mapNotificationLists = function (source) {
+    return source.map(function (_a) {
+        var Id = _a.Id, Title = _a.Title, DefaultIcon = _a.DefaultIcon, ListNotices = _a.ListNotices, Notices = _a.Notices;
+        return ({
+            id: Id.toString(),
+            title: Title,
+            symbol: convertLegacySymbol(DefaultIcon),
+            defaultHeaderOptions: {
+                visible: !!ListNotices.length,
+            },
+            notifications: (ListNotices || [])
+                .concat(Notices || [])
+                .map(function (_a) {
+                var Id = _a.Id, Title = _a.Title, Body = _a.Body, Type = _a.Type, Modified = _a.Modified;
+                return ({
+                    id: Id.toString(),
+                    title: Title,
+                    body: Body,
+                    modified: Modified,
+                    expandable: Type === 'listNotice',
+                });
+            }),
+        });
+    });
+};
+var mapContactMethodSettings = function (_a, Validation) {
+    var Id = _a.Id, Title = _a.Title, DefaultIcon = _a.DefaultIcon, _b = __read(_a.Exits, 1), Exit = _b[0], ExitType = _a.ExitType, ConfirmationText = _a.ConfirmationText, ExpandFormAutomatically = _a.ExpandFormAutomatically, Form = _a.Form, Description = _a.Description;
+    var Adapter = (Exit || { Adapter: {} }).Adapter;
+    var _c = Adapter.ClientName, ClientName = _c === void 0 ? '' : _c, _d = Adapter.Settings, Settings = _d === void 0 ? {} : _d, _e = Adapter.CustomClientName, CustomClientName = _e === void 0 ? '' : _e;
+    var settings = {
+        id: Id.toString(),
+        title: Title,
+        description: Description,
+        symbol: convertLegacySymbol(DefaultIcon),
+        clientName: ClientName === 'custom.adapter' ? CustomClientName : ClientName,
+        expanded: true,
+        inline: true,
+        body: {},
+    };
+    if (ClientName.indexOf('phone') > -1 || ClientName.indexOf('freetext') > -1) {
+        var displayTextBeforeClick = Settings.displayTextBeforeClick, textBeforeClick = Settings.textBeforeClick;
+        if (displayTextBeforeClick === 'true') {
+            settings.expanded = false;
+            settings.title = textBeforeClick;
+        }
+        if (ClientName.indexOf('phone.text') > -1) {
+            settings.body.phoneNumber = Settings.phoneNumber;
+        }
+        else {
+            settings.body.freetext = Settings.freetext;
+        }
+    }
+    if (ClientName.indexOf('chat.popup') > -1 ||
+        ClientName.indexOf('link') > -1 ||
+        (ClientName === 'custom.adapter' && ExitType === 'custom')) {
+        settings.body = Settings;
+        settings.body.confirmationFallback = ConfirmationText;
+    }
+    if (ClientName.indexOf('ace') > -1) {
+        settings.body = Settings;
+    }
+    if (Form && Form.HasValueComponents) {
+        if (Validation) {
+            settings.body.form = widget_forms_1.FormBuilder.fromLegacyForm(Id.toString(), Form, Validation).get();
+        }
+        else {
+            settings.body.form = widget_forms_1.FormBuilder.fromLegacyForm(Id.toString(), Form).get();
+        }
+        if (!ExpandFormAutomatically) {
+            settings.expanded = settings.inline = false;
+        }
+    }
+    return settings;
+};
+var mapTags = function (tags) {
+    if (tags === void 0) { tags = []; }
+    return tags.map(function (_a) {
+        var Id = _a.Id, Title = _a.Title, TotalMatches = _a.TotalMatches, Symbol = _a.Symbol, DefaultIcon = _a.DefaultIcon, ActiveIcon = _a.ActiveIcon;
+        return ({
+            id: Id.toString(),
+            title: Title,
+            matches: TotalMatches,
+            symbol: convertLegacySymbol(DefaultIcon || Symbol),
+            defaultIcon: convertLegacySymbol(DefaultIcon),
+            activeIcon: convertLegacySymbol(ActiveIcon),
+        });
+    });
+};
+var mapGuides = function (guides) {
+    return guides.map(function (_a) {
+        var Id = _a.Id, Title = _a.Title, Tags = _a.Tags, FirstPublishedDate = _a.FirstPublishedDate, Modified = _a.Modified;
+        return ({
+            id: Id.toString(),
+            title: Title,
+            tags: mapTags(Tags),
+            published: FirstPublishedDate,
+            modified: Modified,
+        });
+    });
+};
+var formatLegacyData = function (type, data) {
+    switch (type) {
+        case data_client_1.ServiceClientQueryType.MatchByCategory:
+        case data_client_1.ServiceClientQueryType.Match: {
+            var result = {
+                guides: [],
+                matches: 0,
+                topNotifications: [],
+                middleNotifications: [],
+                bottomNotifications: [],
+                notificationLists: [],
+                tags: [],
+                byCategory: [],
+            };
+            var Matches = data.Matches, TotalMatches = data.TotalMatches, Notices = data.Notices, NoticeLists = data.NoticeLists, Tags = data.Tags, ByCategory = data.ByCategory;
+            result.guides = mapGuides(Matches);
+            result.matches = TotalMatches;
+            result.byCategory = (ByCategory || []).map(function (_a) {
+                var Id = _a.Id, Matches = _a.Matches, TotalMatches = _a.TotalMatches;
+                return ({
+                    id: Id,
+                    guides: mapGuides(Matches),
+                    matches: TotalMatches,
+                });
+            });
+            result.tags = mapTags(Tags);
+            result.notificationLists = mapNotificationLists(NoticeLists || []);
+            result.topNotifications = mapNotices(Notices || [], 'noticeRowTop');
+            result.middleNotifications = mapNotices(Notices || [], 'noticeRowMiddle');
+            result.bottomNotifications = mapNotices(Notices || [], 'footerNotice');
+            return result;
+        }
+        case data_client_1.ServiceClientQueryType.Categories: {
+            var Children = data.Children, GuidesCountTotal = data.GuidesCountTotal;
+            var result = {
+                categories: mapLegacyCategoriesRecursively(Children || []),
+                matches: GuidesCountTotal,
+            };
+            return result;
+        }
+        case data_client_1.ServiceClientQueryType.Guide: {
+            var Id_1 = data.Id, Title_1 = data.Title, Body = data.Body, Related = data.Related, Options = data.Options, ConnectionId_1 = data.ConnectionId, ContactMethods = data.ContactMethods, EnableFeedback = data.EnableFeedback, HandoverExists = data.HandoverExists, FirstPublishedDate = data.FirstPublishedDate, Modified = data.Modified, ModifiedByDisplayName = data.ModifiedByDisplayName, FirstPublishedByDisplayName = data.FirstPublishedByDisplayName, Categories = data.Categories, Tags_1 = data.Tags, SeoMetaDescription = data.SeoMetaDescription, SeoAllowIndex = data.SeoAllowIndex, Perspectives = data.Perspectives, PerspectiveKey = data.PerspectiveKey, Translations_1 = data.Translations;
+            /*
+        PerspectiveKey is always null when on the "top level" of a dialog tree
+        OR when navigating down a dialog tree in the "Default answer version"
+        Note: The "Default answer version" is not the same as a given guides
+        default answer version. The "Default answer version" is always the answer
+        version in Perspectives with the key "Default".
+      */
+            var perspective = PerspectiveKey ||
+                Object.values(Perspectives).find(function (connection) { return connection === ConnectionId_1; }) ||
+                Perspectives['Default'] ||
+                null;
+            var result_1 = {
+                guide: {
+                    id: Id_1.toString(),
+                    title: Title_1,
+                    body: Body,
+                    modified: Modified,
+                    published: FirstPublishedDate,
+                    modifiedBy: ModifiedByDisplayName,
+                    publishedBy: FirstPublishedByDisplayName,
+                    connection: ConnectionId_1,
+                    categories: Categories,
+                    hasHandover: HandoverExists,
+                    allowFeedback: EnableFeedback,
+                    seoMetaDescription: SeoMetaDescription,
+                    seoAllowIndex: SeoAllowIndex,
+                    perspectives: Perspectives,
+                    perspective: perspective,
+                    translations: Object.keys(Translations_1 || {}).reduce(function (acc, key) {
+                        acc[key] = Translations_1[key].toString();
+                        return acc;
+                    }, {}),
+                },
+                related: mapGuides(Related || []),
+                dialog: [],
+                contactMethods: (ContactMethods || []).map(function (cm) { return mapContactMethodSettings(cm); }),
+                tags: mapTags(Tags_1),
+            };
+            (Options || []).forEach(function (_a) {
+                var CanAccess = _a.CanAccess, Description = _a.Description, ConnectionId = _a.ConnectionId, Properties = _a.Properties;
+                if (!CanAccess) {
+                    return;
+                }
+                var item = {
+                    id: Id_1.toString(),
+                    title: Description,
+                    connection: ConnectionId,
+                    type: knowledge_widget_core_1.DialogItemType.default,
+                    parent: {
+                        id: Id_1.toString(),
+                        title: Title_1,
+                        tags: mapTags(Tags_1),
+                    },
+                };
+                if (Properties.Type === 'Guide' || Properties.Type === 'Link') {
+                    Properties.Id && (item.id = Properties.Id.toString());
+                    Properties.Uri && (item.href = Properties.Uri);
+                    Properties.Target && (item.target = Properties.Target);
+                    switch (Properties.Type) {
+                        case 'Guide':
+                            item.type = knowledge_widget_core_1.DialogItemType.guide;
+                            break;
+                        case 'Link':
+                            item.type = knowledge_widget_core_1.DialogItemType.link;
+                            break;
+                    }
+                }
+                result_1.dialog.push(item);
+            });
+            return result_1;
+        }
+        case data_client_1.ServiceClientQueryType.Contacts: {
+            var Children = data.Children, Matches = data.Matches, Notices = data.Notices, NoticeLists = data.NoticeLists;
+            var result = {
+                contactMethods: (Matches || []).map(function (cm) { return mapContactMethodSettings(cm); }),
+                categories: mapLegacyCategoriesRecursively(Children || []),
+                topNotifications: mapNotices(Notices || [], 'noticeRowTop'),
+                middleNotifications: mapNotices(Notices || [], 'noticeRowMiddle'),
+                bottomNotifications: mapNotices(Notices || [], 'footerNotice'),
+                notificationLists: mapNotificationLists(NoticeLists || []),
+            };
+            return result;
+        }
+        case data_client_1.ServiceClientQueryType.ContactMethod: {
+            var ContactMethod = data.ContactMethod;
+            return mapContactMethodSettings(ContactMethod || {});
+        }
+        case data_client_1.ServiceClientQueryType.Tags:
+        case data_client_1.ServiceClientQueryType.TagsOnGuides: {
+            return mapTags(data || []);
+        }
+        case data_client_1.ServiceClientQueryType.Notifications: {
+            var Notices = data.Notices, NoticeLists = data.NoticeLists;
+            return {
+                topNotifications: mapNotices(Notices || [], 'noticeRowTop'),
+                middleNotifications: mapNotices(Notices || [], 'noticeRowMiddle'),
+                bottomNotifications: mapNotices(Notices || [], 'footerNotice'),
+                notificationLists: mapNotificationLists(NoticeLists || []),
+            };
+        }
+        default:
+            return {};
+    }
+};
+exports.formatLegacyData = formatLegacyData;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { Component, DetachedComponent, genericComponentStyling, NotFound, } from '@telia-ace/widget-types-grid';
+export * from './data';
+export { GridWidget } from './widget';

package/lib/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridWidget = exports.NotFound = exports.genericComponentStyling = exports.DetachedComponent = exports.Component = void 0;
+var widget_types_grid_1 = require("@telia-ace/widget-types-grid");
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return widget_types_grid_1.Component; } });
+Object.defineProperty(exports, "DetachedComponent", { enumerable: true, get: function () { return widget_types_grid_1.DetachedComponent; } });
+Object.defineProperty(exports, "genericComponentStyling", { enumerable: true, get: function () { return widget_types_grid_1.genericComponentStyling; } });
+Object.defineProperty(exports, "NotFound", { enumerable: true, get: function () { return widget_types_grid_1.NotFound; } });
+__exportStar(require("./data"), exports);
+var widget_1 = require("./widget");
+Object.defineProperty(exports, "GridWidget", { enumerable: true, get: function () { return widget_1.GridWidget; } });

package/lib/widget/extended-widget.d.ts

@@ -0,0 +1,5 @@
+import { Widget } from '@telia-ace/widget-types-grid';
+import { Container } from '@webprovisions/platform';
+export default class ExtendedWidget extends Widget {
+    constructor(container: Container);
+}

package/lib/widget/extended-widget.js

@@ -0,0 +1,32 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var widget_types_grid_1 = require("@telia-ace/widget-types-grid");
+var services_1 = require("./services");
+var ExtendedWidget = /** @class */ (function (_super) {
+    __extends(ExtendedWidget, _super);
+    function ExtendedWidget(container) {
+        var _this = _super.call(this, container) || this;
+        _this.container.registerAsync('contactMethods', function () {
+            return (0, services_1.createContactMethodPlatform)(_this.container);
+        });
+        _this.container.registerAsync('dataClient', function () { return (0, services_1.createDataClient)(_this.container); });
+        return _this;
+    }
+    return ExtendedWidget;
+}(widget_types_grid_1.Widget));
+exports.default = ExtendedWidget;

package/lib/widget/index.d.ts

@@ -0,0 +1 @@
+export { default as GridWidget } from './extended-widget';

package/lib/widget/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridWidget = void 0;
+var extended_widget_1 = require("./extended-widget");
+Object.defineProperty(exports, "GridWidget", { enumerable: true, get: function () { return __importDefault(extended_widget_1).default; } });

package/lib/widget/services.d.ts

@@ -0,0 +1,3 @@
+import { Container } from '@webprovisions/platform';
+export declare const createContactMethodPlatform: (container: Container) => Promise<import("@telia-ace/knowledge-widget-adapters/lib/contact-methods/platform").default>;
+export declare const createDataClient: (container: Container) => Promise<import("../data").DataClient>;

package/lib/widget/services.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDataClient = exports.createContactMethodPlatform = void 0;
+var createContactMethodPlatform = function (container) {
+    return Promise.resolve().then(function () { return __importStar(require('@telia-ace/knowledge-widget-adapters')); }).then(function (_a) {
+        var ContactMethodPlatform = _a.ContactMethodPlatform;
+        return ContactMethodPlatform.create(container);
+    });
+};
+exports.createContactMethodPlatform = createContactMethodPlatform;
+var createDataClient = function (container) {
+    return Promise.resolve().then(function () { return __importStar(require('../data')); }).then(function (_a) {
+        var DataClient = _a.DataClient;
+        return DataClient.create(container);
+    });
+};
+exports.createDataClient = createDataClient;

package/lib-esm/data/data-client.d.ts

@@ -0,0 +1,91 @@
+import { ServiceClient } from '@telia-ace/knowledge-serviceclient';
+import { Container, EventManager } from '@webprovisions/platform';
+export declare type Subscriber = (...args: any[]) => void;
+export declare enum DataType {
+    Guide = "guide",
+    Guides = "guides",
+    GuidesByCategory = "guides-by-category",
+    RowNotifications = "row-notices",
+    NotificationLists = "notification-lists",
+    GuideCategories = "guide-categories",
+    ContactMethodCategories = "contact-method-categories",
+    ContactMethod = "contact-method",
+    ContactMethods = "contact-methods",
+    Tags = "tags",
+    TagsOnGuides = "tagsonguides"
+}
+export declare type DataError = {
+    status: number;
+    message: string;
+};
+export declare enum ServiceClientQueryType {
+    Match = "match",
+    Categories = "categories",
+    Guide = "guide",
+    Contacts = "contacts",
+    ContactMethod = "contact-method",
+    MatchByCategory = "match-by-category",
+    Tags = "tags",
+    TagsOnGuides = "tagsonguides",
+    Notifications = "notifications"
+}
+export declare enum FeedbackType {
+    Positive = "Positive",
+    Negative = "Negative"
+}
+export declare type QueryParameters = {
+    guideId?: string | number;
+    categories?: string | number | string[] | number[];
+    tagId?: string | number;
+    connection?: string;
+    contactMethodCategoryId?: string | number;
+    contactMethodId?: string | number;
+    searchPhrase?: string | number;
+    take?: string | number;
+    [key: string]: any;
+    expandCategories?: 'none' | 'children' | 'descendants';
+    sorting?: SortingType;
+    guideIds?: string[];
+};
+export declare enum SortingType {
+    POPULARITY_DESCENDING = "popularity-descending",
+    ALPHABETIC_ASCENDING = "alphabetic-ascending",
+    ALPHABETIC_DESCENDING = "alphabetic-descending",
+    MODIFIED_ASCENDING = "modified-ascending",
+    MODIFIED_DESCENDING = "modified-descending",
+    PUBLISHED_ASCENDING = "published-ascending",
+    PUBLISHED_DESCENDING = "published-descending"
+}
+export declare type Query = {
+    params: QueryParameters;
+    resolved: boolean;
+    loading: boolean;
+    error?: DataError;
+    data: any;
+    resolvers: {
+        resolve: (data: any) => void;
+        reject: (data: any) => void;
+    }[];
+};
+export declare const determineServiceClientQueryType: (type: DataType) => ServiceClientQueryType;
+export default class DataClient {
+    private container;
+    private matchingClient;
+    private queries;
+    private lastTake;
+    events: EventManager;
+    constructor(container: Container, matchingClient: ServiceClient);
+    static getInstance(container: Container): Promise<DataClient>;
+    private getUnresolvedQueries;
+    fetch(type: DataType, params: QueryParameters): Promise<any>;
+    read(type: DataType, options: {
+        select?: (data: any) => any;
+    }): any[];
+    feedback(id: string, connection: string, feedback: FeedbackType): Promise<any>;
+    private setLoadingStatus;
+    private runQuery;
+    handleResponse(data: any, type: ServiceClientQueryType, params: QueryParameters, error?: DataError): void;
+    private fetchAllUnresolvedQueries;
+    private track;
+    static create(container: Container): Promise<DataClient>;
+}