@sitecore-content-sdk/core 0.2.0-beta.2 → 0.2.0-beta.21

package/types/client/sitecore-client.d.ts

@@ -6,6 +6,7 @@ import { HTMLLink, FetchOptions, StaticPath, RetryStrategy } from '../models';
 import { PersonalizedRewriteData } from '../personalize/utils';
 import { ErrorPages, SiteInfo, SiteResolver, GraphQLErrorPagesService, GraphQLSitePathService, GraphQLSitemapXmlService } from '../site';
 import { SitecoreClientInit } from './models';
+import { GraphQLRobotsService } from '../site/graphql-robots-service';
 /**
  * Represent a Page model returned from Edge endpoint
  */
@@ -39,6 +40,15 @@ export type SitemapXmlOptions = {
     /** The site name to resolve the sitemap for */
     siteName?: string;
 };
+/**
+ * Options for fetching robots.txt content.
+ */
+export type RobotsOptions = {
+    /**
+     * The name of the site for which to fetch robots.txt content.
+     */
+    siteName: string;
+};
 /**
  * Contract for the Sitecore Client implementations
  */
@@ -53,33 +63,34 @@ export interface BaseSitecoreClient {
      * Retrieves page layoutData and returns page details like language, layoutData and site info for current request
      * @param {string} path current request path
      * @param {PageOptions} pageOptions additional overrides like language, site name and personalization variants
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      * @returns {Page | null} page details when page layout is found and null when not
      */
     getPage(path: string | string[], pageOptions?: PageOptions, fetchOptions?: FetchOptions): Promise<Page | null>;
     /**
-     * Get dictionary data for a given site and locale.
-     * Can retrieve dictionary phrases for default site and language when page options not provided
-     * @param {RouteOptions} [routeOptions] language and site to load dictionary data for
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * Retrieves the robots.txt content for a given site name.
+     * @param {string} siteName - The name of the site for which to fetch robots.txt content.
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
+     * @returns {Promise<string>} A promise that resolves to the robots.txt content.
      */
+    getRobots(siteName: string, fetchOptions?: FetchOptions): Promise<string | null>;
     getDictionary(routeOptions?: Partial<RouteOptions>, fetchOptions?: FetchOptions): Promise<DictionaryPhrases>;
     /**
      * Get error pages configured by SXA for a given site and locale
      * @param {RouteOptions} [routeOptions] language and site to load error pages for
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      */
     getErrorPages(routeOptions?: RouteOptions, fetchOptions?: FetchOptions): Promise<ErrorPages | null>;
     /**
      * Get preview layout details based on details from EditingPreviewData input
      * @param {EditingPreviewData | undefined} previewData preview details like route, site, language etc used to retrieve preview page and layout
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      */
     getPreview(previewData: EditingPreviewData | undefined, fetchOptions?: FetchOptions): Promise<Page | null>;
     /**
      * Get route paths for all pages in the site. Can be used for static site generation.
      * @param {string[]} [languages] languages to fetch routes in
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      */
     getPagePaths(languages?: string[], fetchOptions?: FetchOptions): Promise<StaticPath[]>;
     /**
@@ -97,9 +108,17 @@ export interface BaseSitecoreClient {
     /**
      * Retrieves sitemap XML content - either a specific sitemap or the index of all sitemaps.
      * @param { SitemapRequestConfig} reqOptions - Configuration for sitemap retrieval
+     * @param {FetchOptions} [fetchOptions] - Additional fetchOptions Additional fetch options to override GraphQL requests
      * @returns {Promise<string>} Promise resolving to the sitemap XML content as string
      */
-    getSiteMap(reqOptions: SitemapXmlOptions): Promise<string>;
+    getSiteMap(reqOptions: SitemapXmlOptions, fetchOptions?: FetchOptions): Promise<string>;
+    /**
+     * Retrieves the robots.txt content for a given site name.
+     * @param {string} siteName - The name of the site for which to fetch robots.txt content.
+     * @param {FetchOptions} fetchOptions Additional fetch options to override GraphQL requests
+     * @returns {Promise<string>} A promise that resolves to the robots.txt content.
+     */
+    getRobots(siteName: string, fetchOptions?: FetchOptions): Promise<string | null>;
 }
 export interface BaseServiceOptions {
     defaultSite: string;
@@ -144,7 +163,7 @@ export declare class SitecoreClient implements BaseSitecoreClient {
      * Get page details for a route, with layout and other details
      * @param {string} path route path
      * @param {PageOptions} [pageOptions] site, language and personalization variant details for route
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      * @returns {Page | null} page details
      */
     getPage(path: string | string[], pageOptions?: PageOptions, fetchOptions?: FetchOptions): Promise<Page | null>;
@@ -163,28 +182,28 @@ export declare class SitecoreClient implements BaseSitecoreClient {
     /**
      * Retrieves dictionary phrases for a given site and locale.
      * @param {RouteOptions} routeOptions - Route options containing language and site name to load dictionary for
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      * @returns {DictionaryPhrases} A promise that resolves to the dictionary phrases.
      */
     getDictionary(routeOptions?: Partial<RouteOptions>, fetchOptions?: FetchOptions): Promise<DictionaryPhrases>;
     /**
      * Retrieves error pages for a given site and locale.
      * @param {RouteOptions} routeOptions - Route options containing language and site name to load error pages
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      * @returns {ErrorPages | null} A promise that resolves to the error pages or null if not found.
      */
     getErrorPages(routeOptions?: RouteOptions, fetchOptions?: FetchOptions): Promise<ErrorPages | null>;
     /**
      * Retrieves preview page and layout details
      * @param {EditingPreviewData | undefined} previewData - The editing preview data for metadata mode.
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      * @returns {Page} preview page details
      */
     getPreview(previewData: EditingPreviewData | undefined, fetchOptions?: FetchOptions): Promise<Page | null>;
     /**
      * Get design library page details for Design Library mode of your app
      * @param {DesignLibraryRenderPreviewData} designLibData preview data set in 'library' mode of the app
-     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests (like retries and fetch)
+     * @param {FetchOptions} [fetchOptions] Additional fetch fetch options to override GraphQL requests
      * @returns {Page} preview page for Design Library
      */
     getDesignLibraryData(designLibData: DesignLibraryRenderPreviewData, fetchOptions?: FetchOptions): Promise<Page>;
@@ -203,18 +222,27 @@ export declare class SitecoreClient implements BaseSitecoreClient {
      * @throws {Error} Throws 'REDIRECT_404' if requested sitemap is not found
      */
     getSiteMap(reqOptions: SitemapXmlOptions, fetchOptions?: FetchOptions): Promise<string>;
+    /**
+     * Retrieves the robots.txt content for a given site name.
+     * @param {string} siteName - The name of the site to retrieve the robots.txt for.
+     * @param {FetchOptions} [fetchOptions] - Optional fetch options.
+     * @returns {Promise<string | null>} A promise that resolves to the robots.txt content,
+     * or null if no content is found.
+     */
+    getRobots(siteName: string, fetchOptions?: FetchOptions): Promise<string | null>;
     /**
      * Factory methods for creating dependencies
      * Subclasses can override these to provide custom implementations.
      */
     protected getGraphqlSitemapXMLService(siteName: string): GraphQLSitemapXmlService;
+    protected getRobotsService(siteName: string): GraphQLRobotsService;
     protected getBaseServiceOptions(): BaseServiceOptions;
-    protected getClientFactory(): GraphQLRequestClientFactory;
-    protected getSiteResolver(): SiteResolver;
-    protected getLayoutService(baseOptions: BaseServiceOptions): GraphQLLayoutService;
-    protected getDictionaryService(baseOptions: BaseServiceOptions): GraphQLDictionaryService;
-    protected getEditingService(): GraphQLEditingService;
-    protected getErrorPagesService(): GraphQLErrorPagesService;
-    protected getComponentService(): RestComponentLayoutService;
-    protected getSitePathService(): GraphQLSitePathService;
+    private getClientFactory;
+    private getSiteResolver;
+    private getLayoutService;
+    private getDictionaryService;
+    private getEditingService;
+    private getErrorPagesService;
+    private getComponentService;
+    private getSitePathService;
 }

package/types/config/index.d.ts

@@ -1,3 +1,3 @@
-export { SitecoreConfig, SitecoreConfigInput, SitecoreCliConfig, SitecoreCliConfigInput, ScaffoldTemplate, ComponentTemplateType, } from './models';
+export { SitecoreConfig, SitecoreConfigInput, SitecoreCliConfig, SitecoreCliConfigInput, ScaffoldTemplate, ComponentTemplateType, DeepRequired, } from './models';
 export { defineConfig } from './define-config';
 export { defineCliConfig } from './define-cli-config';

package/types/config/models.d.ts

@@ -13,7 +13,7 @@ export type SitecoreConfigInput = {
      * API settings required to connect to Sitecore.
      * Both edge and local set can be specified as JSS app will use API Key for component library
      */
-    api: {
+    api?: {
         /**
          * Edge endpoint credentials for Sitecore connection. Will be used to connect to SaaS XMCloud instance
          */
@@ -55,7 +55,7 @@ export type SitecoreConfigInput = {
      * The default and fallback locale for your site.
      * Ensure it aligns with the framework-specific settings used in your application.
      */
-    defaultLanguage: string;
+    defaultLanguage?: string;
     /**
      * Your default site name. When using the multisite feature this variable defines the fallback site.
      * @default empty string
@@ -63,6 +63,7 @@ export type SitecoreConfigInput = {
     defaultSite?: string;
     /**
      * Editing secret required to support Sitecore editing and preview functionality.
+     * by default set by the JSS_EDITING_SECRET environment variable
      */
     editingSecret?: string;
     /**
@@ -132,10 +133,14 @@ export type SitecoreConfigInput = {
         enabled?: boolean;
         /**
          * Configuration for your Sitecore Experience Edge endpoint
+         * by default set by the PERSONALIZE_MIDDLEWARE_EDGE_TIMEOUT environment variable
+         * if not set, will use the default value of 400ms
          */
         edgeTimeout?: number;
         /**
          * Configuration for your Sitecore CDP endpoint
+         * by default set by the PERSONALIZE_MIDDLEWARE_CDP_TIMEOUT environment variable
+         * if not set, will use the default value of 400ms
          */
         cdpTimeout?: number;
         /**
@@ -166,6 +171,11 @@ export type SitecoreConfigInput = {
          */
         locales?: string[];
     };
+    /**
+     * Opt-out setting for code generation feature
+     * Disables code extraction procedure
+     */
+    disableCodeGeneration?: boolean;
 };
 /**
  * Final sitecore config type used at runtime

package/types/constants.d.ts

@@ -5,3 +5,13 @@ export declare enum SitecoreTemplateId {
 export declare const siteNameError = "The siteName cannot be empty";
 export declare const SITECORE_EDGE_URL_DEFAULT = "https://edge-platform.sitecorecloud.io";
 export declare const HIDDEN_RENDERING_NAME = "Hidden Rendering";
+export declare const DEFAULT_SITECORE_AUTH_DOMAIN = "https://auth.sitecorecloud.io";
+export declare const DEFAULT_SITECORE_AUTH_AUDIENCE = "https://api.sitecorecloud.io";
+export declare const DEFAULT_SITECORE_AUTH_BASE_URL = "https://edge-platform.sitecorecloud.io/cs/api";
+export declare const CLAIMS = "https://auth.sitecorecloud.io/claims";
+export declare const CLIENT_GRANT_TYPE = "client_credentials";
+export declare const DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+export declare const REFRESH_GRANT_TYPE = "refresh_token";
+export declare const SCOPE = "openid profile email offline_access";
+export declare const TIMEOUT = 600;
+export declare const DEFAULT_INTERVAL = 10;

package/types/content/content-client.d.ts

@@ -0,0 +1,92 @@
+import { DocumentNode } from 'graphql';
+import { GraphQLRequestClient } from '../graphql-request-client';
+import { FetchOptions } from '../models';
+import { Taxonomy } from './taxonomies';
+/**
+ * Interface representing the options for the ContentClient.
+ */
+export interface ContentClientOptions {
+    /** The base URL for the Content API. */
+    url?: string;
+    /** The tenant name. */
+    tenant: string;
+    /** The environment name. */
+    environment: string;
+    /** Indicates if preview mode is enabled. */
+    preview?: boolean;
+    /** The authentication token. */
+    token: string;
+}
+/**
+ * Class representing a client for interacting with the Content API.
+ */
+export declare class ContentClient {
+    endpoint: string;
+    graphqlClient: GraphQLRequestClient;
+    constructor({ url, tenant, environment, preview, token }: ContentClientOptions);
+    /**
+     * Factory method for creating a ContentClient instance. This method allows you to create a client with the values populated from environment variables or provided as arguments.
+     * @param {Partial<ContentClientOptions>} [options] - client configuration options
+     * @param {string} [options.url] - Content base graphql endpoint url. If not provided, it will be read from the SITECORE_CS_URL environment variable. Otherwise, it defaults to https://cs-graphqlapi-staging.sitecore-staging.cloud.
+     * @param {string} [options.tenant] - Tenant name. If not provided, it will be read from the SITECORE_CS_TENANT environment variable
+     * @param {string} [options.environment] - Environment name. If not provided, it will be read from the SITECORE_CS_ENVIRONMENT environment variable. Otherwise, it defaults to 'main'
+     * @param {boolean} [options.preview] - Indicates if preview mode is enabled. If not provided, it will be read from the SITECORE_CS_PREVIEW environment variable. Otherwise, it defaults to false
+     * @param {string} [options.token] - Token for authentication. If not provided, it will be read from the SITECORE_CS_TOKEN environment variable.
+     * @returns {ContentClient} ContentClient instance
+     * @throws {Error} If tenant or token is not provided
+     */
+    static createClient({ url, tenant, environment, preview, token, }?: Partial<ContentClientOptions>): ContentClient;
+    /**
+     * Execute graphql request
+     * @param {string | DocumentNode} query graphql query
+     * @param {object} variables variables for the query
+     * @param {FetchOptions} options options for configuring the request
+     * @returns {T} response data
+     */
+    get<T>(query: string | DocumentNode, variables?: Record<string, unknown>, options?: FetchOptions): Promise<T>;
+    /**
+     * Retrieves the locale information for a given locale ID.
+     * @param {string} id - The unique identifier of the locale item.
+     * @returns A promise that resolves to the locale information associated with the specified locale ID.
+     */
+    getLocale(id: string): Promise<import("./locales").Locale | null>;
+    /**
+     * Retrieves all available locales from the content service.
+     * @returns A promise that resolves to an array of locales.
+     */
+    getLocales(): Promise<import("./locales").Locale[]>;
+    /**
+     * Retrieves all available taxonomies with optional pagination support.
+     * @param {object} [options] - Optional pagination options.
+     * @param {number} [options.pageSize] - Limits the number of taxonomies returned per page. Defaults to the API's default
+     * @param {string} [options.after] - Cursor for pagination; use the `cursor` returned from the previous call to fetch the next page.
+     * @returns A promise that resolves to an object containing taxonomies, their terms, and pagination info.
+     */
+    getTaxonomies(options?: {
+        pageSize?: number;
+        after?: string;
+    }): Promise<{
+        results: {
+            system: import("./taxonomies").TaxonomySystem;
+            terms: import("./taxonomies").Term[];
+        }[];
+        cursor: string | undefined;
+        hasMore: boolean;
+    }>;
+    /**
+     * Retrieves a taxonomy by its ID, with optional pagination support for its terms.
+     * @param {object} options - Options for fetching the taxonomy.
+     * @param {string} options.id - The unique identifier of the taxonomy.
+     * @param {object} [options.terms] - Optional pagination options for terms.
+     * @param {number} [options.terms.pageSize] - Optional. Limits the number of terms returned per page.
+     * @param {string} [options.terms.after] - Optional. Cursor for pagination. Used to fetch the next page of terms.
+     * @returns A promise that resolves to the taxonomy object, including pagination metadata (`hasMore`, `cursor`) for its terms. Returns `null` if the taxonomy is not found.
+     */
+    getTaxonomy({ id, terms, }: {
+        id: string;
+        terms?: {
+            pageSize?: number;
+            after?: string;
+        };
+    }): Promise<Taxonomy | null>;
+}

package/types/content/index.d.ts

@@ -0,0 +1,4 @@
+export { ContentClient, ContentClientOptions } from './content-client';
+export { GET_LOCALE_QUERY, GET_LOCALES_QUERY, LocaleQueryResponse, LocalesQueryResponse, Locale, } from './locales';
+export { GET_TAXONOMY_QUERY, GET_TAXONOMIES_QUERY, TaxonomyQueryResponse, TaxonomiesQueryResponse, Taxonomy, TaxonomySystem, Term, } from './taxonomies';
+export { getContentUrl } from './utils';

package/types/content/locales.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Represents the locale entity.
+ */
+export type Locale = {
+    /** The unique identifier of the locale. */
+    id: string;
+    /** The label of the locale. */
+    label: string;
+};
+/**
+ * A locale item included in a locale query response.
+ */
+export type LocaleItem = {
+    system: Locale;
+};
+/**
+ * Represents the response structure for a query that retrieves a single locale.
+ */
+export interface LocaleQueryResponse {
+    locale: LocaleItem | null;
+}
+/**
+ * Represents the response structure for a query that retrieves multiple locales.
+ */
+export interface LocalesQueryResponse {
+    manyLocale: LocaleItem[];
+}
+/**
+ * GraphQL query to retrieve a specific locale by its ID.
+ *
+ * Variables:
+ * - id: The ID of the locale to retrieve.
+ */
+export declare const GET_LOCALE_QUERY = "\n  query GetLocaleById($id: ID!) {\n    locale(id: $id) {\n      system {\n        id\n        label\n      }\n    }\n  }\n";
+/**
+ * GraphQL query to retrieve all available locales.
+ */
+export declare const GET_LOCALES_QUERY = "\n  query GetAllLocales {\n    manyLocale {\n      system {\n        id\n        label\n      }\n    }\n  }\n";

package/types/content/taxonomies.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Represents a term within a taxonomy.
+ */
+export type Term = {
+    /** The unique identifier of the term. */
+    id: string;
+    /** The internal name of the term. */
+    name: string;
+    /** The display label of the term. */
+    label: string;
+};
+/**
+ * Represents a list of terms within a taxonomy.
+ * In getTaxonomies, terms are always returned as a full list (no pagination).
+ * In getTaxonomy, terms may be paginated.
+ */
+export interface TermList {
+    /** The list of terms in the current (or full) page. */
+    results: Term[];
+    /** The cursor to fetch the next page of terms, if available. (Used only in getTaxonomy) */
+    cursor?: string | null;
+    /** Indicates whether more terms are available after the current page. (Used only in getTaxonomy) */
+    hasMore: boolean;
+}
+/**
+ * Represents the system metadata of a taxonomy.
+ */
+export type TaxonomySystem = {
+    /** The unique identifier of the taxonomy. */
+    id: string;
+    /** The internal name of the taxonomy. */
+    name: string;
+    /** The version of the taxonomy. */
+    version: number;
+    /** The display label of the taxonomy. */
+    label: string;
+    /** The timestamp when the taxonomy was created (ISO 8601 format). */
+    createdAt: string;
+    /** The user ID who created the taxonomy. */
+    createdBy: string;
+    /** The timestamp when the taxonomy was last updated (ISO 8601 format). */
+    updatedAt: string;
+    /** The user ID who last updated the taxonomy. */
+    updatedBy: string;
+    /** The publish status of the taxonomy (e.g., PREVIEW, PUBLISHED). */
+    publishStatus: string;
+};
+/**
+ * Represents a taxonomy with its associated terms.
+ * Terms are paginated only in single-taxonomy queries (getTaxonomy).
+ */
+export type Taxonomy = {
+    /** The list of terms within the taxonomy. */
+    terms: TermList;
+    /** The system metadata of the taxonomy. */
+    system: TaxonomySystem;
+};
+/**
+ * Represents the response structure for a query that retrieves a specific taxonomy by ID.
+ */
+export interface TaxonomyQueryResponse {
+    /** The retrieved taxonomy. */
+    taxonomy: {
+        /** The system metadata of the taxonomy. */
+        system: TaxonomySystem;
+        /** The terms for the taxonomy (may be paginated). */
+        terms: {
+            results: Term[];
+            cursor?: string | null;
+            hasMore: boolean;
+        };
+    };
+}
+/**
+ * Represents the response structure for a query that retrieves multiple taxonomies.
+ */
+export interface TaxonomiesQueryResponse {
+    /** The list of retrieved taxonomies, with pagination metadata. */
+    manyTaxonomy: {
+        /** The list of taxonomies in the current page. */
+        results: {
+            /** The terms associated with the taxonomy (always the full list, not paginated). */
+            terms: {
+                results: Term[];
+                cursor?: string | null;
+                hasMore: boolean;
+            };
+            /** The system metadata of the taxonomy. */
+            system: TaxonomySystem;
+        }[];
+        /** The cursor for fetching the next page of taxonomies, if available. */
+        cursor?: string;
+        /** Indicates whether more taxonomies are available after the current page. */
+        hasMore: boolean;
+    };
+}
+/**
+ * Represents a paginated list of content items (generic for various types, e.g., Taxonomy).
+ * Note: This type does not include any stateful fetchNext/fetchMore helpers. Pagination is stateless.
+ */
+export interface ContentItemList<T> {
+    /** The list of content items in the current page. */
+    results: T[];
+    /** The cursor for fetching the next page of items, if available. */
+    cursor?: string;
+    /** Indicates whether more items are available after the current page. */
+    hasMore: boolean;
+}
+/**
+ * GraphQL query to retrieve all taxonomies with optional pagination for taxonomies only.
+ *
+ * Variables:
+ * - pageSize: The number of taxonomies to retrieve per page.
+ * - after: The cursor for fetching the next page of taxonomies.
+ */
+export declare const GET_TAXONOMIES_QUERY = "\n  query GetAllTaxonomies(\n    $pageSize: Int\n    $after: String\n  ) {\n    manyTaxonomy(minimumPageSize: $pageSize, after: $after) {\n      cursor\n      hasMore\n      results {\n        terms {\n          cursor\n          hasMore\n          results {\n            id\n            name\n            label\n          }\n        }\n        system {\n          id\n          name\n          version\n          label\n          createdAt\n          createdBy\n          updatedAt\n          updatedBy\n          publishStatus\n        }\n      }\n    }\n  }\n";
+/**
+ * GraphQL query to retrieve a specific taxonomy by its ID, with optional pagination for its terms.
+ *
+ * Variables:
+ * - id: The unique ID of the taxonomy to retrieve.
+ * - termsPageSize: The number of terms to retrieve per page.
+ * - termsAfter: The cursor for fetching the next page of terms.
+ */
+export declare const GET_TAXONOMY_QUERY = "\n  query GetTaxonomyById($id: ID!, $termsPageSize: Int, $termsAfter: String) {\n    taxonomy(id: $id) {\n      terms(minimumPageSize: $termsPageSize, after: $termsAfter) {\n        cursor\n        hasMore\n        results {\n          id\n          name\n          label\n        }\n      }\n      system {\n        id\n        name\n        version\n        label\n        createdAt\n        createdBy\n        updatedAt\n        updatedBy\n        publishStatus\n      }\n    }\n  }\n";

package/types/content/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Get the Content graphql endpoint url
+ * @param {object} params Parameters
+ * @param {string} [params.url] Content base graphql endpoint url
+ * @param {string} params.tenant Tenant name
+ * @param {string} params.environment Environment name
+ * @param {boolean} params.preview Indicates if preview mode is enabled
+ * @returns {string} Content graphql endpoint url
+ */
+export declare function getContentUrl({ url, tenant, environment, preview, }: {
+    url?: string;
+    tenant: string;
+    environment: string;
+    preview: boolean;
+}): string;

package/types/debug.d.ts

@@ -11,6 +11,7 @@ export declare const enableDebug: (namespaces: string) => void;
  */
 declare const _default: {
     common: debug.Debugger;
+    content: debug.Debugger;
     form: debug.Debugger;
     http: debug.Debugger;
     layout: debug.Debugger;

package/types/editing/rest-component-layout-service.d.ts

@@ -1,41 +1,4 @@
-import { LayoutServiceData, EditMode } from '../layout/models';
-import { IncomingMessage, ServerResponse } from 'http';
-import { HttpDataFetcher } from '../data-fetcher';
-/**
- * Data fetcher resolver in order to provide custom data fetcher
- * @param {IncomingMessage} [req] Request instance
- * @param {ServerResponse} [res] Response instance
- */
-export type DataFetcherResolver = <T>(req?: IncomingMessage, res?: ServerResponse) => HttpDataFetcher<T>;
-export type RestLayoutServiceConfig = {
-    /**
-     * Your Sitecore instance hostname that is the backend for JSS
-     */
-    apiHost: string;
-    /**
-     * The Sitecore SSC API key your app uses
-     */
-    apiKey: string;
-    /**
-     * The JSS application name
-     */
-    siteName: string;
-    /**
-     * Enables/disables analytics tracking for the Layout Service invocation (default is true).
-     * More than likely, this would be set to false for SSG/hybrid implementations, and the
-     * JSS tracker would instead be used on the client-side
-     * @default true
-     */
-    tracking?: boolean;
-    /**
-     * Function that handles fetching API data
-     */
-    dataFetcherResolver?: DataFetcherResolver;
-    /**
-     * Layout Service "named" configuration
-     */
-    configurationName?: string;
-};
+import { LayoutServiceData } from '../layout/models';
 /**
  * Params for requesting component data from service in Design Library mode
  */
@@ -66,35 +29,37 @@ export interface ComponentLayoutRequestParams {
      */
     version?: string;
     /**
-     * edit mode to be rendered component in. Component is rendered in normal mode by default
+     * site name to be used as context for rendering the component
      */
-    editMode?: EditMode;
+    siteName: string;
+}
+/**
+ * Config for the RestComponentLayoutService
+ */
+export interface RestComponentLayoutServiceConfig {
     /**
-     * site name to be used as context for rendering the component
+     * A unified identifier used to connect and retrieve data from XM Cloud instance
      */
-    siteName?: string;
+    contextId: string;
+    /**
+     * XM Cloud endpoint that the app will communicate and retrieve data from
+     * @default https://edge-platform.sitecorecloud.io
+     */
+    edgeUrl?: string;
 }
 /**
- * REST service that enables Design Library functioality
- * Makes a request to /sitecore/api/layout/component in 'library' mode in Pages.
+ * REST service that enables design Library functionality
  * Returns layoutData for one single rendered component
  */
 export declare class RestComponentLayoutService {
     private config;
-    constructor(config: RestLayoutServiceConfig);
-    fetchComponentData(params: ComponentLayoutRequestParams, req?: IncomingMessage, res?: ServerResponse): Promise<LayoutServiceData>;
-    protected getFetcher: (req?: IncomingMessage, res?: ServerResponse) => HttpDataFetcher<LayoutServiceData> | ((url: string, data?: RequestInit) => Promise<import("..").NativeDataFetcherResponse<LayoutServiceData>>);
-    /**
-     * Resolves layout service url
-     * @param {string} apiType which layout service API to call ('render' or 'placeholder')
-     * @returns the layout service url
-     */
-    protected resolveLayoutServiceUrl(apiType: string): string;
+    constructor(config: RestComponentLayoutServiceConfig);
+    fetchComponentData(params: ComponentLayoutRequestParams): Promise<LayoutServiceData>;
+    protected getComponentFetchParams(params: ComponentLayoutRequestParams): any;
     /**
-     * Provides default @see NativeDataFetcher data fetcher
-     * @param {IncomingMessage} [req] Request instance
-     * @returns default fetcher
+     * Get the fetch URL for the partial layout data endpoint
+     * @param {ComponentLayoutRequestParams} params - The parameters for the request
+     * @returns {string} The fetch URL for the component data
      */
-    protected getDefaultFetcher: <T>(req?: IncomingMessage) => (url: string, data?: RequestInit) => Promise<import("..").NativeDataFetcherResponse<T>>;
-    protected getComponentFetchParams(params: ComponentLayoutRequestParams): any;
+    private getFetchUrl;
 }

package/types/index.d.ts

@@ -1,4 +1,5 @@
 import * as constants from './constants';
+import * as form from './form';
 export { default as debug, Debugger, enableDebug } from './debug';
 export { GraphQLClient, GraphQLRequestClient, GraphQLRequestClientConfig, GraphQLRequestClientFactory, GraphQLRequestClientFactoryConfig, } from './graphql-request-client';
 export { DefaultRetryStrategy } from './retries';
@@ -7,4 +8,5 @@ export { ClientError } from 'graphql-request';
 export { NativeDataFetcher, NativeDataFetcherConfig, NativeDataFetcherError, NativeDataFetcherResponse, } from './native-fetcher';
 export { HTMLLink, RetryStrategy, GenericGraphQLClientError, StaticPath } from './models';
 export { constants };
+export { form };
 export { defineConfig } from './config';

package/types/native-fetcher.d.ts

@@ -33,13 +33,6 @@ export interface NativeDataFetcherResponse<T> {
 export type NativeDataFetcherError = Error & {
     response: NativeDataFetcherResponse<unknown>;
 };
-/**
- * A function that fetches data from a given URL and returns a `NativeDataFetcherResponse`.
- * @param {string} url The URL to request (can include query string parameters).
- * @param {unknown} [data] Optional data to send with the request (e.g., for POST or PUT requests).
- * @returns {Promise<NativeDataFetcherResponse<T>>} A promise that resolves to a `NativeDataFetcherResponse<T>`,
- */
-export type NativeDataFetcherFunction<T> = (url: string, data?: RequestInit) => Promise<NativeDataFetcherResponse<T>>;
 export type NativeDataFetcherConfig = NativeDataFetcherOptions & RequestInit;
 export declare class NativeDataFetcher {
     protected config: NativeDataFetcherConfig;