@veloceapps/api 12.0.0-17 → 12.0.0-19

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

@@ -0,0 +1,18 @@
+import { BaseHttpService, ConfigurationSettings, HttpRequestConfigurableOptions } from '@veloceapps/core';
+import { MessageService } from 'primeng/api';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ConfigurationSettingsApiService {
+    private httpService;
+    private messageService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService, messageService: MessageService);
+    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<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationSettingsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationSettingsApiService>;
+}

package/v2/services/context-definition-admin-api.service.d.ts

@@ -0,0 +1,16 @@
+import { BaseHttpService, ContextDefinition, ContextDefinitionStructure, ContextMapping, ContextMappingDetails, RlmProcedure } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ContextDefinitionAdminApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchContextDefinitions$(): Observable<ContextDefinition[]>;
+    fetchContextMappings$(id: string): Observable<ContextMapping[]>;
+    fetchContextMappingsDetails$(id: string): Observable<ContextMappingDetails[]>;
+    fetchAcceptableContextMappings$(id: string, pricingProcedureId: string): Observable<ContextMappingDetails[]>;
+    fetchContextDefinitionStructure$(id: string): Observable<ContextDefinitionStructure>;
+    fetchRlmProcedures(contextDefinitionId?: string): Observable<RlmProcedure[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextDefinitionAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextDefinitionAdminApiService>;
+}

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

@@ -0,0 +1,17 @@
+import { Attachment, BaseHttpService, FileDownloadService } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { TemplateAttachmentSearchRequest } from '../types';
+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/v2/services/endpoints-admin-api.service.d.ts

@@ -0,0 +1,20 @@
+import { BaseHttpService, Endpoint, EndpointExecuteRequest, Expression, NewEndpoint } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest } from '../types/clone-request.types';
+import * as i0 from "@angular/core";
+export declare class EndpointsAdminApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchEndpoints$(): Observable<Endpoint[]>;
+    searchEndpoints$(expression: Expression, skip: number, count: number): Observable<Endpoint[]>;
+    removeEndpoint$(id: string): Observable<void>;
+    restoreEndpoint$(id: string): Observable<void>;
+    fetchEndpoint$(id: string): Observable<Endpoint>;
+    createEndpoint$(body: NewEndpoint): Observable<Endpoint>;
+    updateEndpoint$(body: Endpoint): Observable<Endpoint>;
+    duplicateEndpoint$(cloneRequest: CloneRequest): Observable<Endpoint>;
+    executeEndpoint$(body: EndpointExecuteRequest): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EndpointsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EndpointsAdminApiService>;
+}

package/v2/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>;
+    fetchFlows(): Observable<Flow[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowsApiService>;
+}

package/v2/services/functions-admin-api.service.d.ts

@@ -0,0 +1,25 @@
+import { BaseHttpService, Expression, FunctionDataSet, HeaderField, NewRule, Rule } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest, FunctionExecuteRequest, FunctionExecuteRequestData } from '../types';
+import * as i0 from "@angular/core";
+export declare class FunctionsAdminApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchAll$: () => Observable<Rule[]>;
+    search$: (expression: Expression, skip?: number, count?: number) => Observable<Rule[]>;
+    create$: (rule: NewRule) => Observable<Rule>;
+    update$: (rule: Rule) => Observable<Rule>;
+    duplicate$: (body: CloneRequest) => Observable<string>;
+    remove$: (id: string) => Observable<string>;
+    restore$: (id: string) => Observable<string>;
+    fetch$(id: string): Observable<Rule>;
+    fetchHeaderFields$(): Observable<HeaderField[]>;
+    execute$(body: FunctionExecuteRequest): Observable<FunctionExecuteRequestData>;
+    executeExtractFunction$(body: FunctionExecuteRequest): Observable<string[]>;
+    fetchFunctionDatasets$(): Observable<FunctionDataSet[]>;
+    fetchFunctionTags$(): Observable<string[]>;
+    fetchObjectParentIdFields$(objectName: string): Observable<string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FunctionsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FunctionsAdminApiService>;
+}

package/v2/services/guided-sellings-admin-api.service.d.ts

@@ -0,0 +1,20 @@
+import { BaseHttpService, Expression, GuidedSelling, NewGuidedSelling } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest, QuerySearchParams } from '../types';
+import * as i0 from "@angular/core";
+export declare class GuidedSellingsAdminApiService {
+    private baseHttpService;
+    static MAX_RESULTS: number;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchGuidedSellings$: (searchParams?: QuerySearchParams) => Observable<GuidedSelling[]>;
+    searchGuidedSellings$: (searchParams?: QuerySearchParams, expression?: Expression) => Observable<GuidedSelling[]>;
+    fetchGuidedSelling$: (id: string) => Observable<GuidedSelling>;
+    createNewGuidedSelling$: (guidedSelling: NewGuidedSelling) => Observable<GuidedSelling>;
+    duplicateGuidedSelling$: (cloneRequest: CloneRequest) => Observable<GuidedSelling>;
+    updateGuidedSelling$: (data: GuidedSelling) => Observable<void>;
+    removeGuidedSelling$: (id: string) => Observable<void>;
+    restoreGuidedSelling$: (id: string) => Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidedSellingsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuidedSellingsAdminApiService>;
+}

package/v2/services/guided-sellings-api.service.d.ts

@@ -0,0 +1,13 @@
+import { BaseHttpService, GuidedSelling } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { QuerySearchParams } from '../types';
+import * as i0 from "@angular/core";
+export declare class GuidedSellingApiService {
+    private http;
+    private readonly serviceUrl;
+    constructor(http: BaseHttpService);
+    searchByName$(name: string, searchParams?: QuerySearchParams): Observable<GuidedSelling[]>;
+    searchById$(id: string, searchParams?: QuerySearchParams): Observable<GuidedSelling[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidedSellingApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuidedSellingApiService>;
+}

package/v2/services/index.d.ts

@@ -0,0 +1,23 @@
+export * from './cache-api.service';
+export * from './catalog-admin-api.service';
+export * from './catalog-api.service';
+export * from './configuration-processors-api.service';
+export * from './configuration-settings-api.service';
+export * from './context-definition-admin-api.service';
+export * from './document-attachment-api.service';
+export * from './endpoints-admin-api.service';
+export * from './flows-api.service';
+export * from './functions-admin-api.service';
+export * from './guided-sellings-admin-api.service';
+export * from './guided-sellings-api.service';
+export * from './orchestrations-admin-api.service';
+export * from './orchestrations-api.service';
+export * from './pcm-api.service';
+export * from './picklists-admin-api.service';
+export * from './products-admin-api.service';
+export * from './sales-transactions-api.service';
+export * from './salesforce-api.service';
+export * from './shopping-cart-settings-api.service';
+export * from './ui-definitions-admin-api.service';
+export * from './ui-templates-admin-api.service';
+export * from './veloce-objects-api.service';

package/v2/services/orchestrations-admin-api.service.d.ts

@@ -0,0 +1,21 @@
+import { BaseHttpService, Expression, NewProcedure, Procedure } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest, ProcedureExecuteRequest } from '../types';
+import * as i0 from "@angular/core";
+export declare class OrchestrationsAdminApiService {
+    private baseHttpService;
+    private readonly SERVICE_URL;
+    constructor(baseHttpService: BaseHttpService);
+    fetchAll$: () => Observable<Procedure[]>;
+    search$: (expression: Expression, skip: number, count: number) => Observable<Procedure[]>;
+    create$: (newProcedure: NewProcedure) => Observable<Procedure>;
+    update$: (procedure: Procedure) => Observable<Procedure>;
+    duplicate$: (body: CloneRequest) => Observable<string>;
+    remove$: (id: string) => Observable<string>;
+    restore$: (id: string) => Observable<string>;
+    fetch$(id: string): Observable<Procedure>;
+    execute$(body: ProcedureExecuteRequest): Observable<string[]>;
+    catalogExecute$(body: ProcedureExecuteRequest): Observable<string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrchestrationsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OrchestrationsAdminApiService>;
+}

package/v2/services/orchestrations-api.service.d.ts

@@ -0,0 +1,12 @@
+import { BaseHttpService, HttpRequestConfigurableOptions, TransactionContext } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { ProcedureApplyRequest } from '../types';
+import * as i0 from "@angular/core";
+export declare class OrchestrationsApiService {
+    private baseHttpService;
+    private readonly SERVICE_URL;
+    constructor(baseHttpService: BaseHttpService);
+    apply$(request: ProcedureApplyRequest, options?: HttpRequestConfigurableOptions): Observable<TransactionContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrchestrationsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OrchestrationsApiService>;
+}

package/v2/services/pcm-api.service.d.ts

@@ -0,0 +1,12 @@
+import { PCMModel } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { SalesforceApiService } from './salesforce-api.service';
+import * as i0 from "@angular/core";
+export declare class PCMApiService {
+    private sfApiService;
+    constructor(sfApiService: SalesforceApiService);
+    fetchPCMByProductId(productId: string): Observable<PCMModel>;
+    private fixUrls;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PCMApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PCMApiService>;
+}

package/v2/services/picklists-admin-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 PicklistsAdminApiService {
+    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<PicklistsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistsAdminApiService>;
+}

package/v2/services/products-admin-api.service.d.ts

@@ -0,0 +1,21 @@
+import { BaseHttpService, Expression, LazyChunkRequest, NewProduct, Product } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ProductsAdminApiService {
+    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>;
+    createNewProduct$: (productData: NewProduct) => Observable<Product>;
+    updateProduct$: (body: Product) => Observable<Product>;
+    removeProduct$: (id: string) => Observable<string>;
+    restoreProduct$: (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<ProductsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductsAdminApiService>;
+}

package/v2/services/sales-transactions-api.service.d.ts

@@ -0,0 +1,26 @@
+import { BaseHttpService, HttpRequestConfigurableOptions, TransactionContext } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { SalesTransactionRequestParams, SalesTransactionUpsertRequest } from '../types';
+import * as i0 from "@angular/core";
+export declare class SalesTransactionApiService {
+    private httpService;
+    private readonly SERVICE_URL;
+    constructor(httpService: BaseHttpService);
+    /**
+     * This endpoint doesn't include orders and assets
+     * @param objectId SF record ID (quoteId | accountId | opportunityId | orderId etc)
+     * @param params Query params
+     * @param options Request options
+     */
+    getState(objectId: string, params?: SalesTransactionRequestParams, options?: HttpRequestConfigurableOptions): Observable<TransactionContext>;
+    /**
+     * This endpoint doesn't include orders and assets
+     * @param headerId SF record ID (quoteId | accountId | opportunityId | orderId etc)
+     * @param params Query params
+     * @param options Request options
+     */
+    query(headerId: string, params?: Record<string, string>, options?: HttpRequestConfigurableOptions): Observable<TransactionContext>;
+    save(request: SalesTransactionUpsertRequest, options?: HttpRequestConfigurableOptions): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SalesTransactionApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SalesTransactionApiService>;
+}

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

@@ -0,0 +1,26 @@
+import { HttpParams } from '@angular/common/http';
+import { BaseHttpService, GlobalPicklist, GlobalPicklistValue, 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[]>;
+    search<T = any>(req: {
+        searchString: string;
+    }, options?: HttpRequestConfigurableOptions): Observable<{
+        searchRecords: T[];
+    }>;
+    describeObject(objectName: string, options?: HttpRequestConfigurableOptions): Observable<SalesforceField[]>;
+    describeField(objectName: string, fieldName: string, options?: HttpRequestConfigurableOptions): Observable<SalesforceField>;
+    describe2<T>(objectName: string, fields: string[], options?: HttpRequestConfigurableOptions): Observable<T>;
+    apexGetRequest<T>(path: string, params: HttpParams | Record<string, any>, options?: HttpRequestConfigurableOptions): Observable<T>;
+    apexPostRequest<T, S>(path: string, body: S, options?: HttpRequestConfigurableOptions): Observable<T>;
+    restGetRequest<T>(path: string, params: HttpParams | Record<string, any>, options?: HttpRequestConfigurableOptions): Observable<T>;
+    getGlobalPicklists(): Observable<GlobalPicklist[]>;
+    getGlobalPicklistValues(id: string): Observable<GlobalPicklistValue[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SalesforceApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SalesforceApiService>;
+}

package/v2/services/shopping-cart-settings-api.service.d.ts

@@ -0,0 +1,14 @@
+import { ConfigurationSettings, ShoppingCartSetting, ShoppingCartSettings } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { ConfigurationSettingsApiService } from './configuration-settings-api.service';
+import * as i0 from "@angular/core";
+export declare class ShoppingCartSettingsApiService {
+    private configurationSettingsApiService;
+    private readonly shoppingCartSettingsKey;
+    constructor(configurationSettingsApiService: ConfigurationSettingsApiService);
+    getSetting(id: string): Observable<ShoppingCartSetting | undefined>;
+    fetchSettings(): Observable<ConfigurationSettings | null>;
+    getSettingsMap(): Observable<ShoppingCartSettings>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShoppingCartSettingsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShoppingCartSettingsApiService>;
+}

package/v2/services/ui-definitions-admin-api.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseHttpService, HttpRequestConfigurableOptions, NewUIDefinitionContainer, UIDefinitionContainer } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class UIDefinitionsAdminApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchAll$(params?: {
+        productId?: string;
+        defaultUIDefinitionId?: string;
+    }, options?: HttpRequestConfigurableOptions): Observable<UIDefinitionContainer[]>;
+    fetch$(id: string, options?: HttpRequestConfigurableOptions): Observable<UIDefinitionContainer>;
+    create$(uiDefinitionContainer: NewUIDefinitionContainer): Observable<UIDefinitionContainer>;
+    update$(uiDefinitionContainer: UIDefinitionContainer): Observable<UIDefinitionContainer>;
+    delete$(id: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UIDefinitionsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UIDefinitionsAdminApiService>;
+}

package/v2/services/ui-templates-admin-api.service.d.ts

@@ -0,0 +1,50 @@
+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 UITemplatesAdminApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchTemplates$: (name?: string) => 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) => 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) => 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>;
+    fetchComponentsAttachments$: (templateId: string) => Observable<ComponentAttachments[]>;
+    private fetchComponentAttachmentFile$;
+    uploadComponentAttachments$: (templateId: string, componentId: string, attachments: ComponentAttachments) => Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UITemplatesAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UITemplatesAdminApiService>;
+}

package/v2/services/veloce-objects-api.service.d.ts

@@ -0,0 +1,23 @@
+import { BaseHttpService, Expression, NewVeloceObject, NewVeloceObjectCategory, VeloceObject, VeloceObjectCategory } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { CloneRequest, QuerySearchParams } from '../types';
+import * as i0 from "@angular/core";
+export declare class VeloceObjectsAdminApiService {
+    private baseHttpService;
+    private readonly serviceUrl;
+    constructor(baseHttpService: BaseHttpService);
+    fetchCategories$(): Observable<VeloceObjectCategory[]>;
+    createCategory$(category: NewVeloceObjectCategory): Observable<VeloceObjectCategory>;
+    updateCategory$: (category: VeloceObjectCategory) => Observable<VeloceObjectCategory>;
+    deleteCategory$: (id: string) => Observable<void>;
+    fetchObjects$(): Observable<VeloceObject[]>;
+    fetchObject$(id: string): Observable<VeloceObject>;
+    searchObjects$: (searchParams?: QuerySearchParams, expression?: Expression) => Observable<VeloceObject[]>;
+    createObject$(object: NewVeloceObject): Observable<VeloceObject>;
+    updateObject$(object: VeloceObject): Observable<VeloceObject>;
+    deleteObject$: (id: string) => Observable<void>;
+    duplicateObject$: (body: CloneRequest) => Observable<string>;
+    restoreObject$: (id: string) => Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloceObjectsAdminApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VeloceObjectsAdminApiService>;
+}

package/v2/types/attachment.types.d.ts

@@ -0,0 +1,4 @@
+export interface TemplateAttachmentSearchRequest {
+    linkedEntityId: string;
+    tag?: string;
+}

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

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

package/v2/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/v2/types/dto/ui-definition-dto.types.d.ts

@@ -0,0 +1,7 @@
+import { NewUIDefinitionContainer, UIDefinitionContainer } from '@veloceapps/core';
+export type UIDefinitionContainerDTO = Omit<UIDefinitionContainer, 'source'> & {
+    sourceBlob: string;
+};
+export type NewUIDefinitionContainerDTO = Omit<NewUIDefinitionContainer, 'source'> & {
+    sourceBlob: string;
+};

package/v2/types/dto/ui-template-dto.types.d.ts

@@ -0,0 +1,6 @@
+export interface UIComponentStoryDTO {
+    id: string;
+    name: string;
+    uiComponentId: string;
+    description?: string;
+}

package/v2/types/function.types.d.ts

@@ -0,0 +1,14 @@
+import { ContextNode, Rule, TransactionContext } from '@veloceapps/core';
+export interface FunctionExecuteRequest {
+    function: Rule;
+    data: FunctionExecuteRequestData;
+}
+export interface FunctionExecuteRequestData {
+    context?: TransactionContext;
+    dataSets?: Record<string, ContextNode[]>;
+    doNotAlignEndDates?: boolean;
+    deployStartDateGradually?: boolean;
+    deployEndDateGradually?: boolean;
+    events?: unknown[];
+    logs?: string[];
+}

package/v2/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './attachment.types';
+export * from './clone-request.types';
+export * from './function.types';
+export * from './procedure.types';
+export * from './sales-transaction.types';
+export * from './search-request.types';

package/v2/types/pcm.types.d.ts

@@ -0,0 +1,10 @@
+import { PCMModel } from '@veloceapps/core';
+export interface PCMResponse {
+    corellationId: string;
+    products: PCMModel[];
+    status: {
+        code: string;
+        errors: unknown[];
+        message: string;
+    };
+}

package/v2/types/procedure.types.d.ts

@@ -0,0 +1,61 @@
+import { ExtractRuleMapper, ExtractRuleQuery, ExtractRuleRequest, MetricRuleMapper, Procedure, RuleCondition, RuleMapper, RuleTypes, TransactionContext } from '@veloceapps/core';
+export interface ProcedureApplyRequest {
+    transactionContext: TransactionContext;
+    orchestrationName?: string;
+    flowId?: string;
+}
+export interface OrchestrationNew {
+    id: string;
+    name: string;
+    description: string;
+    type?: string;
+    active: boolean;
+    deployStartDateGradually: boolean;
+    deployEndDateGradually: boolean;
+    contextDefinitionId?: string;
+    steps?: OrchestrationStepNew[];
+}
+export interface OrchestrationStepNew {
+    id?: string;
+    name: string;
+    active: boolean;
+    sequence?: number;
+    orchestrationId?: string;
+    parentStepId?: string;
+    functionId?: string;
+    function?: FunctionRule;
+    steps?: OrchestrationStepNew[];
+}
+export interface NewFunctionRule {
+    name: string;
+    sequence: number;
+    description: string;
+    parentId: string;
+    active: boolean;
+    type?: RuleTypes;
+    cached?: boolean;
+    duration?: number;
+}
+export interface FunctionRule extends NewFunctionRule {
+    id: string;
+    contextDefinitionId?: string;
+    contextMappingId?: string;
+    procedure: ProcedureInvocation;
+    conditions: RuleCondition[];
+    queries: ExtractRuleQuery[];
+    requests: ExtractRuleRequest[];
+    actions: RuleMapper[] | MetricRuleMapper[] | ExtractRuleMapper[];
+    transformations: any[];
+    parentName: string;
+    parentType: RuleTypes;
+    isDefault: boolean;
+}
+export interface ProcedureInvocation {
+    id?: string;
+    functionId: string;
+    pricingProcedureId: string;
+}
+export interface ProcedureExecuteRequest {
+    orchestration: Procedure;
+    context: any;
+}

package/v2/types/sales-transaction.types.d.ts

@@ -0,0 +1,13 @@
+import { TransactionContext } from '@veloceapps/core';
+export interface SalesTransactionUpsertRequest {
+    transactionContext: TransactionContext;
+    orchestrationName?: string;
+    flowId?: string;
+}
+export interface SalesTransactionRequestParams {
+    contextMappingId?: string;
+    [key: string]: unknown;
+}
+export interface SalesTransactionUpsertResponse {
+    id: string;
+}

package/v2/types/search-request.types.d.ts

@@ -0,0 +1,8 @@
+export type QuerySearchParams = {
+    skip?: number;
+    count?: number;
+    sort?: string;
+    asc?: boolean;
+} & {
+    [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+};

package/v2/utils/ui-definition.utils.d.ts

@@ -0,0 +1,5 @@
+import { NewUIDefinitionContainer, UIDefinitionContainer } from '@veloceapps/core';
+import { NewUIDefinitionContainerDTO, UIDefinitionContainerDTO } from '../types/dto/ui-definition-dto.types';
+export declare function uiDefinitionFromDTO(container: UIDefinitionContainerDTO): UIDefinitionContainer;
+export declare function uiDefinitionToDTO(container: UIDefinitionContainer): UIDefinitionContainerDTO;
+export declare function newUiDefinitionToDTO(container: NewUIDefinitionContainer): NewUIDefinitionContainerDTO;

package/v2/utils/ui-template.utils.d.ts

@@ -0,0 +1,3 @@
+import { ComponentStory, ComponentStoryAttachments } from '@veloceapps/core';
+import { UIComponentStoryDTO } from '../types/dto/ui-template-dto.types';
+export declare const fromUIComponentStoryDTO: (dto: UIComponentStoryDTO, attachments: ComponentStoryAttachments) => ComponentStory;