@sitecore-content-sdk/core 0.1.0-beta.1

package/types/graphql/search-service.d.ts

@@ -0,0 +1,95 @@
+import { DocumentNode } from 'graphql';
+import { GraphQLClient } from '../graphql-request-client';
+/**
+ * Data needed to paginate results
+ */
+export interface PageInfo {
+    /**
+     * string token that can be used to fetch the next page of results
+     */
+    endCursor: string;
+    /**
+     * a value that indicates whether more pages of results are available
+     */
+    hasNext: boolean;
+}
+/**
+ * Schema of data returned in response to a "search" query request
+ * @template T The type of objects being requested.
+ */
+export type SearchQueryResult<T> = {
+    search: {
+        /**
+         * Data needed to paginate the search results
+         */
+        pageInfo: PageInfo;
+        results: T[];
+    };
+};
+/**
+ * Describes the variables used by the 'search' query. Language should always be specified.
+ * The other predicates are optional.
+ */
+export interface SearchQueryVariables {
+    /**
+     * Required. The language versions to search for. Fetch pages that have versions in this language.
+     */
+    language: string;
+    /**
+     * Optional. The ID of the search root item. Fetch items that have this item as an ancestor.
+     */
+    rootItemId?: string;
+    /**
+     * Optional. Sitecore template ID(s). Fetch items that inherit from this template(s).
+     */
+    templates?: string;
+    /**
+     * common variable for all GraphQL queries
+     * it will be used for every type of query to regulate result batch size
+     * Optional. How many result items to fetch in each GraphQL call. This is needed for pagination.
+     * @default 10
+     */
+    pageSize?: number;
+}
+/**
+ * @deprecated will be removed with SearchQueryService. Use GraphQLClient and supporting types
+ * Configuration options for service classes that extend @see SearchQueryService.
+ * This extends @see SearchQueryVariables because properties that can be passed to the search query
+ * as predicates should be configurable. 'language' is excluded because, normally, all properties
+ * except 'language' are consistent across languages so they are passed to constructors, and
+ * 'language' can vary so it is passed to methods.
+ */
+export interface SearchServiceConfig extends Omit<SearchQueryVariables, 'language'> {
+    /**
+     * The name of the current Sitecore site. This is used to to determine the search query root
+     * in cases where one is not specified by the caller.
+     */
+    siteName: string;
+}
+/**
+ * @deprecated use GraphQLClient instead
+ * Provides functionality for performing GraphQL 'search' operations, including handling pagination.
+ * This class is meant to be extended or used as a mixin; it's not meant to be used directly.
+ * @template T The type of objects being requested.
+ * @mixin
+ */
+export declare class SearchQueryService<T> {
+    protected client: GraphQLClient;
+    /**
+     * Creates an instance of search query service.
+     * @param {GraphQLClient} client that fetches data from a GraphQL endpoint.
+     */
+    constructor(client: GraphQLClient);
+    /**
+     * 1. Validates mandatory search query arguments
+     * 2. Executes search query with pagination
+     * 3. Aggregates pagination results into a single result-set.
+     * @template T The type of objects being requested.
+     * @param {string | DocumentNode} query the search query.
+     * @param {SearchQueryVariables} args search query arguments.
+     * @returns {T[]} array of result objects.
+     * @throws {RangeError} if a valid root item ID is not provided.
+     * @throws {RangeError} if the provided language(s) is(are) not valid.
+     */
+    fetch(query: string | DocumentNode, args: SearchQueryVariables): Promise<T[]>;
+}

package/types/graphql-request-client.d.ts

@@ -0,0 +1,159 @@
+import { ClientError } from 'graphql-request';
+import { DocumentNode } from 'graphql';
+import { Debugger } from './debug';
+/**
+ * Options for configuring a GraphQL request.
+ */
+interface RequestOptions {
+    headers?: Record<string, string>;
+}
+/**
+ * An interface for GraphQL clients for Sitecore APIs
+ */
+export interface GraphQLClient {
+    /**
+     * Execute graphql request
+     * @param {string | DocumentNode} query graphql query
+     * @param {object} [variables] graphql variables
+     * @param {RequestOptions} [options] options for configuring a GraphQL request.
+     */
+    request<T>(query: string | DocumentNode, variables?: {
+        [key: string]: unknown;
+    }, options?: RequestOptions): Promise<T>;
+}
+/**
+ * This type represents errors that can occur in a GraphQL client.
+ * In cases where an error status was sent back from the server (`!response.ok`), the `response` will be populated with details. In cases where a response was never received, the `code` can be populated with the error code (e.g. Node's 'ECONNRESET', 'ETIMEDOUT', etc).
+ */
+export type GraphQLClientError = Partial<ClientError> & {
+    headers?: HeadersInit;
+    code?: string;
+};
+/**
+ * Defines the strategy for retrying GraphQL requests based on errors and attempts.
+ */
+export interface RetryStrategy {
+    /**
+     * Determines whether a request should be retried based on the given error and attempt count.
+     * @param error - The error received from the GraphQL request.
+     * @param attempt - The current attempt number.
+     * @param retries - The number of retries configured.
+     * @returns A boolean indicating whether to retry the request.
+     */
+    shouldRetry(error: GraphQLClientError, attempt: number, retries: number): boolean;
+    /**
+     * Calculates the delay (in milliseconds) before the next retry based on the given error and attempt count.
+     * @param error - The error received from the GraphQL request.
+     * @param attempt - The current attempt number.
+     * @returns The delay in milliseconds before the next retry.
+     */
+    getDelay(error: GraphQLClientError, attempt: number): number;
+}
+/**
+ * Minimum configuration options for classes that implement @see GraphQLClient
+ */
+export type GraphQLRequestClientConfig = {
+    /**
+     * The API key to use for authentication. This will be added as an 'sc_apikey' header.
+     */
+    apiKey?: string;
+    /**
+     * Override debugger for logging. Uses 'core:http' by default.
+     */
+    debugger?: Debugger;
+    /**
+     * Override fetch method. Uses 'graphql-request' library default otherwise ('cross-fetch').
+     */
+    fetch?: typeof fetch;
+    /**
+     * GraphQLClient request timeout (in milliseconds).
+     */
+    timeout?: number;
+    /**
+     * Number of retries for client. Will use the specified `retryStrategy`.
+     */
+    retries?: number;
+    /**
+     * Retry strategy for the client. Uses `DefaultRetryStrategy` by default with exponential
+     * back-off factor of 2 for codes 429, 502, 503, 504, 520, 521, 522, 523, 524.
+     */
+    retryStrategy?: RetryStrategy;
+    /**
+     * Custom headers to be sent with each request.
+     */
+    headers?: Record<string, string>;
+};
+/**
+ * A GraphQL Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+ * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+ * @param config - The configuration object that specifies how the GraphQL client should be set up.
+ * @returns An instance of a GraphQL Request Client ready to send GraphQL requests.
+ */
+export type GraphQLRequestClientFactory = (config?: Omit<GraphQLRequestClientConfig, 'apiKey'>) => GraphQLRequestClient;
+/**
+ * Configuration type for @type GraphQLRequestClientFactory
+ */
+export type GraphQLRequestClientFactoryConfig = {
+    endpoint: string;
+    apiKey?: string;
+};
+/**
+ * Represents a default retry strategy for handling retry attempts in case of specific HTTP status codes.
+ * This class implements the RetryStrategy interface and provides methods to determine whether a request
+ * should be retried and calculates the delay before the next retry attempt.
+ */
+export declare class DefaultRetryStrategy implements RetryStrategy {
+    private statusCodes;
+    private errorCodes;
+    private factor;
+    /**
+     * @param {object} options Configurable options for retry mechanism.
+     * @param {number[]} [options.statusCodes] HTTP status codes to trigger retries on. Default is [429].
+     * @param {string[]} [options.errorCodes] Node error codes to trigger retries. Default is ['ECONNRESET', 'ETIMEDOUT', 'EPROTO'].
+     * @param {number} [options.factor] Factor by which the delay increases with each retry attempt. Default is 2.
+     */
+    constructor(options?: {
+        statusCodes?: number[];
+        errorCodes?: string[];
+        factor?: number;
+    });
+    shouldRetry(error: GraphQLClientError, attempt: number, retries: number): boolean;
+    getDelay(error: GraphQLClientError, attempt: number): number;
+}
+/**
+ * A GraphQL client for Sitecore APIs that uses the 'graphql-request' library.
+ * https://github.com/prisma-labs/graphql-request
+ */
+export declare class GraphQLRequestClient implements GraphQLClient {
+    private endpoint;
+    private client;
+    private headers;
+    private debug;
+    private abortTimeout?;
+    private timeout?;
+    private retries;
+    private retryStrategy;
+    /**
+     * Provides ability to execute graphql query using given `endpoint`
+     * @param {string} endpoint The Graphql endpoint
+     * @param {GraphQLRequestClientConfig} [clientConfig] GraphQL request client configuration.
+     */
+    constructor(endpoint: string, clientConfig?: GraphQLRequestClientConfig);
+    /**
+     * Factory method for creating a GraphQLRequestClientFactory.
+     * @param {object} config - client configuration options.
+     * @param {string} config.endpoint - endpoint
+     * @param {string} [config.apiKey] - apikey
+     */
+    static createClientFactory({ endpoint, apiKey, }: GraphQLRequestClientFactoryConfig): GraphQLRequestClientFactory;
+    /**
+     * Execute graphql request
+     * @param {string | DocumentNode} query graphql query
+     * @param {object} [variables] graphql variables
+     * @param {RequestOptions} [options] Options for configuring a GraphQL request.
+     */
+    request<T>(query: string | DocumentNode, variables?: {
+        [key: string]: unknown;
+    }, options?: RequestOptions): Promise<T>;
+}
+export {};

package/types/i18n/dictionary-service.d.ts

@@ -0,0 +1,56 @@
+import { CacheClient, CacheOptions } from '../cache-client';
+/**
+ * Object model for Sitecore dictionary phrases
+ */
+export interface DictionaryPhrases {
+    [k: string]: string;
+}
+/**
+ * Service that fetches dictionary data using Sitecore's GraphQL API.
+ */
+export interface DictionaryService {
+    /**
+     * Fetch dictionary data for a language.
+     * @param {string} language the language to be used to fetch the dictionary
+     */
+    fetchDictionaryData(language: string): Promise<DictionaryPhrases>;
+}
+/**
+ * Base implementation of @see DictionaryService that handles caching dictionary values
+ */
+export declare abstract class DictionaryServiceBase implements DictionaryService, CacheClient<DictionaryPhrases> {
+    options: CacheOptions;
+    private cache;
+    /**
+     * Initializes a new instance of @see DictionaryService using the provided @see CacheOptions
+     * @param {CacheOptions} options Configuration options
+     */
+    constructor(options: CacheOptions);
+    /**
+     * Caches a @see DictionaryPhrases value for the specified cache key.
+     * @param {string} key The cache key.
+     * @param {DictionaryPhrases} value The value to cache.
+     * @returns The value added to the cache.
+     * @mixes CacheClient<DictionaryPhrases>
+     */
+    setCacheValue(key: string, value: DictionaryPhrases): DictionaryPhrases;
+    /**
+     * Retrieves a @see DictionaryPhrases value from the cache.
+     * @param {string} key The cache key.
+     * @returns The @see DictionaryPhrases value, or null if the specified key is not found in the cache.
+     */
+    getCacheValue(key: string): DictionaryPhrases | null;
+    /**
+     * Gets a cache client that can cache data. Uses memory-cache as the default
+     * library for caching (@see MemoryCacheClient). Override this method if you
+     * want to use something else.
+     * @returns {CacheClient} implementation
+     */
+    protected getCacheClient(): CacheClient<DictionaryPhrases>;
+    /**
+     * Fetch dictionary data for a language.
+     * @param {string} language the language to be used to fetch the dictionary
+     * @returns {Promise<DictionaryPhrases>}
+     */
+    abstract fetchDictionaryData(language: string): Promise<DictionaryPhrases>;
+}

package/types/i18n/graphql-dictionary-service.d.ts

@@ -0,0 +1,94 @@
+import { GraphQLClient, GraphQLRequestClientConfig, GraphQLRequestClientFactory } from '../graphql-request-client';
+import { DictionaryPhrases, DictionaryServiceBase } from './dictionary-service';
+import { CacheOptions } from '../cache-client';
+import { PageInfo, SearchQueryVariables } from '../graphql';
+/** @private */
+export declare const queryError = "Valid value for rootItemId not provided and failed to auto-resolve app root item.";
+/**
+ * Configuration options for @see GraphQLDictionaryService instances
+ */
+export interface GraphQLDictionaryServiceConfig extends Omit<SearchQueryVariables, 'language'>, CacheOptions, Pick<GraphQLRequestClientConfig, 'retries' | 'retryStrategy'> {
+    /**
+     * The name of the current Sitecore site. This is used to to determine the search query root
+     * in cases where one is not specified by the caller.
+     */
+    siteName: string;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+    /**
+     * Optional. The template ID to use when searching for dictionary entries.
+     * @default '6d1cd89719364a3aa511289a94c2a7b1' (/sitecore/templates/System/Dictionary/Dictionary entry)
+     */
+    dictionaryEntryTemplateId?: string;
+    /**
+     * Optional. The template ID of a JSS App to use when searching for the appRootId.
+     * @default '061cba1554744b918a0617903b102b82' (/sitecore/templates/Foundation/JavaScript Services/App)
+     */
+    jssAppTemplateId?: string;
+    /**
+     * Optional. Use site query for dictionary fetch instead of search query (XM Cloud only)
+     */
+    useSiteQuery?: boolean;
+}
+/**
+ * The schema of data returned in response to a dictionary query request.
+ */
+export type DictionaryQueryResult = {
+    key: {
+        value: string;
+    };
+    phrase: {
+        value: string;
+    };
+};
+export type DictionarySiteQueryResponse = {
+    site: {
+        siteInfo: {
+            dictionary: {
+                results: {
+                    key: string;
+                    value: string;
+                }[];
+                pageInfo: PageInfo;
+            };
+        };
+    };
+};
+/**
+ * Service that fetch dictionary data using Sitecore's GraphQL API.
+ * @augments DictionaryServiceBase
+ * @mixes SearchQueryService<DictionaryQueryResult>
+ */
+export declare class GraphQLDictionaryService extends DictionaryServiceBase {
+    options: GraphQLDictionaryServiceConfig;
+    private graphQLClient;
+    /**
+     * Creates an instance of graphQL dictionary service with the provided options
+     * @param {GraphQLDictionaryService} options instance
+     */
+    constructor(options: GraphQLDictionaryServiceConfig);
+    /**
+     * Fetches dictionary data for internalization. Uses search query by default
+     * @param {string} language the language to fetch
+     * @returns {Promise<DictionaryPhrases>} dictionary phrases
+     * @throws {Error} if the app root was not found for the specified site and language.
+     */
+    fetchDictionaryData(language: string): Promise<DictionaryPhrases>;
+    /**
+     * Fetches dictionary data with site query
+     * This is the default behavior for XMCloud deployments. Uses `siteQuery` to retrieve data.
+     * @param {string} language the language to fetch
+     * @returns {Promise<DictionaryPhrases>} dictionary phrases
+     */
+    fetchWithSiteQuery(language: string): Promise<DictionaryPhrases>;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}

package/types/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { DictionaryPhrases, DictionaryService, DictionaryServiceBase } from './dictionary-service';
+export { GraphQLDictionaryServiceConfig, GraphQLDictionaryService, } from './graphql-dictionary-service';

package/types/index.d.ts

@@ -0,0 +1,8 @@
+import * as constants from './constants';
+export { default as debug, Debugger, enableDebug } from './debug';
+export { RetryStrategy, DefaultRetryStrategy, GraphQLClient, GraphQLRequestClient, GraphQLRequestClientConfig, GraphQLRequestClientFactory, GraphQLRequestClientFactoryConfig, } from './graphql-request-client';
+export { CacheClient, CacheOptions, MemoryCacheClient } from './cache-client';
+export { ClientError } from 'graphql-request';
+export { NativeDataFetcher, NativeDataFetcherConfig, NativeDataFetcherError, NativeDataFetcherResponse, } from './native-fetcher';
+export { HTMLLink } from './models';
+export { constants };

package/types/layout/content-styles.d.ts

@@ -0,0 +1,18 @@
+import { ComponentRendering, Field, Item, LayoutServiceData, RouteData } from './index';
+import { HTMLLink } from '../models';
+type Config = {
+    loadStyles: boolean;
+};
+/**
+ * Get the content styles link to be loaded from the Sitecore Edge Platform
+ * @param {LayoutServiceData} layoutData Layout service data
+ * @param {string} sitecoreEdgeContextId Sitecore Edge Context ID
+ * @param {string} [sitecoreEdgeUrl] Sitecore Edge Platform URL. Default is https://edge-platform.sitecorecloud.io
+ * @returns {HTMLLink | null} content styles link, null if no styles are used in layout
+ */
+export declare const getContentStylesheetLink: (layoutData: LayoutServiceData, sitecoreEdgeContextId: string, sitecoreEdgeUrl?: string) => HTMLLink | null;
+export declare const getContentStylesheetUrl: (sitecoreEdgeContextId: string, sitecoreEdgeUrl?: string) => string;
+export declare const traversePlaceholder: (components: Array<ComponentRendering>, config: Config) => void;
+export declare const traverseField: (field: Field | Item | Item[] | undefined, config: Config) => void;
+export declare const traverseComponent: (component: RouteData | ComponentRendering, config: Config) => void;
+export {};

package/types/layout/graphql-layout-service.d.ts

@@ -0,0 +1,58 @@
+import { LayoutServiceBase } from './layout-service';
+import { LayoutServiceData } from './models';
+import { GraphQLClient, GraphQLRequestClientFactory, GraphQLRequestClientConfig } from '../graphql-request-client';
+export declare const GRAPHQL_LAYOUT_QUERY_NAME = "JssLayoutQuery";
+export interface GraphQLLayoutServiceConfig extends Pick<GraphQLRequestClientConfig, 'retries' | 'retryStrategy'> {
+    /**
+     * The JSS application name
+     */
+    siteName: string;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+    /**
+     * Override default layout query
+     * @param {string} siteName
+     * @param {string} itemPath
+     * @param {string} [locale]
+     * @returns {string} custom layout query
+     * Layout query
+     * layout(site:"${siteName}", routePath:"${itemPath}", language:"${language}")
+     */
+    formatLayoutQuery?: (siteName: string, itemPath: string, locale?: string) => string;
+}
+/**
+ * Service that fetch layout data using Sitecore's GraphQL API.
+ * @augments LayoutServiceBase
+ * @mixes GraphQLRequestClient
+ */
+export declare class GraphQLLayoutService extends LayoutServiceBase {
+    serviceConfig: GraphQLLayoutServiceConfig;
+    private graphQLClient;
+    /**
+     * Fetch layout data using the Sitecore GraphQL endpoint.
+     * @param {GraphQLLayoutServiceConfig} serviceConfig configuration
+     */
+    constructor(serviceConfig: GraphQLLayoutServiceConfig);
+    /**
+     * Fetch layout data for an item.
+     * @param {string} itemPath item path to fetch layout data for.
+     * @param {string} [language] the language to fetch layout data for.
+     * @returns {Promise<LayoutServiceData>} layout service data
+     */
+    fetchLayoutData(itemPath: string, language?: string): Promise<LayoutServiceData>;
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+    /**
+     * Returns GraphQL Layout query
+     * @param {string} itemPath page route
+     * @param {string} [language] language
+     * @returns {string} GraphQL query
+     */
+    protected getLayoutQuery(itemPath: string, language?: string): string;
+}

package/types/layout/index.d.ts

@@ -0,0 +1,6 @@
+export { LayoutServiceData, LayoutServicePageState, LayoutServiceContext, LayoutServiceContextData, RouteData, PlaceholderData, ComponentRendering, Field, GenericFieldValue, Item, PlaceholdersData, ComponentFields, ComponentParams, EditMode, FieldMetadata, RenderingType, EDITING_COMPONENT_PLACEHOLDER, EDITING_COMPONENT_ID, } from './models';
+export { getFieldValue, getChildPlaceholder, isFieldValueEmpty, isDynamicPlaceholder, getDynamicPlaceholderPattern, EMPTY_DATE_FIELD_VALUE, } from './utils';
+export { getContentStylesheetLink } from './content-styles';
+export { LayoutService } from './layout-service';
+export { GraphQLLayoutService, GraphQLLayoutServiceConfig, GRAPHQL_LAYOUT_QUERY_NAME, } from './graphql-layout-service';
+export { getComponentLibraryStylesheetLinks } from './themes';

package/types/layout/layout-service.d.ts

@@ -0,0 +1,19 @@
+import * as models from './models';
+import { IncomingMessage, ServerResponse } from 'http';
+export interface LayoutService {
+    /**
+     * Fetch layout data for an item.
+     * @param {string} itemPath
+     * @param {string} [language]
+     * @param {IncomingMessage} [req] Request instance
+     * @param {ServerResponse} [res] Response instance
+     * @returns {Promise<LayoutServiceData>} layout data
+     */
+    fetchLayoutData(itemPath: string, language?: string, req?: IncomingMessage, res?: ServerResponse): Promise<models.LayoutServiceData>;
+}
+/**
+ * Base abstraction to implement custom layout service
+ */
+export declare abstract class LayoutServiceBase implements LayoutService {
+    abstract fetchLayoutData(itemPath: string, language?: string, req?: IncomingMessage, res?: ServerResponse): Promise<models.LayoutServiceData>;
+}

package/types/layout/models.d.ts

@@ -0,0 +1,145 @@
+/**
+ * A reply from the Sitecore Layout Service
+ */
+export interface LayoutServiceData {
+    sitecore: LayoutServiceContextData & {
+        route: RouteData | null;
+    };
+}
+/**
+ * Layout Service page state enum
+ * library mode would render a single component
+ */
+export declare enum LayoutServicePageState {
+    Preview = "preview",
+    Edit = "edit",
+    Normal = "normal"
+}
+/**
+ * Represents the edit mode for rendering content in Sitecore Editors
+ */
+export declare enum EditMode {
+    Metadata = "metadata"
+}
+/**
+ * Shape of context data from the Sitecore Layout Service
+ */
+export interface LayoutServiceContext {
+    [key: string]: unknown;
+    pageEditing?: boolean;
+    language?: string;
+    itemPath?: string;
+    pageState?: LayoutServicePageState;
+    visitorIdentificationTimestamp?: number;
+    site?: {
+        name?: string;
+    };
+    renderingType?: RenderingType;
+    clientScripts?: string[];
+    clientData?: Record<string, Record<string, unknown>>;
+}
+/**
+ * Context information from the Sitecore Layout Service
+ */
+export interface LayoutServiceContextData {
+    context: LayoutServiceContext;
+}
+/**
+ * Shape of route data returned from Sitecore Layout Service
+ */
+export interface RouteData<Fields = Record<string, Field | Item | Item[]>> {
+    name: string;
+    displayName?: string;
+    fields?: Fields;
+    databaseName?: string;
+    deviceId?: string;
+    itemLanguage?: string;
+    itemVersion?: number;
+    layoutId?: string;
+    templateId?: string;
+    templateName?: string;
+    placeholders: PlaceholdersData;
+    itemId?: string;
+}
+/**
+ * Placeholder contents data (name: placeholder name, then array of components within that placeholder name)
+ */
+export type PlaceholdersData<TYPEDNAME extends string = string> = {
+    [P in TYPEDNAME]: Array<ComponentRendering>;
+};
+/**
+ * Content field data passed to a component
+ */
+export interface ComponentFields {
+    [name: string]: Field | Item | Item[];
+}
+/**
+ * Component params
+ */
+export interface ComponentParams {
+    [name: string]: string;
+}
+/**
+ * Definition of a component instance within a placeholder on a route
+ */
+export interface ComponentRendering<T = ComponentFields> {
+    componentName: string;
+    dataSource?: string;
+    uid?: string;
+    placeholders?: PlaceholdersData;
+    fields?: T;
+    params?: ComponentParams;
+}
+/**
+ * Field value data on a component
+ */
+export type GenericFieldValue = string | boolean | number | Date | {
+    [key: string]: unknown;
+} | Array<{
+    [key: string]: unknown;
+}>;
+export interface Field<T = GenericFieldValue> extends FieldMetadata {
+    value: T;
+}
+/**
+ * Field metadata in editing mode
+ */
+export interface FieldMetadata {
+    metadata?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Content data returned from Layout Service
+ */
+export interface Item {
+    name: string;
+    displayName?: string;
+    id?: string;
+    url?: string;
+    fields: {
+        [name: string]: Field | Item | Item[] | undefined;
+    };
+}
+/**
+ * Contents of a single placeholder returned from placeholder service
+ */
+export interface PlaceholderData {
+    name: string;
+    path: string;
+    elements: ComponentRendering[];
+}
+/**
+ * Editing rendering type
+ */
+export declare enum RenderingType {
+    Component = "component"
+}
+/**
+ * Static placeholder name used for component rendering
+ */
+export declare const EDITING_COMPONENT_PLACEHOLDER = "editing-componentmode-placeholder";
+/**
+ * Id of wrapper for component rendering
+ */
+export declare const EDITING_COMPONENT_ID = "editing-component";

package/types/layout/themes.d.ts

@@ -0,0 +1,11 @@
+import { LayoutServiceData } from '.';
+import { HTMLLink } from '../models';
+/**
+ * Walks through rendering tree and returns list of links of all FEAAS, BYOC or SXA Component Library Stylesheets that are used
+ * @param {LayoutServiceData} layoutData Layout service data
+ * @param {string} sitecoreEdgeContextId Sitecore Edge Context ID
+ * @param {string} [sitecoreEdgeUrl] Sitecore Edge Platform URL. Default is https://edge-platform.sitecorecloud.io
+ * @returns {HTMLLink[]} library stylesheet links
+ */
+export declare function getComponentLibraryStylesheetLinks(layoutData: LayoutServiceData, sitecoreEdgeContextId: string, sitecoreEdgeUrl?: string): HTMLLink[];
+export declare const getStylesheetUrl: (id: string, sitecoreEdgeContextId: string, sitecoreEdgeUrl?: string) => string;