@sitecore-jss/sitecore-jss-angular 22.10.0-canary.9 → 22.10.0

package/dist/index.d.ts

@@ -1,5 +1,642 @@
+import * as i0 from '@angular/core';
+import { OnChanges, SimpleChanges, ViewContainerRef, EmbeddedViewRef, TemplateRef, Type, Renderer2, InjectionToken, OnInit, DoCheck, OnDestroy, EventEmitter, TransferState, ModuleWithProviders } from '@angular/core';
+import { GenericFieldValue, FieldMetadata, ComponentRendering, HtmlElementRendering, LayoutServiceContextData, RouteData } from '@sitecore-jss/sitecore-jss/layout';
+export { ComponentFields, ComponentParams, ComponentRendering, EditMode, Field, GraphQLLayoutService, HtmlElementRendering, LayoutService, LayoutServiceContext, LayoutServiceContextData, LayoutServiceData, LayoutServicePageState, PlaceholdersData, RestLayoutService, RouteData, getChildPlaceholder, getContentStylesheetLink, getFieldValue } from '@sitecore-jss/sitecore-jss/layout';
+import { MetadataKind, EditFrameDataSource, EditButtonTypes } from '@sitecore-jss/sitecore-jss/editing';
+export { DefaultEditFrameButton, DefaultEditFrameButtons, EditFrameDataSource, FieldEditButton, WebEditButton, handleEditorAnchors, isEditorActive, resetEditorChromes } from '@sitecore-jss/sitecore-jss/editing';
+import { NavigationExtras, ActivatedRouteSnapshot, RouterStateSnapshot, Router, UrlTree, RedirectCommand } from '@angular/router';
+import { Observable } from 'rxjs';
+import * as i1 from '@angular/common';
+export { mediaApi } from '@sitecore-jss/sitecore-jss/media';
+export { DictionaryPhrases, DictionaryService, GraphQLDictionaryService, RestDictionaryService } from '@sitecore-jss/sitecore-jss/i18n';
+export { DefaultRetryStrategy, GraphQLClientError, GraphQLRequestClient, GraphQLRequestClientFactoryConfig, RetryStrategy, getEdgeProxyContentUrl } from '@sitecore-jss/sitecore-jss/graphql';
+export { CacheClient, CacheOptions, ClientError, HTMLLink, HttpDataFetcher, HttpResponse, MemoryCacheClient, NativeDataFetcher, NativeDataFetcherConfig, NativeDataFetcherError, NativeDataFetcherResponse, constants, debug, enableDebug } from '@sitecore-jss/sitecore-jss';
+export { CdpHelper, DEFAULT_VARIANT, GraphQLPersonalizeService, GraphQLPersonalizeServiceConfig, PersonalizeInfo, getGroomedVariantIds, personalizeLayout } from '@sitecore-jss/sitecore-jss/personalize';
+export { isServer } from '@sitecore-jss/sitecore-jss/utils';
+export { CampaignInstance, EventInstance, GoalInstance, OutcomeInstance, PageViewInstance, TrackingRequestOptions, trackingApi } from '@sitecore-jss/sitecore-jss/tracking';
+
+interface RenderingField<V = GenericFieldValue> extends FieldMetadata {
+    value?: V;
+    editable?: string;
+}
+interface DateField extends RenderingField<string | number | Date> {
+}
+interface FileFieldValue {
+    src?: string;
+    title?: string;
+    displayName?: string;
+}
+interface FileField extends FileFieldValue, RenderingField<FileFieldValue> {
+}
+interface ImageFieldValue {
+    [key: string]: unknown;
+    src?: string;
+    srcSet?: {
+        [key: string]: string | number | undefined;
+    }[];
+}
+interface ImageField extends ImageFieldValue, RenderingField {
+    value?: ImageFieldValue;
+}
+interface LinkFieldValue {
+    [key: string]: unknown;
+    href?: string;
+    text?: string;
+    anchor?: string;
+}
+interface LinkField extends LinkFieldValue, RenderingField {
+    value?: LinkFieldValue;
+    editableFirstPart?: string;
+    editableLastPart?: string;
+}
+interface RichTextField extends RenderingField<string> {
+}
+interface TextField extends RenderingField<string> {
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * File fields cannot be managed via the EE. We never output "editable."
  */
-/// <amd-module name="@sitecore-jss/sitecore-jss-angular" />
-export * from './public_api';
+declare class FileDirective implements OnChanges {
+    field: FileField;
+    private viewRef;
+    private viewContainer;
+    private templateRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileDirective, "[scFile]", never, { "field": { "alias": "scFile"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Base class that contains common functionality for the field directives.
+ */
+declare abstract class BaseFieldDirective {
+    protected viewContainer: ViewContainerRef;
+    protected viewRef: EmbeddedViewRef<unknown>;
+    protected abstract field: RenderingField<GenericFieldValue>;
+    protected abstract editable: boolean;
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    protected abstract emptyFieldEditingTemplate: TemplateRef<unknown>;
+    /**
+     * Default component to render in Pages in Metadata edit mode if field value is empty and emptyFieldEditingTemplate is not provided
+     */
+    protected abstract defaultFieldEditingComponent: Type<unknown>;
+    /**
+     * Determines if directive should render the field as is
+     * Returns true if we are in edit mode 'chromes' (field.editable is present) or field is not empty
+     */
+    protected shouldRender(): boolean;
+    /**
+     * Renders the empty field markup which is required by Pages in editMode 'metadata' in case field is empty.
+     */
+    protected renderEmpty(): void;
+    /**
+     * Renders a metadata chrome marker for the field. Required by Pages in editMode 'metadata'.
+     * @param {string} kind - 'open' or 'close' to indicate the start or end of the metadata chrome
+     */
+    protected renderMetadata(kind: MetadataKind): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFieldDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class ImageDirective extends BaseFieldDirective implements OnChanges {
+    field: ImageField;
+    editable: boolean;
+    /**
+     * Custom regexp that finds media URL prefix that will be replaced by `/-/jssmedia` or `/~/jssmedia`.
+     * @example
+     * /\/([-~]{1})assets\//i
+     * /-assets/website -> /-/jssmedia/website
+     * /~assets/website -> /~/jssmedia/website
+     */
+    mediaUrlPrefix?: RegExp;
+    urlParams: {
+        [param: string]: string | number;
+    };
+    attrs: {
+        [param: string]: unknown;
+    };
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    emptyFieldEditingTemplate: TemplateRef<unknown>;
+    /**
+     * Default component to render in Pages in Metadata edit mode if field value is empty and emptyFieldEditingTemplate is not provided
+     */
+    protected defaultFieldEditingComponent: Type<unknown>;
+    private inlineRef;
+    private templateRef;
+    private renderer;
+    private elementRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateView;
+    private getImageAttrs;
+    private renderTemplate;
+    private getElementAttrs;
+    private renderInlineWrapper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageDirective, "[scImage]", never, { "field": { "alias": "scImage"; "required": false; }; "editable": { "alias": "scImageEditable"; "required": false; }; "mediaUrlPrefix": { "alias": "scImageMediaUrlPrefix"; "required": false; }; "urlParams": { "alias": "scImageUrlParams"; "required": false; }; "attrs": { "alias": "scImageAttrs"; "required": false; }; "emptyFieldEditingTemplate": { "alias": "scImageEmptyFieldEditingTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LinkDirective extends BaseFieldDirective implements OnChanges {
+    editable: boolean;
+    attrs: {
+        [attr: string]: string;
+    };
+    field: LinkField;
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    emptyFieldEditingTemplate: TemplateRef<unknown>;
+    /**
+     * Default component to render in Pages in Metadata edit mode if field value is empty and emptyFieldEditingTemplate is not provided
+     */
+    protected defaultFieldEditingComponent: Type<unknown>;
+    protected templateRef: TemplateRef<any>;
+    protected renderer: Renderer2;
+    private inlineRef;
+    private elementRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected renderTemplate(props: {
+        [prop: string]: unknown;
+    }, linkText?: string): void;
+    protected updateAttribute(node: HTMLElement, key: string, propValue?: unknown): void;
+    /**
+     * Determines if directive should render the field as is
+     * Returns true if we are in edit mode 'chromes' (field.editable is present) or field is not empty
+     * or link field text is present and we are not in edit mode 'metadata'
+     * The right side of the expression was added to preserve existing functionality
+     */
+    protected shouldRender(): boolean;
+    private updateView;
+    private renderInlineWrapper;
+    private getElementAttrs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LinkDirective, "[scLink]", never, { "editable": { "alias": "scLinkEditable"; "required": false; }; "attrs": { "alias": "scLinkAttrs"; "required": false; }; "field": { "alias": "scLink"; "required": false; }; "emptyFieldEditingTemplate": { "alias": "scLinkEmptyFieldEditingTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RouterLinkDirective extends LinkDirective {
+    editable: boolean;
+    attrs: {
+        [attr: string]: string;
+    };
+    field: LinkField;
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    emptyFieldEditingTemplate: TemplateRef<unknown>;
+    private router;
+    protected renderTemplate(props: {
+        [prop: string]: string;
+    }, linkText: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RouterLinkDirective, "[scRouterLink]", never, { "editable": { "alias": "scRouterLinkEditable"; "required": false; }; "attrs": { "alias": "scRouterLinkAttrs"; "required": false; }; "field": { "alias": "scRouterLink"; "required": false; }; "emptyFieldEditingTemplate": { "alias": "scRouterLinkEmptyFieldEditingTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class GenericLinkDirective extends LinkDirective {
+    editable: boolean;
+    attrs: {
+        [key: string]: string;
+    };
+    field: LinkField;
+    extras?: NavigationExtras;
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    emptyFieldEditingTemplate: TemplateRef<unknown>;
+    private router;
+    protected renderTemplate(props: {
+        [key: string]: string;
+    }, linkText: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GenericLinkDirective, "[scGenericLink]", never, { "editable": { "alias": "scGenericLinkEditable"; "required": false; }; "attrs": { "alias": "scGenericLinkAttrs"; "required": false; }; "field": { "alias": "scGenericLink"; "required": false; }; "extras": { "alias": "scGenericLinkExtras"; "required": false; }; "emptyFieldEditingTemplate": { "alias": "scGenericLinkEmptyFieldEditingTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Registers a statically loaded component */
+declare class ComponentNameAndType {
+    name: string;
+    type: Type<unknown>;
+    canActivate?: JssCanActivate | Type<JssCanActivate> | JssCanActivateFn | Array<JssCanActivate | JssCanActivateFn | Type<JssCanActivate>>;
+    resolve?: {
+        [key: string]: JssResolve<unknown> | Type<JssResolve<unknown>>;
+    };
+}
+/** Registers a lazily loaded component by name and module to lazy load when it's needed */
+interface ComponentNameAndModule {
+    /** Name of the component */
+    path: string;
+    /**
+     * Dynamic import of the component,
+     * e.g. () => import('./path/to/lazyloadedcomponent.module').then(m => m.LazyLoadedComponentModuleExportName)
+     */
+    loadChildren: () => Promise<Type<unknown>>;
+    canActivate?: JssCanActivate | JssCanActivateFn | Type<JssCanActivate> | Array<JssCanActivate | JssCanActivateFn | Type<JssCanActivate>>;
+    resolve?: {
+        [key: string]: JssResolve<unknown> | Type<JssResolve<unknown>>;
+    };
+}
+declare const DYNAMIC_COMPONENT: InjectionToken<Type<unknown> | {
+    [s: string]: unknown;
+}>;
+interface GuardInput {
+    activatedRoute: ActivatedRouteSnapshot;
+    routerState: RouterStateSnapshot;
+    rendering: ComponentRendering;
+    router: Router;
+}
+interface JssCanActivateFn {
+    (input: GuardInput): Observable<boolean | UrlTree | RedirectCommand | string | string[]> | Promise<boolean | UrlTree | RedirectCommand | string | string[]> | boolean | UrlTree | RedirectCommand | string | string[];
+}
+interface JssCanActivate {
+    canActivate: JssCanActivateFn;
+}
+interface JssResolve<T> {
+    resolve(input: GuardInput): Observable<T> | Promise<T> | T;
+}
+
+declare class PlaceholderLoadingDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlaceholderLoadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PlaceholderLoadingDirective, "[scPlaceholderLoading]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RenderEachDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderEachDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderEachDirective, "[renderEach]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RenderEmptyDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderEmptyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderEmptyDirective, "[renderEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PlaceholderComponent implements OnInit, OnChanges, DoCheck, OnDestroy {
+    name?: string;
+    rendering: ComponentRendering;
+    renderings?: Array<ComponentRendering | HtmlElementRendering>;
+    outputs: {
+        [k: string]: (eventType: unknown) => void;
+    };
+    clientOnly: boolean;
+    loaded: EventEmitter<string>;
+    failed: EventEmitter<Error>;
+    renderEachTemplate: RenderEachDirective;
+    renderEmptyTemplate: RenderEmptyDirective;
+    placeholderLoading?: PlaceholderLoadingDirective;
+    private view;
+    private metadataNode;
+    isLoading: boolean;
+    metadataMode: boolean;
+    chromeType: string;
+    private _inputs;
+    private _differ;
+    private _componentInstances;
+    private placeholderData?;
+    private destroyed;
+    private parentStyleAttribute;
+    private contextSubscription;
+    private differs;
+    private componentFactory;
+    private changeDetectorRef;
+    private elementRef;
+    private renderer;
+    private router;
+    private missingComponentComponent;
+    private hiddenRenderingComponent;
+    private guardResolver;
+    private dataResolver;
+    private platformId;
+    private jssState;
+    constructor();
+    set inputs(value: {
+        [key: string]: unknown;
+    });
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngDoCheck(): void;
+    /**
+     * Gets id for Metadata code blocks, in specific format
+     * Metadata code blocks will wrap be added around placeholder content and each rendering component
+     * to allow for editing integration in Pages.
+     * @param {string} kind code block type ("open" or "close"). "open" is added before an element, and "close" added after one.
+     * @param {string?} renderingId rendering uid to apply as id to code block
+     * @returns {string} formatted id value for code HTML node
+     */
+    getCodeBlockId: (kind: string, renderingId?: string) => string | undefined;
+    /**
+     * Get renderings/components to be rendered for current placeholder name
+     * Can modify the inner placeholders collection to adjust to using SXA dynamic placeholders
+     * @returns {ComponentRendering<ComponentFields> | HtmlElementRendering[] | null} List of renderings to be rendered
+     */
+    private getPlaceholder;
+    private _setComponentInputs;
+    private _subscribeComponentOutputs;
+    private _render;
+    private _renderTemplatedComponent;
+    private _renderEmbeddedComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlaceholderComponent, "sc-placeholder,[sc-placeholder]", never, { "name": { "alias": "name"; "required": false; }; "rendering": { "alias": "rendering"; "required": false; }; "renderings": { "alias": "renderings"; "required": false; }; "outputs": { "alias": "outputs"; "required": false; }; "clientOnly": { "alias": "clientOnly"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; }, { "loaded": "loaded"; "failed": "failed"; }, ["renderEachTemplate", "renderEmptyTemplate", "placeholderLoading"], never, true, never>;
+}
+
+declare class HiddenRenderingComponent {
+    get style(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HiddenRenderingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HiddenRenderingComponent, "sc-hidden-rendering", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a single JSS component given a rendering definition.
+ * Useful inside templated placeholders.
+ */
+declare class RenderComponentComponent implements OnChanges {
+    rendering: ComponentRendering | HtmlElementRendering;
+    outputs: {
+        [k: string]: (eventType: unknown) => void;
+    };
+    private view;
+    private _inputs;
+    private _differ;
+    private destroyed;
+    private differs;
+    private componentFactory;
+    private missingComponentComponent;
+    set inputs(value: {
+        [key: string]: unknown;
+    });
+    ngOnChanges(changes: SimpleChanges): void;
+    private _setComponentInputs;
+    private _subscribeComponentOutputs;
+    private _render;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderComponentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RenderComponentComponent, "sc-render-component", never, { "rendering": { "alias": "rendering"; "required": false; }; "outputs": { "alias": "outputs"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DateDirective extends BaseFieldDirective implements OnChanges {
+    format?: string;
+    timezone?: string;
+    locale?: string;
+    editable: boolean;
+    field: DateField;
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    emptyFieldEditingTemplate: TemplateRef<unknown>;
+    /**
+     * Default component to render in Pages in Metadata edit mode if field value is empty and emptyFieldEditingTemplate is not provided
+     */
+    protected defaultFieldEditingComponent: Type<unknown>;
+    private templateRef;
+    private datePipe;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateDirective, "[scDate]", never, { "format": { "alias": "scDateFormat"; "required": false; }; "timezone": { "alias": "scDateTimezone"; "required": false; }; "locale": { "alias": "scDateLocale"; "required": false; }; "editable": { "alias": "scDateEditable"; "required": false; }; "field": { "alias": "scDate"; "required": false; }; "emptyFieldEditingTemplate": { "alias": "scDateEmptyFieldEditingTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class EditFrameComponent implements OnChanges {
+    dataSource: EditFrameDataSource;
+    buttons: EditButtonTypes[];
+    title: string;
+    tooltip: string;
+    cssClass: string;
+    parameters: Record<string, string | number | boolean | undefined | null>;
+    sitecore: LayoutServiceContextData & {
+        route: RouteData<unknown> | null;
+    };
+    isEditing: boolean;
+    frameProps: Record<string, unknown>;
+    chromeData: string;
+    ngOnChanges(): void;
+    buildChromeData(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditFrameComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditFrameComponent, "sc-edit-frame,[sc-edit-frame]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "title": { "alias": "title"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; "sitecore": { "alias": "sitecore"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Component that renders editing scripts and client data for the current page in Sitecore Editor.
+ * Only renders scripts when Metadata mode is used.
+ */
+declare class EditingScriptsComponent implements OnInit {
+    private renderer;
+    private stateService;
+    private document;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditingScriptsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditingScriptsComponent, "sc-editing-scripts", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Shape of the Form component rendering data.
+ * FormId is the rendering parameter that specifies the ID of the Sitecore Form to render.
+ */
+type FormRendering = {
+    params: {
+        FormId: string;
+        styles?: string;
+    };
+} & ComponentRendering;
+/**
+ * A component that renders a Sitecore Form.
+ * It fetches the form markup from the Sitecore Edge service and renders it in the component's template.
+ */
+declare class FormComponent implements OnInit, OnDestroy {
+    /**
+     * The rendering data for the component
+     */
+    rendering: FormRendering;
+    hasError: boolean;
+    isEditing: boolean;
+    private contextSubscription;
+    private edgeConfig;
+    private platformId;
+    private elRef;
+    private jssState;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Fetches the form markup from the Sitecore Edge service and renders it in the component's template.
+     */
+    loadForm(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "app-form", never, { "rendering": { "alias": "rendering"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Shape of the Sitecore Edge configuration.
+ */
+type EdgeConfigToken = {
+    sitecoreEdgeUrl?: string;
+    sitecoreEdgeContextId: string;
+};
+/**
+ * Injection token for the Sitecore Edge configuration.
+ */
+declare const EDGE_CONFIG: InjectionToken<EdgeConfigToken>;
+
+declare class BaseJssState {
+    sitecore?: LayoutServiceContextData & {
+        route: RouteData | null;
+    };
+    viewBag?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * The service that is used to store and retrieve the current state of the app.
+ * Referenced by the SDK to get the current state of the app.
+ */
+declare class JssStateService<State extends BaseJssState = BaseJssState> {
+    protected transferState: TransferState;
+    private _state;
+    constructor();
+    /**
+     * Observable JSS state to subscribe to
+     */
+    get state(): Observable<State>;
+    /**
+     * The 'here and now' state value, usable without subscribing
+     */
+    get stateValue(): State;
+    /**
+     * Set new JSS state
+     * @param {JssState} newState new state
+     */
+    setState(newState: State): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JssStateService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JssStateService<any>>;
+}
+
+/**
+ * @param {HtmlElementRendering | ComponentRendering} rendering
+ */
+declare function isRawRendering(rendering: HtmlElementRendering | ComponentRendering): rendering is HtmlElementRendering;
+
+interface LayoutServiceLinkField {
+    field: {
+        link: LinkField;
+    };
+}
+interface SxaLinkListFields {
+    data: {
+        datasource: {
+            children: {
+                results: LayoutServiceLinkField[];
+            };
+            field: {
+                title: TextField;
+            };
+        };
+    };
+}
+interface SxaTitleSourceItem {
+    url: {
+        path: string;
+        siteName: string;
+    };
+    field: {
+        jsonValue: {
+            value: string;
+            editable?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+    };
+}
+interface SxaTitleFields {
+    data: {
+        datasource: SxaTitleSourceItem;
+        contextItem: SxaTitleSourceItem;
+    };
+}
+
+declare class RichTextDirective extends BaseFieldDirective implements OnChanges {
+    editable: boolean;
+    field: RichTextField;
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    emptyFieldEditingTemplate: TemplateRef<unknown>;
+    /**
+     * Default component to render in Pages in Metadata edit mode if field value is empty and emptyFieldEditingTemplate is not provided
+     */
+    protected defaultFieldEditingComponent: Type<unknown>;
+    private templateRef;
+    private renderer;
+    private router;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RichTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RichTextDirective, "[scRichText]", never, { "editable": { "alias": "scRichTextEditable"; "required": false; }; "field": { "alias": "scRichText"; "required": false; }; "emptyFieldEditingTemplate": { "alias": "scRichTextEmptyFieldEditingTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TextDirective extends BaseFieldDirective implements OnChanges {
+    editable: boolean;
+    encode: boolean;
+    field: TextField;
+    /**
+     * Custom template to render in Pages in Metadata edit mode if field value is empty
+     */
+    emptyFieldEditingTemplate: TemplateRef<unknown>;
+    /**
+     * Default component to render in Pages in Metadata edit mode if field value is empty and emptyFieldEditingTemplate is not provided
+     */
+    protected defaultFieldEditingComponent: Type<unknown>;
+    private templateRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextDirective, "[scText]", never, { "editable": { "alias": "scTextEditable"; "required": false; }; "encode": { "alias": "scTextEncode"; "required": false; }; "field": { "alias": "scText"; "required": false; }; "emptyFieldEditingTemplate": { "alias": "scTextEmptyFieldEditingTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RawComponent implements OnInit {
+    rendering: HtmlElementRendering;
+    private renderer;
+    private elementRef;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RawComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RawComponent, "sc-raw", never, { "rendering": { "alias": "rendering"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MissingComponentComponent {
+    rendering: ComponentRendering;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MissingComponentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MissingComponentComponent, "sc-missing-component", never, { "rendering": { "alias": "rendering"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class JssModule {
+    /**
+     * Instantiates the JSS module with no component factory.
+     * Useful for using it from libraries. Most of the time you'd want withComponents()
+     * @returns {ModuleWithProviders<JssModule>} module
+     */
+    static forRoot(): ModuleWithProviders<JssModule>;
+    /**
+     * Instantiates a module for a lazy-loaded JSS component(s)
+     * @param {Type<unknown> | Record<string, Type<unknown>> } value - component or map of components
+     * @returns {ModuleWithProviders<JssModule>} module
+     */
+    static forChild(value: Type<unknown> | {
+        [key: string]: Type<unknown>;
+    }): ModuleWithProviders<JssModule>;
+    /**
+     * Instantiates the JSS module and specifies the mapping from component name to component implementation.
+     * Appropriate when defining the set of JSS components that your app is aware of.
+     * @param {ComponentNameAndType[]} components
+     * @param {ComponentNameAndModule[]} [lazyComponents]
+     * @returns {ModuleWithProviders<JssModule>} module
+     */
+    static withComponents(components: ComponentNameAndType[], lazyComponents?: ComponentNameAndModule[]): ModuleWithProviders<JssModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JssModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<JssModule, never, [typeof i1.CommonModule, typeof FileDirective, typeof ImageDirective, typeof LinkDirective, typeof RouterLinkDirective, typeof GenericLinkDirective, typeof TextDirective, typeof DateDirective, typeof RenderEachDirective, typeof RenderEmptyDirective, typeof PlaceholderLoadingDirective, typeof RenderComponentComponent, typeof PlaceholderComponent, typeof RawComponent, typeof RichTextDirective, typeof MissingComponentComponent, typeof HiddenRenderingComponent, typeof EditFrameComponent, typeof EditingScriptsComponent, typeof FormComponent], [typeof FileDirective, typeof ImageDirective, typeof DateDirective, typeof LinkDirective, typeof RouterLinkDirective, typeof GenericLinkDirective, typeof RenderEachDirective, typeof RenderEmptyDirective, typeof RenderComponentComponent, typeof PlaceholderComponent, typeof HiddenRenderingComponent, typeof PlaceholderLoadingDirective, typeof RichTextDirective, typeof TextDirective, typeof EditFrameComponent, typeof EditingScriptsComponent, typeof FormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<JssModule>;
+}
+
+export { BaseJssState, ComponentNameAndType, DYNAMIC_COMPONENT, DateDirective, EDGE_CONFIG, EditFrameComponent, EditingScriptsComponent, FileDirective, FormComponent, GenericLinkDirective, HiddenRenderingComponent, ImageDirective, JssModule, JssStateService, LinkDirective, PlaceholderComponent, PlaceholderLoadingDirective, RenderComponentComponent, RenderEachDirective, RenderEmptyDirective, RichTextDirective, RouterLinkDirective, TextDirective, isRawRendering };
+export type { ComponentNameAndModule, FileField, GuardInput, ImageField, ImageFieldValue, JssCanActivate, JssCanActivateFn, JssResolve, LinkField, LinkFieldValue, RenderingField, RichTextField, SxaLinkListFields, SxaTitleFields, TextField };

package/ng-package.json

@@ -1,13 +1,13 @@
-{
-  "$schema": "./node_modules/ng-packagr/ng-package.schema.json",
-  "dest": "dist",
-  "lib": {
-    "entryFile": "./src/public_api.ts"
-  },
-  "allowedNonPeerDependencies": [
-    "sitecore-jss",
-    "@angular/common",
-    "@angular/core",
-    "@angular/router"
-  ]
-}
+{
+  "$schema": "./node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "dist",
+  "lib": {
+    "entryFile": "./src/public_api.ts"
+  },
+  "allowedNonPeerDependencies": [
+    "sitecore-jss",
+    "@angular/common",
+    "@angular/core",
+    "@angular/router"
+  ]
+}