@veloceapps/api 4.0.21-0

package/lib/services/configuration-api.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseHttpService, ConfigurationRequest, ConfigurePrice, RuntimeData, RuntimeModel } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ConfigurationApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    configureLineItem({ configurationRequest, runtimeModel, pricingEnabled, }: {
+        configurationRequest: ConfigurationRequest;
+        runtimeModel?: RuntimeModel;
+        pricingEnabled?: boolean;
+    }): Observable<ConfigurePrice>;
+    getRuntimeDataByProductId(productId: string, offeringId?: string): Observable<RuntimeData>;
+    getRuntimeDataByModelId(modelId: string): Observable<RuntimeData>;
+    private updatePortDomains;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationApiService>;
+}

package/lib/services/configuration-settings-api.service.d.ts

@@ -0,0 +1,17 @@
+import { BaseHttpService, ConfigurationSettings, DataAdministrationField, HttpRequestConfigurableOptions } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ConfigurationSettingsApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    fetchSettings(options?: HttpRequestConfigurableOptions): Observable<ConfigurationSettings[]>;
+    fetchSetting(settingsKey: string, options?: HttpRequestConfigurableOptions): Observable<ConfigurationSettings | null>;
+    createSetting(setting: ConfigurationSettings, options?: HttpRequestConfigurableOptions): Observable<ConfigurationSettings>;
+    updateSetting(setting: ConfigurationSettings, options?: HttpRequestConfigurableOptions): Observable<ConfigurationSettings>;
+    removeSetting(setting: ConfigurationSettings, options?: HttpRequestConfigurableOptions): Observable<ConfigurationSettings>;
+    restoreSetting(settingId: string, options?: HttpRequestConfigurableOptions): Observable<any>;
+    clear(name: DataAdministrationField, options?: HttpRequestConfigurableOptions): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationSettingsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationSettingsApiService>;
+}

package/lib/services/context-api.service.d.ts

@@ -0,0 +1,11 @@
+import { BaseHttpService, ConfigurationContext, ConfigurationContextMode } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ContextApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    getContext(headerId: string, mode: ConfigurationContextMode): Observable<ConfigurationContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextApiService>;
+}

package/lib/services/delta-api.service.d.ts

@@ -0,0 +1,12 @@
+import { BaseHttpService, LineItem } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CalculateDeltaRequest } from '../types/delta-request.types';
+import * as i0 from "@angular/core";
+export declare class DeltaApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    calculate$(request: CalculateDeltaRequest): Observable<LineItem[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeltaApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeltaApiService>;
+}

package/lib/services/document-attachment-api.service.d.ts

@@ -0,0 +1,16 @@
+import { Attachment, BaseHttpService, FileDownloadService, TemplateAttachmentSearchRequest } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DocumentAttachmentApiService {
+    private httpService;
+    private fileDownloadService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService, fileDownloadService: FileDownloadService);
+    getAttachments(searchRequest: TemplateAttachmentSearchRequest): Observable<Attachment[]>;
+    createAttachment(attachment: Attachment, file?: File, reportProgress?: boolean): Observable<Attachment>;
+    updateAttachment(id: string, attachment: Attachment): Observable<Attachment>;
+    getAttachmentFile(id: string, isPreventDownload?: boolean): Observable<any>;
+    removeAttachment(id: string): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentAttachmentApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentAttachmentApiService>;
+}

package/lib/services/document-templates-api.service.d.ts

@@ -0,0 +1,47 @@
+import { HttpClient } from '@angular/common/http';
+import { Attachment, BaseHttpService, DocumentTemplate, FileDownloadService, TemplateAttachmentSearchRequest } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { DocumentAttachmentApiService } from './document-attachment-api.service';
+import { SalesforceApiService } from './salesforce-api.service';
+import * as i0 from "@angular/core";
+export interface DocumentGenerationParams {
+    attachToQuote?: boolean;
+    documentFormat?: 'DOCX';
+    shouldPreventDownload?: boolean;
+}
+export declare class DocumentTemplatesApiService {
+    private service;
+    private salesforceApiService;
+    private fileDownloadService;
+    private documentAttachmentService;
+    private http;
+    readonly DOCGEN_TAG = "docgen";
+    private readonly SERVICE_URL;
+    private readonly DOC_GEN_URL_FALLBACK;
+    private readonly DOC_GEN_URL;
+    constructor(service: BaseHttpService, salesforceApiService: SalesforceApiService, fileDownloadService: FileDownloadService, documentAttachmentService: DocumentAttachmentApiService, http: HttpClient);
+    getTemplates(tag?: string): Observable<DocumentTemplate[]>;
+    getTemplate(id: string): Observable<DocumentTemplate>;
+    upsertTemplate(template: DocumentTemplate, file?: File, reportProgress?: boolean): Observable<DocumentTemplate>;
+    removeTemplate(id: string): Observable<DocumentTemplate>;
+    restoreTemplate(id: string): Observable<void>;
+    cloneTemplate(id: string, propertiesToOverride?: Partial<DocumentTemplate>): Observable<{
+        clonedRecordId: string;
+    }>;
+    getTemplateFile(id: string): Observable<ArrayBuffer>;
+    downloadTemplateFile(id: string): Observable<Blob>;
+    mergeDocuments(document: Blob, attachments: ArrayBuffer[]): Observable<ArrayBuffer>;
+    getAttachments(searchRequest: TemplateAttachmentSearchRequest): Observable<Attachment[]>;
+    getAttachmentFile(id: string): any;
+    createAttachment(attachment: Attachment, file?: File, reportProgress?: boolean): Observable<Attachment>;
+    removeAttachment(id: string): Observable<unknown>;
+    generateDocumentData(template: DocumentTemplate, object: any, params?: DocumentGenerationParams): Observable<any>;
+    generateDocument(template: DocumentTemplate, object: any, params?: DocumentGenerationParams): Observable<Blob>;
+    private generateDocumentDataLegacy;
+    private resolveAttachments$;
+    private mapSfQueryResult;
+    private mapBooleanIfAplicable;
+    private queryObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentTemplatesApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentTemplatesApiService>;
+}

package/lib/services/flows-api.service.d.ts

@@ -0,0 +1,13 @@
+import { Flow } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { ConfigurationSettingsApiService } from './configuration-settings-api.service';
+import * as i0 from "@angular/core";
+export declare class FlowsApiService {
+    private configurationSettingsApiService;
+    private readonly flowsKey;
+    constructor(configurationSettingsApiService: ConfigurationSettingsApiService);
+    getFlow(id: string): Observable<Flow | undefined>;
+    fetchFlows(): Observable<Flow[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowsApiService>;
+}

package/lib/services/picklists-api.service.d.ts

@@ -0,0 +1,17 @@
+import { BaseHttpService, NewPicklist, NewPicklistValue, Picklist } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class PicklistsApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchAllPicklists$: () => Observable<Picklist[]>;
+    fetchPicklist$: (code: string) => Observable<Picklist>;
+    createPicklist$: (picklist: NewPicklist) => Observable<Picklist>;
+    updatePicklist$: (picklist: Picklist) => Observable<Picklist>;
+    removePicklist$: (id: string) => Observable<void>;
+    restorePicklist$: (id: string) => Observable<void>;
+    addPicklistValue$: (picklist: Picklist, value: NewPicklistValue) => Observable<Picklist>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistsApiService>;
+}

package/lib/services/price-api.service.d.ts

@@ -0,0 +1,16 @@
+import { BaseHttpService, PriceList, PriceSummary } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { PriceCalculateRequest } from '../types/price.types';
+import * as i0 from "@angular/core";
+export declare class PriceApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    calculate(request: PriceCalculateRequest): Observable<PriceSummary>;
+    getPriceLists(): Observable<PriceList[]>;
+    getPriceList(id: string): Observable<PriceList>;
+    getSellingTermByEndDate(planId?: string, offeringId?: string, startDate?: string, endDate?: string, frequencyUnit?: string, frequencyDuration?: string): Observable<any>;
+    getSellingTermByTerm(planId?: string, offeringId?: string, startDate?: string, term?: number, frequencyUnit?: string, frequencyDuration?: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PriceApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PriceApiService>;
+}

package/lib/services/procedures-api.service.d.ts

@@ -0,0 +1,27 @@
+import { BaseHttpService, Expression, NewProcedure, Procedure, ProcedureExecuteRequest, QuoteDraft } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest } from '../types/clone-request.types';
+import * as i0 from "@angular/core";
+export declare class ProceduresApiService {
+    private baseHttpService;
+    private readonly ADMIN_SERVICE_URL;
+    private readonly SERVICE_URL;
+    constructor(baseHttpService: BaseHttpService);
+    fetchProcedures$: () => Observable<Procedure[]>;
+    searchProcedures$: (expression: Expression, skip: number, count: number) => Observable<Procedure[]>;
+    createProcedure$: (newProcedure: NewProcedure) => Observable<Procedure>;
+    updateProcedure$: (procedure: Procedure) => Observable<Procedure>;
+    duplicateProcedure$: (body: CloneRequest) => Observable<string>;
+    removeProcedure$: (id: string) => Observable<string>;
+    restoreProcedure$: (id: string) => Observable<string>;
+    fetchProcedure$(id: string): Observable<Procedure>;
+    execute$(body: ProcedureExecuteRequest): Observable<string[]>;
+    /**
+     * Run active procedure against QuoteDraft
+     * @param body
+     * @returns
+     */
+    apply$(body: QuoteDraft): Observable<QuoteDraft>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProceduresApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProceduresApiService>;
+}

package/lib/services/product-api.service.d.ts

@@ -0,0 +1,31 @@
+import { AttributeDefinition, BaseHttpService, Expression, LazyChunkRequest, NewAttributeDefinition, NewProduct, NewProductAttribute, Product, ProductAttribute } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ProductApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchProducts$: (payload: LazyChunkRequest) => Observable<Product[]>;
+    searchProducts$: (expression: Expression, skip: number, count: number) => Observable<Product[]>;
+    fetchProduct$: (id: string) => Observable<Product>;
+    fetchAttributes$: () => Observable<AttributeDefinition[]>;
+    searchAttributes$: (expression: Expression, skip: number, count: number) => Observable<AttributeDefinition[]>;
+    fetchAttributesByModel: (modelId: string) => Observable<AttributeDefinition[]>;
+    createNewProduct$: (productData: NewProduct) => Observable<Product>;
+    updateProduct$: (body: Product) => Observable<Product>;
+    removeProduct$: (id: string) => Observable<string>;
+    restoreProduct$: (id: string) => Observable<void>;
+    createProductAttribute$: (attributeData: NewProductAttribute) => Observable<AttributeDefinition>;
+    updateProductAttribute$: (attributeData: ProductAttribute) => Observable<AttributeDefinition>;
+    removeProductAttribute$: (id: string) => Observable<void>;
+    createNewAttribute$: (attributeData: NewAttributeDefinition) => Observable<AttributeDefinition>;
+    updateAttribute$: (body: AttributeDefinition) => Observable<AttributeDefinition>;
+    removeAttribute$: (id: string) => Observable<void>;
+    restoreAttribute$: (id: string) => Observable<void>;
+    attachImage$(productId: string, file: File): Observable<void>;
+    removeImage$(productId: string): Observable<void>;
+    fetchImage$(productId: string): Observable<File>;
+    getImageUrl(productId: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductApiService>;
+}

package/lib/services/product-model-api.service.d.ts

@@ -0,0 +1,30 @@
+import { BaseHttpService, ModelReleaseRequest, PmlConfigurationMode, ProductModel, ProductModelsContainer, ProductModelVersion } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ProductModelApiService {
+    private httpService;
+    static MAX_RESULTS: number;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    addModel(model: ProductModel): Observable<any>;
+    releaseModel(model: ModelReleaseRequest): Observable<any>;
+    removeModel(modelId: string, successFn?: any, failureFn?: any): void;
+    getModelVersions(modelId: string, count?: number, skip?: number): Observable<ProductModelVersion[]>;
+    getModel(id: string, version?: string): Observable<ProductModel>;
+    getModels(skipCount: number, searchText: string): Observable<ProductModel[]>;
+    getLinkedModels(id: string, version?: string): Observable<ProductModel[]>;
+    load(id: string, version?: string): Observable<ProductModelsContainer>;
+    getPML(modelId: string, version?: string): Observable<any>;
+    savePML(modelId: string, pml: string, comment: string): Observable<any>;
+    generateProducts(modelId: string): Observable<ProductModel>;
+    saveModel(productModel: ProductModel, comment: string): Observable<string>;
+    validateModel(productModel: ProductModel): Observable<string>;
+    renameModel(productModel: ProductModel, name: string): Observable<any>;
+    uploadPmlFile(file: File, modelId: string): Observable<any>;
+    runPml(modelId: string, pml: string, rootType: string, configurationMode: PmlConfigurationMode): Observable<any>;
+    evictAllCache(): Observable<{
+        result: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductModelApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductModelApiService>;
+}

package/lib/services/quote-api.service.d.ts

@@ -0,0 +1,25 @@
+import { BaseHttpService, HttpRequestConfigurableOptions, QuoteDraft } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class QuoteApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    getQuoteDraft(objectId: string, params?: Dictionary<string>, errorHandler?: (error: any) => void): Observable<QuoteDraft>;
+    /**
+     * @deprecated
+     * Will be removed in next major release
+     * Use `getQuoteDraft` instead
+     */
+    getQuote: (objectId: string, params?: Dictionary<string> | undefined, errorHandler?: ((error: any) => void) | undefined) => Observable<QuoteDraft>;
+    upsertQuote(request: QuoteDraft, options?: HttpRequestConfigurableOptions): Observable<{
+        quoteId: string;
+    }>;
+    submitQuote(request: QuoteDraft, options?: HttpRequestConfigurableOptions): Observable<{
+        quoteId: string;
+    }>;
+    attachDocument(id: string, documentName: string, data: any): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuoteApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QuoteApiService>;
+}

package/lib/services/ramp-api.service.d.ts

@@ -0,0 +1,13 @@
+import { BaseHttpService, HttpRequestConfigurableOptions, PriceSummary } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { NextRampRequest, RenewRampRequest } from '../types';
+import * as i0 from "@angular/core";
+export declare class RampApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    next(request: NextRampRequest, options?: HttpRequestConfigurableOptions): Observable<PriceSummary>;
+    renew(request: RenewRampRequest, options?: HttpRequestConfigurableOptions): Observable<PriceSummary>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RampApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RampApiService>;
+}

package/lib/services/rule-groups-api.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseHttpService, Expression, NewRuleGroup, RuleGroup } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest } from '../types/clone-request.types';
+import * as i0 from "@angular/core";
+export declare class RuleGroupsApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchRuleGroups$: () => Observable<RuleGroup[]>;
+    searchRuleGroups$: (expression: Expression, skip: number, count: number) => Observable<RuleGroup[]>;
+    createRuleGroup$: (ruleGroup: NewRuleGroup) => Observable<RuleGroup>;
+    updateRuleGroup$: (ruleGroup: RuleGroup) => Observable<RuleGroup>;
+    duplicateRuleGroup$: (body: CloneRequest) => Observable<string>;
+    removeRuleGroup$: (id: string) => Observable<string>;
+    restoreRuleGroup$: (id: string) => Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleGroupsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuleGroupsApiService>;
+}

package/lib/services/rules-api.service.d.ts

@@ -0,0 +1,21 @@
+import { BaseHttpService, Expression, HeaderField, NewRule, Rule, RuleExecuteRequest } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest } from '../types/clone-request.types';
+import * as i0 from "@angular/core";
+export declare class RulesApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchRules$: () => Observable<Rule[]>;
+    searchRules$: (expression: Expression, skip: number, count: number) => Observable<Rule[]>;
+    createRule$: (rule: NewRule) => Observable<Rule>;
+    updateRule$: (rule: Rule) => Observable<Rule>;
+    duplicateRule$: (body: CloneRequest) => Observable<string>;
+    removeRule$: (id: string) => Observable<string>;
+    restoreRule$: (id: string) => Observable<string>;
+    fetchRule$(id: string): Observable<Rule>;
+    fetchHeaderFields$(): Observable<HeaderField[]>;
+    execute$(body: RuleExecuteRequest): Observable<string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RulesApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RulesApiService>;
+}

package/lib/services/salesforce-api.service.d.ts

@@ -0,0 +1,17 @@
+import { HttpParams } from '@angular/common/http';
+import { BaseHttpService, HttpRequestConfigurableOptions, SalesforceField, SalesforceObject, SearchRequest } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SalesforceApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    query<T>(searchRequest: SearchRequest, objectName: string, options?: HttpRequestConfigurableOptions): Observable<T[]>;
+    queryObjects(search?: string, options?: HttpRequestConfigurableOptions): Observable<SalesforceObject[]>;
+    describe(objectName: string, fieldName?: string, options?: HttpRequestConfigurableOptions): Observable<SalesforceField[]>;
+    describe2<T>(objectName: string, fields: string[], options?: HttpRequestConfigurableOptions): Observable<T>;
+    apexGetRequest<T>(path: string, params: HttpParams, options?: HttpRequestConfigurableOptions): Observable<T>;
+    apexPostRequest<T, S>(path: string, body: S, options?: HttpRequestConfigurableOptions): Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SalesforceApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SalesforceApiService>;
+}

package/lib/services/scripts-api.service.d.ts

@@ -0,0 +1,21 @@
+import { BaseHttpService, Expression, NewScript, Script, ScriptDetails, ScriptExecuteRequest } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest } from '../types/clone-request.types';
+import * as i0 from "@angular/core";
+export declare class ScriptsApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchScripts$: () => Observable<Script[]>;
+    searchScripts$: (expression: Expression, skip: number, count: number) => Observable<Script[]>;
+    fetchScript$: (id: string) => Observable<ScriptDetails>;
+    createScript$: (script: NewScript) => Observable<Script>;
+    updateScriptMeta$: (script: Script) => Observable<Script>;
+    updateScriptDetails$: (script: ScriptDetails) => Observable<ScriptDetails>;
+    cloneScript$: (cloneRequest: CloneRequest) => Observable<string>;
+    removeScript$: (id: string) => Observable<string>;
+    restoreScript$: (id: string) => Observable<string>;
+    execute$: (body: ScriptExecuteRequest) => Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScriptsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScriptsApiService>;
+}

package/lib/services/ui-templates-api.service.d.ts

@@ -0,0 +1,49 @@
+import { BaseHttpService, ComponentAttachments, ComponentStory, ComponentStoryAttachments, Expression, NewComponentStory, NewTemplateComponent, NewUITemplate, TemplateAttachmentType, TemplateComponent, UITemplate } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { Observable } from 'rxjs';
+import { CloneRequest } from '../types/clone-request.types';
+import * as i0 from "@angular/core";
+export declare class UITemplatesApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchTemplates$: (name?: string | undefined) => Observable<UITemplate[]>;
+    createTemplate$: (template: NewUITemplate) => Observable<UITemplate>;
+    updateTemplate$: (template: UITemplate) => Observable<UITemplate>;
+    duplicateTemplate$: (template: UITemplate, cloneRequest: CloneRequest) => Observable<string>;
+    removeTemplate$: (id: string) => Observable<void>;
+    restoreTemplate$: (id: string) => Observable<void>;
+    searchTemplates$: (data: {
+        params?: Dictionary<string>;
+        expression?: Expression;
+    }) => Observable<UITemplate[]>;
+    fetchComponents$: (templateId: string, name?: string | undefined) => Observable<TemplateComponent[]>;
+    fetchComponent$: (templateId: string, componentId: string) => Observable<TemplateComponent>;
+    createComponent$: (component: NewTemplateComponent) => Observable<TemplateComponent>;
+    updateComponent$: (component: TemplateComponent) => Observable<TemplateComponent>;
+    duplicateComponent$: (component: TemplateComponent, cloneRequest: CloneRequest) => Observable<string>;
+    removeComponent$: (templateId: string, componentId: string) => Observable<void>;
+    restoreComponent$: (templateId: string, componentId: string) => Observable<void>;
+    searchComponents$: (templateId: string, data: {
+        params?: Dictionary<string>;
+        expression?: Expression;
+    }) => Observable<TemplateComponent[]>;
+    fetchStoryAttachment: (templateId: string, componentId: string, storyId: string, type: TemplateAttachmentType) => Observable<string>;
+    private convertToComponentStory$;
+    fetchStories$: (templateId: string, componentId: string, name?: string | undefined) => Observable<ComponentStory[]>;
+    fetchStory$: (templateId: string, componentId: string, storyId: string) => Observable<ComponentStory>;
+    createComponentStory$: (templateId: string, story: NewComponentStory) => Observable<ComponentStory>;
+    updateComponentStory$: (templateId: string, story: ComponentStory) => Observable<ComponentStory>;
+    duplicateComponentStory$: (story: ComponentStory, cloneRequest: CloneRequest) => Observable<string>;
+    deleteComponentStory$: (templateId: string, componentId: string, storyId: string) => Observable<void>;
+    restoreComponentStory$: (templateId: string, componentId: string, storyId: string) => Observable<void>;
+    uploadStoryAttachments$: (templateId: string, componentId: string, storyId: string, attachments: ComponentStoryAttachments) => Observable<void>;
+    getTemplateThumbnailUrl(templateId: string): string;
+    attachTemplateThumbnail$(templateId: string, file: File): Observable<any>;
+    removeTemplateThumbnail$(templateId: string): Observable<any>;
+    fetchComponentAttachments$: (templateId: string, component: TemplateComponent) => Observable<ComponentAttachments>;
+    private fetchComponentAttachmentFile$;
+    uploadComponentAttachments$: (templateId: string, componentId: string, attachments: ComponentAttachments) => Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UITemplatesApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UITemplatesApiService>;
+}

package/lib/types/clone-request.types.d.ts

@@ -0,0 +1,5 @@
+import { Dictionary } from 'lodash';
+export interface CloneRequest {
+    id: string;
+    propertiesToOverride: Dictionary<any>;
+}

package/lib/types/delta-request.types.d.ts

@@ -0,0 +1,5 @@
+import { LineItem } from '@veloceapps/core';
+export interface CalculateDeltaRequest {
+    initialState: LineItem[];
+    currentState: LineItem[];
+}

package/lib/types/dto/attribute-dto.types.d.ts

@@ -0,0 +1,11 @@
+import { Attribute } from '@veloceapps/core';
+export declare class AttributeDTO {
+    name: string;
+    type: string;
+    value: any;
+    cfgStatus: string;
+    id?: string | undefined;
+    scale?: number | undefined;
+    static fromDTO(dto: AttributeDTO): Attribute;
+    constructor(name: string, type: string, value: any, cfgStatus: string, id?: string | undefined, scale?: number | undefined);
+}

package/lib/types/dto/charge-group-item-dto.types.d.ts

@@ -0,0 +1,26 @@
+import { ChargeGroupItem } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { PriceAdjustmentDTO } from './price-adjustment-dto.types';
+export declare class ChargeGroupItemDTO {
+    chargeType: string;
+    chargeMethod: string;
+    properties: Dictionary<string>;
+    id?: string | undefined;
+    chargeTypeDisplayValue?: string | undefined;
+    frequencyUnit?: string | undefined;
+    frequencyDuration?: number | undefined;
+    basePrice?: number | undefined;
+    currency?: string | undefined;
+    sellingTerm?: number | undefined;
+    netPrice?: number | undefined;
+    listPrice?: number | undefined;
+    netUnitPrice?: number | undefined;
+    listUnitPrice?: number | undefined;
+    cost?: number | undefined;
+    priceAdjustment?: PriceAdjustmentDTO | undefined;
+    priceWaterfalls?: PriceAdjustmentDTO[] | undefined;
+    priceAdjustmentEnabled?: boolean | undefined;
+    listPriceAdjustmentEnabled?: boolean | undefined;
+    static fromDTO(dto: ChargeGroupItemDTO): ChargeGroupItem;
+    constructor(chargeType: string, chargeMethod: string, properties: Dictionary<string>, id?: string | undefined, chargeTypeDisplayValue?: string | undefined, frequencyUnit?: string | undefined, frequencyDuration?: number | undefined, basePrice?: number | undefined, currency?: string | undefined, sellingTerm?: number | undefined, netPrice?: number | undefined, listPrice?: number | undefined, netUnitPrice?: number | undefined, listUnitPrice?: number | undefined, cost?: number | undefined, priceAdjustment?: PriceAdjustmentDTO | undefined, priceWaterfalls?: PriceAdjustmentDTO[] | undefined, priceAdjustmentEnabled?: boolean | undefined, listPriceAdjustmentEnabled?: boolean | undefined);
+}

package/lib/types/dto/charge-item-dto.types.d.ts

@@ -0,0 +1,41 @@
+import { ChargeItem, RequiresApproval } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { PriceAdjustmentDTO } from './price-adjustment-dto.types';
+export declare class ChargeItemDTO {
+    id: string;
+    price: number;
+    unitPrice: number;
+    baseListPrice: number;
+    baseListUnitPrice: number;
+    listPrice: number;
+    listUnitPrice: number;
+    netPrice: number;
+    previousNetPrice: number;
+    netUnitPrice: number;
+    chargeId: string;
+    chargeType: string;
+    chargeMethod: string;
+    priceItemId: string;
+    startDate: string;
+    priceWaterfalls: PriceAdjustmentDTO[];
+    quantity: number;
+    properties: Dictionary<string>;
+    chargeTypeDisplayValue?: string | undefined;
+    arr?: number | undefined;
+    frequencyUnit?: string | undefined;
+    frequencyDuration?: number | undefined;
+    endDate?: string | undefined;
+    sellingTerm?: number | undefined;
+    currency?: string | undefined;
+    unitCost?: number | undefined;
+    cost?: number | undefined;
+    minUnitPrice?: number | undefined;
+    minPrice?: number | undefined;
+    enablePriceAdjustment?: boolean | undefined;
+    enableListPriceAdjustment?: boolean | undefined;
+    listPriceAdjustment?: PriceAdjustmentDTO | undefined;
+    priceAdjustment?: PriceAdjustmentDTO | undefined;
+    requiresApprovals?: RequiresApproval[] | undefined;
+    static fromDTO(dto: ChargeItemDTO): ChargeItem;
+    constructor(id: string, price: number, unitPrice: number, baseListPrice: number, baseListUnitPrice: number, listPrice: number, listUnitPrice: number, netPrice: number, previousNetPrice: number, netUnitPrice: number, chargeId: string, chargeType: string, chargeMethod: string, priceItemId: string, startDate: string, priceWaterfalls: PriceAdjustmentDTO[], quantity: number, properties: Dictionary<string>, chargeTypeDisplayValue?: string | undefined, arr?: number | undefined, frequencyUnit?: string | undefined, frequencyDuration?: number | undefined, endDate?: string | undefined, sellingTerm?: number | undefined, currency?: string | undefined, unitCost?: number | undefined, cost?: number | undefined, minUnitPrice?: number | undefined, minPrice?: number | undefined, enablePriceAdjustment?: boolean | undefined, enableListPriceAdjustment?: boolean | undefined, listPriceAdjustment?: PriceAdjustmentDTO | undefined, priceAdjustment?: PriceAdjustmentDTO | undefined, requiresApprovals?: RequiresApproval[] | undefined);
+}

package/lib/types/dto/configuration-dto.types.d.ts

@@ -0,0 +1,18 @@
+import { Charge, CompiledPricePlan, ConfigurationContext, ConfigurePrice } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { LineItemDTO } from './line-item-dto.types';
+export interface ConfigurePriceDTO {
+    lineItem: LineItemDTO;
+    context: ConfigurationContext;
+    charges: Dictionary<Charge>;
+    pricePlans: Dictionary<CompiledPricePlan>;
+    deletedLineItems: LineItemDTO[];
+}
+export declare class ConfigurePriceDTO {
+    lineItem: LineItemDTO;
+    context: ConfigurationContext;
+    charges: Dictionary<Charge>;
+    pricePlans: Dictionary<CompiledPricePlan>;
+    static fromDTO(dto: ConfigurePriceDTO): ConfigurePrice;
+    constructor(lineItem: LineItemDTO, context: ConfigurationContext, charges: Dictionary<Charge>, pricePlans: Dictionary<CompiledPricePlan>);
+}

package/lib/types/dto/configuration-settings-dto.types.d.ts

@@ -0,0 +1,9 @@
+import { ConfigurationSettings } from '@veloceapps/core';
+export declare class ConfigurationSettingsDTO {
+    id: string;
+    key: string;
+    value: string;
+    static fromDTO(dto: ConfigurationSettingsDTO, key?: string): ConfigurationSettings;
+    static toDTO(data: ConfigurationSettings): ConfigurationSettingsDTO;
+    constructor(id: string, key: string, value: string);
+}

package/lib/types/dto/domain-type-dto.types.d.ts

@@ -0,0 +1,15 @@
+import { DomainType } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { RecommendedPriceDTO } from './recommended-price-dto.types';
+export declare class DomainTypeDTO {
+    name: string;
+    displayName: string;
+    minCard: number;
+    maxCard: number;
+    recommendedPrices?: RecommendedPriceDTO[] | undefined;
+    properties?: Dictionary<string> | undefined;
+    status?: string | undefined;
+    cardinality?: number | undefined;
+    static fromDTO(dto: DomainTypeDTO): DomainType;
+    constructor(name: string, displayName: string, minCard: number, maxCard: number, recommendedPrices?: RecommendedPriceDTO[] | undefined, properties?: Dictionary<string> | undefined, status?: string | undefined, cardinality?: number | undefined);
+}