@veloceapps/sdk 5.0.13-0

package/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@veloceapps/sdk",
+  "version": "5.0.13-0",
+  "private": false,
+  "peerDependencies": {
+    "@angular/animations": "^12.2.0",
+    "@angular/common": "^12.2.0",
+    "@angular/core": "^12.2.0",
+    "@angular/forms": "^12.2.0",
+    "@angular/platform-browser-dynamic": "^12.2.0",
+    "@angular/platform-browser": "^12.2.0",
+    "@veloceapps/core": "5.0.0",
+    "@veloceapps/api": "5.0.0",
+    "@veloceapps/components": "5.0.0",
+    "ionicons": "^4.6.3",
+    "rxjs": "^7.3.0",
+    "zone.js": "~0.11.4",
+    "lodash": "^4.17.21",
+    "brotli-wasm": "^1.2.0",
+    "pako": "^1.0.11",
+    "primeng": "^12.2.2",
+    "angular-expressions": "^1.1.4",
+    "docxtemplater": "^3.28.1",
+    "pizzip": "^3.1.1",
+    "@aws-sdk/client-xray": "^3.40.0",
+    "monaco-editor": "^0.30.1",
+    "@angular/router": "^12.2.0",
+    "jshashes": "^1.0.8",
+    "@veloce/elements": "^1.1.2",
+    "ngx-bootstrap": "^5.6.2"
+  },
+  "dependencies": {
+    "@angular/cdk": "^12.2.12",
+    "@angular/cdk-experimental": "^13.1.0",
+    "@angular/compiler": "^12.2.0",
+    "@babel/standalone": "^7.17.1",
+    "moment": "^2.29.1",
+    "tslib": "^2.2.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "bundles/veloceapps-sdk.umd.js",
+  "module": "fesm2015/veloceapps-sdk.js",
+  "es2015": "fesm2015/veloceapps-sdk.js",
+  "esm2015": "esm2015/veloceapps-sdk.js",
+  "fesm2015": "fesm2015/veloceapps-sdk.js",
+  "typings": "veloceapps-sdk.d.ts"
+}

package/runtime/components/component-preview/component-preview.component.d.ts

@@ -0,0 +1,27 @@
+import { ChangeDetectorRef, OnChanges, SimpleChanges } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ComponentStoryPreview, Section } from '@veloceapps/core';
+import { FormScopeService } from '../../services/form-scope.service';
+import { RuntimeFormService } from '../../services/runtime-form.service';
+import { RuntimeService } from '../../services/runtime.service';
+import { SectionsService } from '../../services/section.service';
+import * as i0 from "@angular/core";
+export declare class ComponentPreviewComponent implements OnChanges {
+    private sectionsService;
+    private runtimeFormService;
+    private formScope;
+    private runtimeService;
+    private cdr;
+    data?: ComponentStoryPreview;
+    form: FormGroup;
+    section?: Section;
+    showPreview: boolean;
+    isNoPreviewAvailable: boolean;
+    isPreviewFailed: boolean;
+    constructor(sectionsService: SectionsService, runtimeFormService: RuntimeFormService, formScope: FormScopeService, runtimeService: RuntimeService, cdr: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    runPreview(data: ComponentStoryPreview): void;
+    createRuntimeContext(section: Section): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ComponentPreviewComponent, "vl-component-preview", never, { "data": "data"; }, {}, never, never>;
+}

package/runtime/components/index.d.ts

@@ -0,0 +1,4 @@
+export { ComponentPreviewComponent } from './component-preview/component-preview.component';
+export { SectionRendererComponent } from './section-renderer/section-renderer.component';
+export { RuntimePreviewComponent } from './ui-runtime-preview/runtime-preview.component';
+export { RuntimeComponent } from './ui-runtime/runtime.component';

package/runtime/components/section-renderer/section-renderer.component.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, Injector, NgModuleRef, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloceapps/core';
+import { SectionScopeService } from '../../services/section-scope.service';
+import { SectionStoreService } from '../../services/section-store.service';
+import * as i0 from "@angular/core";
+export declare class SectionRendererComponent implements OnInit, AfterViewInit, OnDestroy {
+    private _injector;
+    private _m;
+    private sectionScope;
+    private sectionStore;
+    private _section;
+    set section(value: Section);
+    get section(): Section;
+    form: FormGroup;
+    constructor(_injector: Injector, _m: NgModuleRef<any>, sectionScope: SectionScopeService, sectionStore: SectionStoreService);
+    container: ViewContainerRef;
+    private componentRef;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    renderSection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionRendererComponent, "vl-section-renderer", never, { "section": "section"; "form": "form"; }, {}, never, never>;
+}

package/runtime/components/ui-runtime/runtime.component.d.ts

@@ -0,0 +1,53 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { LineItem, OrderByPipe, SearchFilterPipe, Section, UITab } from '@veloceapps/core';
+import { ContextService } from '@veloceapps/sdk/core';
+import { MessageService } from 'primeng/api';
+import { CollapsibleStateService } from '../../services/collapsible-state.service';
+import { FormScopeService } from '../../services/form-scope.service';
+import { RuntimeFormService } from '../../services/runtime-form.service';
+import { RuntimeService } from '../../services/runtime.service';
+import { SectionsService } from '../../services/section.service';
+import { LegacyRuntimeContext, SolutionReadyAware } from '../../types';
+import * as i0 from "@angular/core";
+export declare class RuntimeComponent implements OnInit, OnDestroy, SolutionReadyAware {
+    private sectionsService;
+    private formScope;
+    private collapsibleState;
+    private formService;
+    private runtimeService;
+    private messageService;
+    private contextService;
+    private orderByPipe;
+    private searchFilterPipe;
+    private cdr;
+    readonly messageBucketId = "ui.runtime";
+    sortedSections: Section[];
+    staticSections: Section[];
+    runtimeContext: LegacyRuntimeContext;
+    solutionLineItem: LineItem;
+    form: FormGroup;
+    activeUITab?: UITab;
+    solutionIsReady: boolean;
+    private readonly unsubscribe;
+    private readonly solutionUpdated;
+    constructor(sectionsService: SectionsService, formScope: FormScopeService, collapsibleState: CollapsibleStateService, formService: RuntimeFormService, runtimeService: RuntimeService, messageService: MessageService, contextService: ContextService, orderByPipe: OrderByPipe, searchFilterPipe: SearchFilterPipe, cdr: ChangeDetectorRef);
+    private adjustPrice;
+    ngOnInit(): void;
+    onSolutionReady(lineItem: LineItem): void;
+    private handleSolutionUpdate;
+    private handleSolutionFailedUpdate;
+    private updateCardinalityVariable;
+    private createLineItem;
+    ngOnDestroy(): void;
+    private startRuntime;
+    private updateRuntime;
+    addToCart(): void;
+    processSolution(isUpdate?: boolean, isError?: boolean): void;
+    hideModal(): void;
+    private updateLineItemsSectionPath;
+    private filterAndSort;
+    private findSection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuntimeComponent, "vl-runtime", never, {}, { "solutionUpdated": "solutionUpdated"; }, never, never>;
+}

package/runtime/components/ui-runtime-preview/runtime-preview.component.d.ts

@@ -0,0 +1,27 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ConfigurationApiService } from '@veloceapps/api';
+import { LineItem, UIDefinition } from '@veloceapps/core';
+import { ContextService } from '@veloceapps/sdk/core';
+import { ProductModelCacheService } from '../../services/product-model-cache.service';
+import { RuntimeService } from '../../services/runtime.service';
+import * as i0 from "@angular/core";
+export declare class RuntimePreviewComponent implements OnInit, OnDestroy {
+    private runtimeService;
+    private modelCacheService;
+    private configurationApiService;
+    private contextService;
+    modelId?: string;
+    set uiDefinition(value: UIDefinition);
+    private _uiDefinition?;
+    private initialisedUiDefinition?;
+    private productModelContainer?;
+    private destroy$;
+    constructor(runtimeService: RuntimeService, modelCacheService: ProductModelCacheService, configurationApiService: ConfigurationApiService, contextService: ContextService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    initDefinition(uiDefinition: UIDefinition): void;
+    onSolutionUpdated(lineItem: LineItem): void;
+    private launchRuntime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimePreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuntimePreviewComponent, "vl-runtime-preview", never, { "modelId": "modelId"; "uiDefinition": "uiDefinition"; }, {}, never, never>;
+}

package/runtime/execution/components/children-placeholder/children-placeholder.component.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloceapps/core';
+import { Subscription } from 'rxjs';
+import { CollapsibleStateService } from '../../../services/collapsible-state.service';
+import { FormScopeService } from '../../../services/form-scope.service';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import * as i0 from "@angular/core";
+export declare class ChildrenPlaceholderComponent implements OnInit, OnChanges, OnDestroy {
+    private sectionScope;
+    private formScope;
+    private collapsibleState;
+    children?: Section[];
+    _children: Section[];
+    section: Section;
+    form: FormGroup;
+    sub: Subscription;
+    collapsed: boolean;
+    constructor(sectionScope: SectionScopeService, formScope: FormScopeService, collapsibleState: CollapsibleStateService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setChildren(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChildrenPlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChildrenPlaceholderComponent, "children-placeholder", never, { "children": "children"; }, {}, never, never>;
+}
+export declare class TemplateComponent extends ChildrenPlaceholderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateComponent, "template-component", never, {}, {}, never, never>;
+}

package/runtime/execution/components/context-provider/context-provider.component.d.ts

@@ -0,0 +1,14 @@
+import { OnInit } from '@angular/core';
+import { ProductType, RuntimeProduct, RuntimeType } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { RuntimeService } from '../../../services/runtime.service';
+import * as i0 from "@angular/core";
+export declare class ContextProviderComponent implements OnInit {
+    private runtimeService;
+    types: (RuntimeType | ProductType)[];
+    products: Dictionary<RuntimeProduct[]>;
+    constructor(runtimeService: RuntimeService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextProviderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextProviderComponent, "vl-context-provider", never, { "types": "types"; "products": "products"; }, {}, never, never>;
+}

package/runtime/execution/components/execution-section-renderer/execution-section-renderer.component.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, Injector, NgModuleRef, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloceapps/core';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import { SectionStoreService } from '../../../services/section-store.service';
+import * as i0 from "@angular/core";
+export declare class ExecutionSectionRendererComponent implements OnInit, AfterViewInit, OnDestroy {
+    private _injector;
+    private _m;
+    private sectionScope;
+    private sectionStore;
+    private _section;
+    set section(value: Section);
+    get section(): Section;
+    form: FormGroup;
+    constructor(_injector: Injector, _m: NgModuleRef<any>, sectionScope: SectionScopeService, sectionStore: SectionStoreService);
+    container: ViewContainerRef;
+    private componentRef;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    renderSection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExecutionSectionRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExecutionSectionRendererComponent, "section-renderer", never, { "section": "section"; "form": "form"; }, {}, never, never>;
+}

package/runtime/execution/components/federated/federated.component.d.ts

@@ -0,0 +1,36 @@
+import { AfterViewInit, ApplicationRef, Compiler, ElementRef, Injector, OnChanges, Renderer2, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';
+import { LineItem } from '@veloceapps/core';
+import * as i0 from "@angular/core";
+declare enum IntegrationEvent {
+    Init = "Init"
+}
+interface InputData {
+    rootLineItem: LineItem;
+}
+interface IntegrationEventPayload {
+    type: IntegrationEvent;
+    payload?: unknown;
+}
+export declare class FederatedComponent implements AfterViewInit, OnChanges {
+    private injector;
+    private compiler;
+    private appRef;
+    private renderer;
+    federatedComponent?: ViewContainerRef;
+    foo?: TemplateRef<unknown>;
+    moduleHostRef?: ElementRef;
+    remoteEntry?: string;
+    remoteName?: string;
+    exposedModule?: string;
+    data?: InputData;
+    eventData?: IntegrationEventPayload;
+    private integrationEvent;
+    moduleReady: boolean;
+    private instance?;
+    constructor(injector: Injector, compiler: Compiler, appRef: ApplicationRef, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FederatedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FederatedComponent, "veloce-host-federated", never, { "remoteEntry": "remoteEntry"; "remoteName": "remoteName"; "exposedModule": "exposedModule"; "data": "data"; "eventData": "eventData"; }, { "integrationEvent": "integrationEvent"; }, never, never>;
+}
+export {};

package/runtime/execution/components/velo-attribute/velo-attribute.component.d.ts

@@ -0,0 +1,19 @@
+import { OnInit } from '@angular/core';
+import { FormScopeService } from '../../../services/form-scope.service';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import { VeloAttributeDirective } from '../../directives/velo-attribute.directive';
+import * as i0 from "@angular/core";
+export declare class VeloAttributeComponent extends VeloAttributeDirective implements OnInit {
+    controlName: string;
+    displayName: string;
+    isMultiselect: boolean;
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    getValueOptions(valueOptions: unknown): (string | number)[];
+    getValueText(valueOptions: unknown, value: string | number): string;
+    handleMultiselectChange(value: string | number): void;
+    handleMultipleDropdownChange(event: any): void;
+    private isBooleanType;
+    private getDisplayName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloAttributeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloAttributeComponent, "velo-attribute", never, {}, {}, never, never>;
+}

package/runtime/execution/components/velo-multiselect/velo-multiselect.component.d.ts

@@ -0,0 +1,35 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { ElementRef, EventEmitter, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class MultiselectComponent implements ControlValueAccessor, OnDestroy {
+    private elRef;
+    private viewContainerRef;
+    private overlay;
+    options?: any[];
+    selectionChange: EventEmitter<string[]>;
+    selected: string[];
+    displayValue: string;
+    touched: boolean;
+    disabled: boolean;
+    overlayTemplate: TemplateRef<any>;
+    opened: boolean;
+    private overlayRef?;
+    private dropdownClosingActionsSub?;
+    onChange: (selected: string[]) => void;
+    onTouched: () => void;
+    constructor(elRef: ElementRef, viewContainerRef: ViewContainerRef, overlay: Overlay);
+    ngOnDestroy(): void;
+    writeValue(selected: string[]): void;
+    registerOnChange(onChange: any): void;
+    registerOnTouched(onTouched: any): void;
+    setDisabledState(disabled: boolean): void;
+    handleSelection(value: any): void;
+    toggleOpened(): void;
+    private getDisplayValue;
+    private openDropdown;
+    private dropdownClosingActions;
+    private destroyDropdown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiselectComponent, "velo-multiselect", never, { "options": "options"; }, { "selectionChange": "selectionChange"; }, never, never>;
+}

package/runtime/execution/components/velo-port-checkbox/velo-port-checkbox.component.d.ts

@@ -0,0 +1,22 @@
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloceapps/core';
+import { FormScopeService } from '../../../services/form-scope.service';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import * as i0 from "@angular/core";
+export declare class VeloPortCheckBoxComponent {
+    private formScope;
+    private sectionScope;
+    controlName: string;
+    form: FormGroup;
+    section: Section;
+    showSelectAll: boolean;
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    handleChange(valueOption: string): void;
+    hasValueFor(valueOption: string): boolean;
+    selectAllChange(): void;
+    isAllSelected(): boolean;
+    getMessages(valueOption: string): string[];
+    private findLineItemForValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloPortCheckBoxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloPortCheckBoxComponent, "velo-port-checkbox", never, { "showSelectAll": "showSelectAll"; }, {}, never, ["*"]>;
+}

package/runtime/execution/components/velo-port-dropdown/velo-port-dropdown.component.d.ts

@@ -0,0 +1,22 @@
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { FormScopeService } from '../../../services/form-scope.service';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import * as i0 from "@angular/core";
+export declare class VeloPortDropdownComponent {
+    private formScope;
+    private sectionScope;
+    controlName: string;
+    qtyControlName: string;
+    form: FormGroup;
+    section: Section;
+    prices: Dictionary<any>;
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    isAddAllowed(): boolean;
+    handleCreate(): void;
+    private findPriceItemsForValue;
+    private add;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloPortDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloPortDropdownComponent, "velo-port-dropdown", never, {}, {}, never, ["*"]>;
+}

package/runtime/execution/components/velo-port-radio/velo-port-radio.component.d.ts

@@ -0,0 +1,28 @@
+import { OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { LineItem, RecommendedPrice, Section } from '@veloceapps/core';
+import { Dictionary } from 'lodash';
+import { FormScopeService } from '../../../services/form-scope.service';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import * as i0 from "@angular/core";
+export declare class VeloPortRadioComponent implements OnInit {
+    private formScope;
+    private sectionScope;
+    controlName: string;
+    form: FormGroup;
+    section: Section;
+    prices: Dictionary<any>;
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    ngOnInit(): void;
+    handleChange(event: any, valueOption: any): void;
+    hasValueFor(valueOption: string): boolean;
+    getMessages(valueOption: string): LineItem['messages'];
+    toString(price: RecommendedPrice): string;
+    private hasPreviousValue;
+    private findLineItemForValue;
+    private initPriceItems;
+    private findPriceItemsForValue;
+    private add;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloPortRadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloPortRadioComponent, "velo-port-radio", never, {}, {}, never, ["*", "*"]>;
+}

package/runtime/execution/components/velo-type/velo-type.component.d.ts

@@ -0,0 +1,31 @@
+import { OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { RecommendedPrice, Section } from '@veloceapps/core';
+import { MessageService } from 'primeng/api';
+import { CollapsibleStateService } from '../../../services/collapsible-state.service';
+import { FormScopeService } from '../../../services/form-scope.service';
+import { SectionScopeService } from '../../../services/section-scope.service';
+import * as i0 from "@angular/core";
+export declare class VeloTypeComponent implements OnInit {
+    private formScope;
+    private collapsibleState;
+    private sectionScope;
+    private messageService;
+    readonly messageBucketId = "ui-runtime";
+    controlName: string;
+    qtyControlName: string;
+    displayName: string;
+    indent: number;
+    form: FormGroup;
+    section: Section;
+    prices: RecommendedPrice[];
+    constructor(formScope: FormScopeService, collapsibleState: CollapsibleStateService, sectionScope: SectionScopeService, messageService: MessageService);
+    ngOnInit(): void;
+    handleRemove(): void;
+    handleQuantityUpdate(): void;
+    toggleCollapse(): void;
+    getPrices(): RecommendedPrice[];
+    private add;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloTypeComponent, "velo-type", never, {}, {}, never, ["*"]>;
+}

package/runtime/execution/directives/section-script.directive.d.ts

@@ -0,0 +1,59 @@
+import { AfterViewInit, ChangeDetectorRef, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+import { ContextService, QuoteDraftService } from '@veloceapps/sdk/core';
+import { ShoppingCartService } from '../../services/cart.service';
+import { CurrentStateService } from '../../services/current-state.service';
+import { FormScopeService } from '../../services/form-scope.service';
+import { RuntimeService } from '../../services/runtime.service';
+import { SectionScopeService } from '../../services/section-scope.service';
+import { SfQueryDirective } from './sf-query.directive';
+import { LineItemDirective } from './velo-port.directive';
+import { VlApprovalDirective } from './vl-approval.directive';
+import { VlDocumentAttachmentsDirective } from './vl-document-attachments.directive';
+import { VlDocumentTemplatesDirective } from './vl-document-templates.directive';
+import { VlQuoteDirective } from './vl-quote.directive';
+import { VlRampDirective } from './vl-ramp.directive';
+import * as i0 from "@angular/core";
+export declare class SectionScriptDirective implements OnInit, AfterViewInit, OnDestroy {
+    private _document;
+    private sfQueryDirective;
+    private lineItemDirective;
+    private quoteDirective;
+    private documentTemplatesDirective;
+    private rampDirective;
+    private approvalDirective;
+    private documentAttachmentsDirective;
+    private formScope;
+    private sectionScope;
+    private renderer;
+    private formBuilder;
+    private runtimeService;
+    private cdr;
+    private cartService;
+    private contextService;
+    private currentStateService;
+    private quoteService;
+    private scriptElement;
+    private scriptId;
+    private registry;
+    private sessionScope;
+    constructor(_document: Document, sfQueryDirective: SfQueryDirective, lineItemDirective: LineItemDirective, quoteDirective: VlQuoteDirective, documentTemplatesDirective: VlDocumentTemplatesDirective, rampDirective: VlRampDirective, approvalDirective: VlApprovalDirective, documentAttachmentsDirective: VlDocumentAttachmentsDirective, formScope: FormScopeService, sectionScope: SectionScopeService, renderer: Renderer2, formBuilder: FormBuilder, runtimeService: RuntimeService, cdr: ChangeDetectorRef, cartService: ShoppingCartService, contextService: ContextService, currentStateService: CurrentStateService, quoteService: QuoteDraftService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get scope(): any;
+    private scriptExists;
+    private encodeScriptBody;
+    private generateScriptId;
+    private getScriptRegistry;
+    private getSessionScope;
+    private initScript;
+    private removeScript;
+    private appendScriptElementToDom;
+    private removeScriptElementFromDom;
+    private scriptFromTemplate;
+    private methodApply;
+    private getExposedApis;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionScriptDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SectionScriptDirective, "section-script", ["scriptApi"], {}, {}, never>;
+}

package/runtime/execution/directives/sf-query.directive.d.ts

@@ -0,0 +1,15 @@
+import { HttpParams } from '@angular/common/http';
+import { SalesforceApiService } from '@veloceapps/api';
+import { SearchRequest } from '@veloceapps/core';
+import * as i0 from "@angular/core";
+export declare class SfQueryDirective {
+    private apiService;
+    constructor(apiService: SalesforceApiService);
+    query(searchRequest: SearchRequest, objectName: string): Promise<any>;
+    describe(objectName: string, fieldName?: string): Promise<any>;
+    describe2(objectName: string, fieldsNames: string[]): Promise<any>;
+    apexGetRequest<T = unknown>(path: string, params: HttpParams): Promise<T>;
+    apexPostRequest<T = unknown, S = unknown>(path: string, body: S): Promise<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SfQueryDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SfQueryDirective, "sf-query", ["sfApi"], {}, {}, never>;
+}

package/runtime/execution/directives/velo-attribute.directive.d.ts

@@ -0,0 +1,26 @@
+import { OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { Section } from '@veloceapps/core';
+import { FormScopeService } from '../../services/form-scope.service';
+import { SectionScopeService } from '../../services/section-scope.service';
+import * as i0 from "@angular/core";
+export declare class VeloAttributeDirective implements OnInit {
+    private formScope;
+    private sectionScope;
+    valueQuantities: {
+        [index: string]: number;
+    };
+    form: FormGroup;
+    section: Section;
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    ngOnInit(): void;
+    handleChange(valueOption?: any): void;
+    handleChangDate(valueOption: any): void;
+    handleRemove(): void;
+    nextVal(): void;
+    prevVal(): void;
+    private initQuantity;
+    private getCurrentValueIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloAttributeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VeloAttributeDirective, "velo-attribute-directive", ["attributeApi"], {}, {}, never>;
+}

package/runtime/execution/directives/velo-port.directive.d.ts

@@ -0,0 +1,74 @@
+import { OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { LineItem, Section } from '@veloceapps/core';
+import { ConfigurationService } from '../../services/configuration.service';
+import { FormScopeService } from '../../services/form-scope.service';
+import { SectionScopeService } from '../../services/section-scope.service';
+import { LegacyRuntimeContext } from '../../types';
+import * as i0 from "@angular/core";
+export declare class SectionContextAware implements OnInit {
+    protected formScope: FormScopeService;
+    protected sectionScope: SectionScopeService;
+    controlName: string;
+    qtyControlName: string;
+    form: FormGroup;
+    section: Section;
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    ngOnInit(): void;
+    initControlNames(): void;
+    isAddAllowed(quantityToAdd?: number): boolean;
+    isRemoveAllowed(quantityToRemove?: number): boolean;
+    handleCreate(valueOption?: any): void;
+    handleChange(valueOption?: any): void;
+    handleQtyChange(valueOption: any): void;
+    handleRemove(valueOption: string): void;
+    handleCopy(valueOption: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionContextAware, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SectionContextAware, never, never, {}, {}, never>;
+}
+export declare class LineItemDirective implements OnInit {
+    private formScope;
+    private sectionScope;
+    private configurationService;
+    section: Section;
+    lineItem?: LineItem;
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService, configurationService: ConfigurationService);
+    ngOnInit(): void;
+    handlePatch(rootLineItem: any): void;
+    configure(runtimeContext: LegacyRuntimeContext, configurableRamp: LineItem): Promise<LineItem>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LineItemDirective, "line-item", ["liApi"], {}, {}, never>;
+}
+export declare class VeloPortDirective extends SectionContextAware implements OnInit {
+    valueQuantities: {
+        [index: string]: number;
+    };
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    private handlePriceAdjustment;
+    ngOnInit(): void;
+    handleUpsert(valueOption?: any, event?: Event): void;
+    isActive(valueOption?: any): boolean;
+    private initQuantity;
+    handleNextVal(valueOption: string): void;
+    handlePrevVal(valueOption: string): void;
+    handleManualQtyChange(valueOption: string, qtyVal: any): void;
+    handleNetPriceAdjustment(valueOption: string, amount: number): void;
+    handleListPriceAdjustment(valueOption: string, amount: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloPortDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VeloPortDirective, "velo-port", ["portApi"], {}, {}, never>;
+}
+export declare class VeloDropdownComponent extends SectionContextAware {
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloDropdownComponent, "velo-dropdown", never, {}, {}, never, never>;
+}
+export declare class VeloQuantityComponent extends SectionContextAware {
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloQuantityComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloQuantityComponent, "velo-quantity", never, {}, {}, never, never>;
+}
+export declare class VeloQuantityButtonComponent extends SectionContextAware {
+    constructor(formScope: FormScopeService, sectionScope: SectionScopeService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VeloQuantityButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VeloQuantityButtonComponent, "velo-quantity-button", never, {}, {}, never, never>;
+}