@esolve/ng-esolve-connect 0.136.0 → 0.138.0

package/media/index.d.ts

@@ -1,8 +1,262 @@
-export * from './lib/ng-esolve-connect-media.module';
-export * from './lib/esolve-connect-media-config.token';
-export * from './lib/components';
-export * from './lib/classes';
-export * from './lib/types';
-export * from './lib/functions';
-export * from './lib/interfaces';
-export * from './lib/services';
+import * as i0 from '@angular/core';
+import { OnChanges, ModuleWithProviders, InjectionToken, Provider } from '@angular/core';
+import { ComponentType, ComponentPortal } from '@angular/cdk/portal';
+import { EsolveUrlTarget, EsolveManufacturerRecord, EsolveRangeRecord, EsolveTagRecord, EsolveTopicRecord, EsolveCustomFields, EsolveSeoDetails, EsolveTag, EsolveTopic, EsolveSeoInfo, EsolveManufacturer, EsolveRange, EsolveSort } from '@esolve/ng-esolve-connect';
+import { Observable } from 'rxjs';
+
+type EsolveMediaLayoutSectionType = 'media' | 'banner' | 'albums' | 'categories_grid' | 'categories_slider' | 'linked_stock' | 'stock' | 'custom';
+
+interface EsolveLayoutSectionConfig {
+    key: EsolveMediaLayoutSectionType;
+    sub_key?: string;
+    component: ComponentType<any>;
+}
+
+interface EsolveLayoutConfig {
+    key: string;
+    component: ComponentType<any>;
+    sections?: {
+        [key: string]: EsolveLayoutSectionConfig[] | undefined;
+        /**
+         * Default sections to use for entire layout
+         */
+        __default?: EsolveLayoutSectionConfig[];
+    };
+}
+
+interface EsolveHeadingRecord {
+    id: number;
+    identifier: string;
+    value: string;
+}
+
+interface EsolveMediaGroupRecord {
+    id?: number;
+    name?: string;
+    sef_name?: string;
+    description?: string;
+}
+
+interface EsolveMediaSectionDataGeneric {
+    [data_field: string]: string | number | boolean | (string | number)[] | {
+        min: number;
+        max: number;
+    };
+}
+
+interface EsolveMediaLayoutSectionRecord {
+    type: EsolveMediaLayoutSectionType;
+    sub_type?: string;
+    identifier: string;
+    data?: EsolveMediaSectionDataGeneric | null;
+}
+
+interface EsolveMediaRecord {
+    identifier: string;
+    title: string;
+    sub_title: string;
+    article: string;
+    id?: number;
+    media_group_id?: number;
+    media_group?: EsolveMediaGroupRecord;
+    txdate?: number;
+    seo_page_priority?: string;
+    seo_page_update_frequency?: string;
+    seo_page_title?: string;
+    seo_keywords?: string;
+    seo_description?: string;
+    userid?: number;
+    language_code?: string;
+    active?: boolean;
+    sort_priority?: number;
+    only_display_when_logged_on?: boolean;
+    is_minor_article?: boolean;
+    is_both_master_and_minor_article?: boolean;
+    url?: string;
+    sef_url?: string;
+    link_caption?: string;
+    target?: EsolveUrlTarget;
+    modified?: string;
+    image_url?: string;
+    image_checksum?: string;
+    manufacturer?: EsolveManufacturerRecord;
+    range?: EsolveRangeRecord;
+    layout?: string;
+    tags?: EsolveTagRecord[];
+    topics?: EsolveTopicRecord[];
+    sections?: {
+        [key: string]: EsolveMediaLayoutSectionRecord[];
+    };
+    custom_fields?: EsolveCustomFields;
+}
+
+interface EsolveMediaLinkRecord {
+    url: string;
+    caption?: string;
+    target?: EsolveUrlTarget;
+}
+
+interface EsolveConnectMediaConfig {
+    layouts: EsolveLayoutConfig[];
+    default_layout?: string;
+    sections: EsolveLayoutSectionConfig[];
+}
+
+interface EsolveMediaStockSectionData {
+    tags: (string | number)[];
+}
+
+interface EsolveSectionKeyOptions {
+    type: EsolveMediaLayoutSectionType;
+    sub_type?: string;
+    layout?: string;
+    group?: string;
+}
+
+declare class EsolveHeading {
+    identifier: string;
+    value: string;
+    constructor(identifier: string, value: string);
+}
+
+declare class EsolveMediaGroup {
+    id: number;
+    name: string;
+    sef_name: string;
+    description: string;
+    constructor(record?: EsolveMediaGroupRecord);
+}
+
+declare class EsolveMediaLayoutSection {
+    type: EsolveMediaLayoutSectionType;
+    sub_type: string;
+    identifier: string;
+    private data?;
+    constructor(record: EsolveMediaLayoutSectionRecord);
+    getData<T = EsolveMediaSectionDataGeneric>(): T | null;
+}
+
+declare class EsolveMediaLink {
+    caption: string;
+    url: string;
+    target: EsolveUrlTarget;
+    constructor(record: EsolveMediaLinkRecord);
+}
+
+declare class EsolveMediaArticle implements EsolveSeoDetails {
+    identifier: string;
+    title: string;
+    sub_title: string;
+    published_date?: Date;
+    article: string;
+    layout: string;
+    image_url: string;
+    tags: EsolveTag[];
+    topics: EsolveTopic[];
+    seo_details: EsolveSeoInfo;
+    group?: EsolveMediaGroup;
+    manufacturer?: EsolveManufacturer;
+    range?: EsolveRange;
+    sections?: Map<string, EsolveMediaLayoutSection[]>;
+    link?: EsolveMediaLink;
+    custom_fields?: EsolveCustomFields;
+    constructor(record: EsolveMediaRecord);
+}
+
+declare class EsolveMediaLayoutComponent implements OnChanges {
+    private readonly layoutService;
+    media: EsolveMediaArticle;
+    portal?: ComponentPortal<any> | null;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveMediaLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsolveMediaLayoutComponent, "eslv-media-layout", never, { "media": { "alias": "media"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EsolveMediaSectionComponent implements OnChanges {
+    private readonly layoutService;
+    key: string;
+    portals: ComponentPortal<any>[];
+    ngOnChanges(): void;
+    private processPortals;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveMediaSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsolveMediaSectionComponent, "eslv-media-section", never, { "key": { "alias": "key"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgEsolveConnectMediaModule {
+    static withConfig(config: EsolveConnectMediaConfig): ModuleWithProviders<NgEsolveConnectMediaModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgEsolveConnectMediaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgEsolveConnectMediaModule, never, [typeof EsolveMediaLayoutComponent, typeof EsolveMediaSectionComponent], [typeof EsolveMediaLayoutComponent, typeof EsolveMediaSectionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgEsolveConnectMediaModule>;
+}
+
+declare const ESOLVE_CONNECT_MEDIA_CONFIG: InjectionToken<EsolveConnectMediaConfig>;
+
+declare function provideNgEsolveConnectMedia(config: EsolveConnectMediaConfig): Provider;
+
+declare class EsolveMediaService {
+    private config;
+    private http;
+    /**
+     * Retrieves the media record from the eSolve instance using the identifier
+     *
+     * @param identifier String representing the eSolve media identifier
+     */
+    getMediaArticle(identifier: string): Observable<EsolveMediaArticle>;
+    /**
+     * Retrieves a group of media records from the eSolve instance linked to a group
+     *
+     * @param media_group String representing the eSolve media group
+     */
+    getGroupedMediaArticles(media_group: string, sort?: EsolveSort): Observable<EsolveMediaArticle[]>;
+    /**
+     * Retrieves the media heading records from the eSolve instance using the identifiers
+     *
+     * @param identifiers Array of strings representing the eSolve heading identifiers
+     */
+    getHeadings(identifiers: string[]): Observable<EsolveHeading[]>;
+    /**
+     * Processes media article record
+     *
+     * @param record Record from eSolve instance
+     */
+    private processMediaRecord;
+    /**
+     * Processes media heading record
+     *
+     * @param record Record from eSolve instance
+     */
+    private processHeadingRecord;
+    /**
+     * Retrieves media records from eSolve instance.
+     *
+     * @param params HTTP params
+     */
+    private getMediaRecords;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveMediaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolveMediaService>;
+}
+
+declare class EsolveMediaLayoutService {
+    private readonly section_key_delimiter;
+    private readonly default_section_group_key;
+    private readonly default_layout_key;
+    private media?;
+    private layout_map;
+    private section_map;
+    private default_layout;
+    constructor();
+    getMedia(): EsolveMediaArticle;
+    setMedia(media: EsolveMediaArticle): void;
+    getLayout(): ComponentType<any>;
+    getSectionContent(key: string): EsolveMediaLayoutSection[];
+    getSectionComponent(key: string, section: EsolveMediaLayoutSection): ComponentType<any>;
+    private searchLayout;
+    private setLayout;
+    private setSection;
+    private createSectionMapKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveMediaLayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolveMediaLayoutService>;
+}
+
+export { ESOLVE_CONNECT_MEDIA_CONFIG, EsolveHeading, EsolveMediaArticle, EsolveMediaGroup, EsolveMediaLayoutComponent, EsolveMediaLayoutSection, EsolveMediaLayoutService, EsolveMediaLink, EsolveMediaSectionComponent, EsolveMediaService, NgEsolveConnectMediaModule, provideNgEsolveConnectMedia };
+export type { EsolveConnectMediaConfig, EsolveHeadingRecord, EsolveLayoutConfig, EsolveLayoutSectionConfig, EsolveMediaGroupRecord, EsolveMediaLayoutSectionRecord, EsolveMediaLayoutSectionType, EsolveMediaLinkRecord, EsolveMediaRecord, EsolveMediaSectionDataGeneric, EsolveMediaStockSectionData, EsolveSectionKeyOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esolve/ng-esolve-connect",
-  "version": "0.136.0",
+  "version": "0.138.0",
   "homepage": "https://www.esolve.co.za/",
   "description": "An Angular library that speaks to an eSolve instance's API",
   "peerDependencies": {

package/survey/index.d.ts

@@ -1,4 +1,225 @@
-export * from './lib/classes';
-export * from './lib/interfaces';
-export * from './lib/types';
-export * from './lib/services';
+import { EsolvePostResponseItem, EsolveSeoDetails, EsolveSeoInfo, EsolveResponseResult } from '@esolve/ng-esolve-connect';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+type EsolveSurveyType = 'general' | 'anonymous' | 'transaction';
+
+type EsolveSurveyOptionsQuestionType = 'rating' | 'select';
+
+type EsolveSurveyTextQuestionType = 'input' | 'textarea';
+
+type EsolveSurveyValuesQuestionType = 'check_boxes' | 'radio_boxes';
+
+type EsolveSurveyQuestionType = EsolveSurveyTextQuestionType | EsolveSurveyOptionsQuestionType | EsolveSurveyValuesQuestionType;
+
+type EsolveSurveyQuestionRecordList = (EsolveSurveyTextQuestionRecord | EsolveSurveyOptionsQuestionRecord | EsolveSurveyValuesQuestionRecord)[];
+
+interface EsolveSurveyRecord {
+    id: number;
+    type: EsolveSurveyType;
+    identifier: string;
+    title: string;
+    description: string;
+    questions: EsolveSurveyQuestionRecordList;
+}
+
+interface EsolveSurveyOption<T extends number | string> {
+    label: string;
+    value: T;
+}
+
+interface EsolveSurveyQuestionRecord {
+    type: EsolveSurveyQuestionType;
+    id: number;
+    identifier: string;
+    question: string;
+    title: string;
+    description: string;
+}
+
+interface EsolveSurveyOptionsQuestionRecord extends EsolveSurveyQuestionRecord {
+    type: EsolveSurveyOptionsQuestionType;
+    options: EsolveSurveyOption<number | string>[];
+}
+
+interface EsolveSurveyTextQuestionRecord extends EsolveSurveyQuestionRecord {
+    type: EsolveSurveyTextQuestionType;
+    length: number;
+    placeholder: string;
+}
+
+interface EsolveSurveyValuesQuestionRecord extends EsolveSurveyQuestionRecord {
+    type: EsolveSurveyValuesQuestionType;
+    values: string[];
+}
+
+interface EsolveSurveyOptions {
+    id?: number;
+    identifier?: string;
+    transaction_id?: number;
+}
+
+interface EsolveSurveyAnswerResponse extends EsolvePostResponseItem {
+    invalid_question_ids?: number[];
+}
+
+declare abstract class EsolveSurveyQuestion {
+    abstract type: EsolveSurveyQuestionType;
+    id: number;
+    identifier: string;
+    question: string;
+    title: string;
+    description: string;
+    constructor(record: EsolveSurveyQuestionRecord);
+}
+
+declare class EsolveSurvey implements EsolveSeoDetails {
+    id: number;
+    type: EsolveSurveyType;
+    identifier: string;
+    title: string;
+    description: string;
+    questions: EsolveSurveyQuestion[];
+    seo_details: EsolveSeoInfo;
+    constructor(record: EsolveSurveyRecord);
+    private processQuestions;
+}
+
+declare abstract class EsolveSurveyTextQuestion extends EsolveSurveyQuestion {
+    length: number;
+    placeholder: string;
+    constructor(record: EsolveSurveyTextQuestionRecord);
+}
+
+declare abstract class EsolveSurveyValuesQuestion extends EsolveSurveyQuestion {
+    values: string[];
+    constructor(record: EsolveSurveyValuesQuestionRecord);
+}
+
+declare abstract class EsolveSurveyOptionsQuestion<T extends number | string> extends EsolveSurveyQuestion {
+    options: EsolveSurveyOption<T>[];
+    constructor(record: EsolveSurveyOptionsQuestionRecord);
+    protected abstract processValue(option: number | string): T;
+    protected processOption(option: EsolveSurveyOption<string | number>): void;
+}
+
+declare class EsolveSurveyInputQuestion extends EsolveSurveyTextQuestion {
+    readonly type = "input";
+    constructor(record: EsolveSurveyTextQuestionRecord);
+}
+
+declare class EsolveSurveyTextareaQuestion extends EsolveSurveyTextQuestion {
+    readonly type = "textarea";
+    constructor(record: EsolveSurveyTextQuestionRecord);
+}
+
+declare class EsolveSurveyCheckQuestion extends EsolveSurveyValuesQuestion {
+    readonly type = "check_boxes";
+    constructor(record: EsolveSurveyValuesQuestionRecord);
+}
+
+declare class EsolveSurveyRadioQuestion extends EsolveSurveyValuesQuestion {
+    readonly type = "radio_boxes";
+    constructor(record: EsolveSurveyValuesQuestionRecord);
+}
+
+declare class EsolveSurveyRatingQuestion extends EsolveSurveyOptionsQuestion<number> {
+    readonly type = "rating";
+    constructor(record: EsolveSurveyOptionsQuestionRecord);
+    protected processValue(value: string | number): number;
+}
+
+declare class EsolveSurveySelectQuestion extends EsolveSurveyOptionsQuestion<string> {
+    readonly type = "select";
+    placeholder?: string;
+    constructor(record: EsolveSurveyOptionsQuestionRecord);
+    protected processValue(value: string | number): string;
+    protected processOption(option: EsolveSurveyOption<string>): void;
+}
+
+declare class EsolveSurveyAnswerResult extends EsolveResponseResult {
+    invalid_question_ids?: number[];
+    constructor(response: EsolveSurveyAnswerResponse);
+}
+
+declare class EsolveSurveyService {
+    private readonly config;
+    private readonly http;
+    private readonly errorHandler;
+    private readonly responseHandler;
+    /**
+     * Get survey from eSolve API
+     *
+     * @param options
+     *
+     * @returns An `Observable` with requested survey
+     */
+    getSurvey(options: {
+        id: number;
+        transaction_id?: number;
+    }): Observable<EsolveSurvey>;
+    getSurvey(options: {
+        identifier: string;
+        transaction_id?: number;
+    }): Observable<EsolveSurvey>;
+    /**
+     * Get survey from eSolve API
+     *
+     * @param id
+     * @param transaction_id
+     *
+     * @returns An `Observable` with requested survey
+     */
+    getSurvey(id: number, transaction_id?: number): Observable<EsolveSurvey>;
+    /**
+     * Get survey from eSolve API
+     *
+     * @param identifier
+     * @param transaction_id
+     *
+     * @returns An `Observable` with requested survey
+     */
+    getSurvey(identifier: string, transaction_id?: number): Observable<EsolveSurvey>;
+    /**
+     * Set the survey answer
+     *
+     * @param data
+     * @param options
+     *
+     * @returns An `Observable` with the result
+     */
+    setSurveyAnswer(data: FormData, options: {
+        id: number;
+        transaction_id?: number;
+    }): Observable<EsolveSurveyAnswerResult>;
+    setSurveyAnswer(data: FormData, options: {
+        identifier: string;
+        transaction_id?: number;
+    }): Observable<EsolveSurveyAnswerResult>;
+    /**
+     * Set the survey answer
+     *
+     * @param data
+     * @param id
+     * @param transaction_id
+     *
+     * @returns An `Observable` with the result
+     */
+    setSurveyAnswer(data: FormData, id: number, transaction_id?: number): Observable<EsolveSurveyAnswerResult>;
+    /**
+     * Set the survey answer
+     *
+     * @param data
+     * @param identifier
+     * @param transaction_id
+     *
+     * @returns An `Observable` with the result
+     */
+    setSurveyAnswer(data: FormData, identifier: string, transaction_id?: number): Observable<EsolveSurveyAnswerResult>;
+    private setParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveSurveyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolveSurveyService>;
+}
+
+export { EsolveSurvey, EsolveSurveyAnswerResult, EsolveSurveyCheckQuestion, EsolveSurveyInputQuestion, EsolveSurveyOptionsQuestion, EsolveSurveyQuestion, EsolveSurveyRadioQuestion, EsolveSurveyRatingQuestion, EsolveSurveySelectQuestion, EsolveSurveyService, EsolveSurveyTextQuestion, EsolveSurveyTextareaQuestion, EsolveSurveyValuesQuestion };
+export type { EsolveSurveyAnswerResponse, EsolveSurveyOption, EsolveSurveyOptions, EsolveSurveyOptionsQuestionRecord, EsolveSurveyOptionsQuestionType, EsolveSurveyQuestionRecord, EsolveSurveyQuestionRecordList, EsolveSurveyQuestionType, EsolveSurveyRecord, EsolveSurveyTextQuestionRecord, EsolveSurveyTextQuestionType, EsolveSurveyType, EsolveSurveyValuesQuestionRecord, EsolveSurveyValuesQuestionType };

package/lib/account/address/classes/esolve-address-result.model.d.ts

@@ -1,10 +0,0 @@
-import { EsolveAddressResponse } from '../interfaces/esolve-address-response.interface';
-import { EsolveGeocodeResponse } from '../../esolve-geocode-response.interface';
-import { EsolveResponseResult } from '../../../shared/response';
-export declare class EsolveAddressResult extends EsolveResponseResult {
-    id: number;
-    address_validated: boolean;
-    geocode_status: string;
-    geocode_result: EsolveGeocodeResponse | null;
-    constructor(response: EsolveAddressResponse);
-}

package/lib/account/address/classes/esolve-address.model.d.ts

@@ -1,23 +0,0 @@
-import { EsolveAddressRecord } from '../interfaces/esolve-address-record.interface';
-import { EsolveAddressPlaceType } from '../types';
-import { EsolveAddressType } from '../types/esolve-address-type.type';
-export declare class EsolveAddress {
-    id: number;
-    recipient: string;
-    address_type: EsolveAddressType;
-    pobox: string;
-    place_name: string;
-    unit_number: string;
-    place_type: EsolveAddressPlaceType;
-    alias: string;
-    street_number: string;
-    street: string;
-    suburb: string;
-    city: string;
-    province: string;
-    country: string;
-    postal_code: string;
-    latitude: number;
-    longitude: number;
-    constructor(record?: Partial<EsolveAddressRecord>);
-}

package/lib/account/address/classes/esolve-session-address-update-result.model.d.ts

@@ -1,5 +0,0 @@
-import { EsolvePostResponseItem, EsolveResponseResult } from '../../../shared';
-export declare class EsolveSessionAddressUpdateResult extends EsolveResponseResult {
-    address_updated: boolean;
-    constructor(response: EsolvePostResponseItem);
-}

package/lib/account/address/classes/index.d.ts

@@ -1,3 +0,0 @@
-export * from './esolve-address-result.model';
-export * from './esolve-address.model';
-export * from './esolve-session-address-update-result.model';

package/lib/account/address/index.d.ts

@@ -1,3 +0,0 @@
-export * from './classes';
-export * from './interfaces';
-export * from './types';

package/lib/account/address/interfaces/esolve-address-post-data.interface.d.ts

@@ -1,23 +0,0 @@
-import { EsolveAddressPlaceType, EsolveAddressType } from '../types';
-export interface EsolveAddressPostData {
-    addresses_id?: number;
-    recipient?: string;
-    address_type?: EsolveAddressType;
-    pobox?: string;
-    place_name?: string;
-    unit_number?: string;
-    place_type?: EsolveAddressPlaceType;
-    alias?: string;
-    street_number?: string | number;
-    street?: string;
-    suburb?: string;
-    sub_region?: string;
-    city?: string;
-    province?: string;
-    country?: string;
-    postal_code?: string;
-    description?: string;
-    latitude?: number;
-    longitude?: number;
-    formatted_address?: string;
-}

package/lib/account/address/interfaces/esolve-address-record.interface.d.ts

@@ -1,21 +0,0 @@
-import { EsolveAddressPlaceType, EsolveAddressType } from '../types';
-export interface EsolveAddressRecord {
-    id: number;
-    userid: number;
-    recipient: string;
-    address_type: EsolveAddressType;
-    pobox: string;
-    alias: string;
-    place_name: string;
-    unit_number: string;
-    place_type: EsolveAddressPlaceType;
-    street_number: string;
-    street: string;
-    suburb: string;
-    city: string;
-    province: string;
-    country: string;
-    postal_code: string;
-    latitude: number;
-    longitude: number;
-}

package/lib/account/address/interfaces/esolve-address-response.interface.d.ts

@@ -1,8 +0,0 @@
-import { EsolvePostResponseItem } from '../../../shared/response';
-import { EsolveGeocodeResponse } from '../../esolve-geocode-response.interface';
-export interface EsolveAddressResponse extends EsolvePostResponseItem {
-    esolve_id: number;
-    geocode_status: string;
-    address_validated: boolean;
-    geocode_result: EsolveGeocodeResponse | null;
-}

package/lib/account/address/interfaces/index.d.ts

@@ -1,3 +0,0 @@
-export * from './esolve-address-record.interface';
-export * from './esolve-address-response.interface';
-export * from './esolve-address-post-data.interface';

package/lib/account/address/types/esolve-address-place-type.type.d.ts

@@ -1 +0,0 @@
-export type EsolveAddressPlaceType = 'freestanding_home' | 'complex' | 'farm' | 'business_complex' | 'flat_complex' | 'estate';

package/lib/account/address/types/esolve-address-type.type.d.ts

@@ -1 +0,0 @@
-export type EsolveAddressType = 'physical' | 'postal';

package/lib/account/address/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './esolve-address-place-type.type';
-export * from './esolve-address-type.type';

package/lib/account/confirmation/esolve-account-confirmation-post-response-item.interface.d.ts

@@ -1,10 +0,0 @@
-import { EsolvePostResponseItem } from '../../shared/response';
-export interface EsolveAccountConfirmationPostResponseItem extends EsolvePostResponseItem {
-    esolve_id: number;
-    location_id: number;
-    shipping_id: number;
-    addresses_id: number;
-    clients_id: number;
-    recalculated_cart: boolean;
-    auto_login: boolean;
-}

package/lib/account/confirmation/esolve-account-confirmation-result.model.d.ts

@@ -1,8 +0,0 @@
-import { EsolveResponseResult } from '../../shared/response';
-import { EsolveAccountConfirmationPostResponseItem } from './esolve-account-confirmation-post-response-item.interface';
-export declare class EsolveAccountConfirmationResult extends EsolveResponseResult {
-    user_id: number;
-    location_id: number;
-    recalculated_cart: boolean;
-    constructor(response: EsolveAccountConfirmationPostResponseItem);
-}

package/lib/account/confirmation/index.d.ts

@@ -1,2 +0,0 @@
-export * from './esolve-account-confirmation-result.model';
-export * from './esolve-account-confirmation-post-response-item.interface';