@sisense/sdk-ui 0.11.3

package/dist/query/date-formats/angular-text-date-format-replacers.d.ts

@@ -0,0 +1,5 @@
+import type { DateFormat } from './apply-date-format';
+declare const angularTextDates: readonly ["shortDate", "shortTime", "short", "mediumDate", "mediumTime", "medium", "longDate", "fullDate"];
+export type AngularTextDate = (typeof angularTextDates)[number];
+export declare function newDateFormatWithExpandedAngularTextFormats(oldFormat: DateFormat, locale: Locale): DateFormat;
+export {};

package/dist/query/date-formats/apply-date-format.d.ts

@@ -0,0 +1,65 @@
+import type { Locale } from 'date-fns';
+export type DateFormat = string;
+declare const dateLevels: readonly ["years", "quarters", "months", "weeks", "days", "dateAndTime", "minutes"];
+/** @expandType */
+export type DateLevel = (typeof dateLevels)[number];
+export declare const YEARS: DateLevel;
+export declare const QUARTERS: DateLevel;
+export declare const MONTHS: DateLevel;
+export declare const WEEKS: DateLevel;
+export declare const DAYS: DateLevel;
+export declare const DATE_AND_TIME: DateLevel;
+export declare const MINUTES: DateLevel;
+export type MonthOfYear = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+export declare const JAN: MonthOfYear;
+export declare const FEB: MonthOfYear;
+export declare const MAR: MonthOfYear;
+export declare const APR: MonthOfYear;
+export declare const MAY: MonthOfYear;
+export declare const JUN: MonthOfYear;
+export declare const JUL: MonthOfYear;
+export declare const AUG: MonthOfYear;
+export declare const SEP: MonthOfYear;
+export declare const OCT: MonthOfYear;
+export declare const NOV: MonthOfYear;
+export declare const DEC: MonthOfYear;
+export type DayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export declare const SUN: DayOfWeek;
+export declare const MON: DayOfWeek;
+export declare const TUE: DayOfWeek;
+export declare const WED: DayOfWeek;
+export declare const THU: DayOfWeek;
+export declare const FRI: DayOfWeek;
+export declare const SAT: DayOfWeek;
+/**
+ * Date configurations
+ */
+export type DateConfig = {
+    /** Boolean flag whether fiscal year is enabled */
+    isFiscalOn: boolean;
+    /** First month of the fiscal year that is configured */
+    fiscalMonth: MonthOfYear;
+    /**
+     * First day of the week
+     */
+    weekFirstDay: DayOfWeek;
+    /**
+     * The selected date level for this particular column of data
+     */
+    selectedDateLevel: DateLevel;
+    /**
+     * The IANA time zone
+     */
+    timeZone: string;
+};
+export declare const defaultDateConfig: DateConfig;
+/**
+ * Returns a formatted date, according to the provided date format string.
+ *
+ * @param date -
+ * @param format -
+ * @param locale -
+ * @param cfg -
+ */
+export declare function applyDateFormat(date: Date, format: DateFormat, locale?: Locale, cfg?: DateConfig): string;
+export {};

package/dist/query/date-formats/fiscal-date-format-replacers.d.ts

@@ -0,0 +1,33 @@
+import type { DateFormat, DateLevel, MonthOfYear } from './apply-date-format';
+export declare function subtractYearForFiscal(date: Date, selectedDateLevel: DateLevel, fiscalMonth: MonthOfYear): Date;
+export declare function shiftMonthForFiscal(date: Date, fiscalMonth: MonthOfYear): Date;
+/**
+ * Substitutes any y, yy, yyyy, yyyp, yp masks with their numeric text and
+ * returns a new date format string.
+ *
+ * Takes into consideration:
+ * - the configured start month of the customer's fiscal year
+ * - the currently selected date level for this particular column of data
+ *
+ * @param oldFormat
+ * @param date
+ * @param timeZone
+ * @param selectedDateLevel
+ * @param isFiscalOn
+ * @param fiscalMonth
+ */
+export declare function newDateFormatWithExpandedYearsMasks(oldFormat: DateFormat, date: Date, timeZone: string, selectedDateLevel: DateLevel, isFiscalOn: boolean, fiscalMonth: MonthOfYear): DateFormat;
+/**
+ * Substitutes any QQ or Q with their escaped text describing the quarter number and
+ * returns a new date format string.
+ *
+ * Takes into consideration:
+ * - the configured start month of the customer's fiscal year
+ * - the currently selected date level for this particular column of data
+ *
+ * @param oldFormat
+ * @param date
+ * @param selectedDateLevel
+ * @param fiscalMonth
+ */
+export declare function newDateFormatWithExpandedQuartersMasks(oldFormat: DateFormat, date: Date, selectedDateLevel: DateLevel, fiscalMonth: MonthOfYear): DateFormat;

package/dist/query/date-formats/index.d.ts

@@ -0,0 +1,2 @@
+export type { DateFormat, DateConfig } from './apply-date-format';
+export { applyDateFormat, defaultDateConfig } from './apply-date-format';

package/dist/query/date-formats/new-date-format.d.ts

@@ -0,0 +1,16 @@
+import type { DateFormat } from './apply-date-format';
+type replacement = string;
+type getReplacementFn = (matchForSearchText: string) => replacement;
+/**
+ * Returns a new date format string.
+ *
+ * If `searchText` is found in `oldDateFormat`, then
+ * all occurrences of `searchText` are replaced. The replacement text
+ * will be whatever is returned by the `getReplacement` function.
+ *
+ * @param oldDateFormat
+ * @param searchText
+ * @param getReplacement
+ */
+export declare function newDateFormat(oldDateFormat: DateFormat, searchText: string, getReplacement: getReplacementFn): DateFormat;
+export {};

package/dist/query/date-formats/simple-date-format-replacers.d.ts

@@ -0,0 +1,4 @@
+import type { DateFormat } from './apply-date-format';
+export declare function newDateFormatWithUnicodeMillisecondsMasks(oldFormat: DateFormat): DateFormat;
+export declare function newDateFormatWithExpandedAMPM(oldFormat: DateFormat, date: Date, timeZone: string): DateFormat;
+export declare function newDateFormatWithExpandedTimezoneOffset(oldFormat: DateFormat, date: Date, timeZone: string, locale: Locale): DateFormat;

package/dist/query/execute-query.d.ts

@@ -0,0 +1,8 @@
+import { Attribute, DataSource, Filter, Measure, QueryResultData } from '@sisense/sdk-data';
+import { ClientApplication } from '../app/client-application';
+/** @internal */
+export declare const QUERY_DEFAULT_LIMIT = 20000;
+/** @internal */
+export declare const QUERY_DEFAULT_OFFSET = 0;
+/** @internal */
+export declare const executeQuery: (dataSource: DataSource | undefined, dimensions: Attribute[] | undefined, measures: Measure[] | undefined, filters: Filter[] | undefined, highlights: Filter[] | undefined, app: ClientApplication, count?: number, offset?: number) => Promise<QueryResultData>;

package/dist/query/query-result-date-formatting.d.ts

@@ -0,0 +1,5 @@
+import type { Locale } from 'date-fns';
+import { Data } from '@sisense/sdk-data';
+import type { DateConfig } from './date-formats';
+import type { QueryResultData } from '@sisense/sdk-data';
+export declare function applyDateFormats(data: QueryResultData | Data, chartDataOptions: any, locale?: Locale, dateConfig?: DateConfig): QueryResultData | Data;

package/dist/query-execution/execute-query-by-widget-id.d.ts

@@ -0,0 +1,29 @@
+import { type FunctionComponent } from 'react';
+import { ExecuteQueryByWidgetIdProps } from '../props';
+/**
+ * Executes a query over the existing widget and renders a function as child component.
+ * The child component is passed the results of the query.
+ *
+ * This component takes the Children Prop Pattern and
+ * offers an alternative approach to the {@link useExecuteQueryByWidgetId} hook.
+ *
+ * @example
+ * The example below executes a query over the existing dashboard widget with the specified widget and dashboard OIDs.
+ * ```tsx
+ * <ExecuteQueryByWidgetId
+ *   widgetOid={'64473e07dac1920034bce77f'}
+ *   dashboardOid={'6441e728dac1920034bce737'}
+ * >
+ * {
+ *   (data, query) => {
+ *     if (data) {
+ *       return <div>{`Total Rows: ${data.rows.length}`}</div>;
+ *     }
+ *   }
+ * }
+ * </ExecuteQueryByWidgetId>
+ * ```
+ * @param props - ExecuteQueryByWidgetId properties
+ * @returns ExecuteQueryByWidgetId component
+ */
+export declare const ExecuteQueryByWidgetId: FunctionComponent<ExecuteQueryByWidgetIdProps>;

package/dist/query-execution/execute-query.d.ts

@@ -0,0 +1,32 @@
+import { type FunctionComponent } from 'react';
+import { ExecuteQueryProps } from '../props';
+/**
+ * Executes a query and renders a function as child component. The child
+ * component is passed the results of the query.
+ *
+ * This component takes the Children Prop Pattern and
+ * offers an alternative approach to the {@link useExecuteQuery} hook.
+ *
+ * @example
+ * Example of using the component to query the `Sample ECommerce` data source:
+ * ```tsx
+ * <ExecuteQuery
+ *   dataSource={DM.DataSource}
+ *   dimensions={[DM.Commerce.AgeRange]}
+ *   measures={[measures.sum(DM.Commerce.Revenue)]}
+ *   filters={[filters.greaterThan(DM.Commerce.Revenue, 1000)]}
+ * >
+ * {
+ *   (data) => {
+ *     if (data) {
+ *       console.log(data);
+ *       return <div>{`Total Rows: ${data.rows.length}`}</div>;
+ *     }
+ *   }
+ * }
+ * </ExecuteQuery>
+ * ```
+ * @param props - ExecuteQuery properties
+ * @returns ExecuteQuery component
+ */
+export declare const ExecuteQuery: FunctionComponent<ExecuteQueryProps>;

package/dist/query-execution/index.d.ts

@@ -0,0 +1,5 @@
+export { ExecuteQuery } from './execute-query';
+export { useExecuteQuery, type ExecuteQueryParams } from './use-execute-query';
+export { ExecuteQueryByWidgetId } from './execute-query-by-widget-id';
+export { useExecuteQueryByWidgetId, type ExecuteQueryByWidgetIdParams, type QueryByWidgetIdState, executeQueryByWidgetId, } from './use-execute-query-by-widget-id';
+export type { QueryState, QueryLoadingState, QuerySuccessState, QueryErrorState, } from './query-state-reducer';

package/dist/query-execution/query-state-reducer.d.ts

@@ -0,0 +1,66 @@
+import { QueryResultData } from '@sisense/sdk-data';
+/**
+ * State of a query execution.
+ */
+export type QueryState = QueryLoadingState | QueryErrorState | QuerySuccessState;
+/**
+ * State of a query execution that is loading.
+ */
+export type QueryLoadingState = {
+    /** Whether the query is loading */
+    isLoading: true;
+    /** Whether the query has failed */
+    isError: false;
+    /** Whether the query has succeeded */
+    isSuccess: false;
+    /** The error if any occurred */
+    error: undefined;
+    /** The result data if the query has succeeded */
+    data: QueryResultData | undefined;
+    /** The status of the query execution */
+    status: 'loading';
+};
+/**
+ * State of a query execution that has failed.
+ */
+export type QueryErrorState = {
+    /** Whether the query is loading */
+    isLoading: false;
+    /** Whether the query has failed */
+    isError: true;
+    /** Whether the query has succeeded */
+    isSuccess: false;
+    /** The error if any occurred */
+    error: Error;
+    /** The result data if the query has succeeded */
+    data: undefined;
+    /** The status of the query execution */
+    status: 'error';
+};
+/**
+ * State of a query execution that has succeeded.
+ */
+export type QuerySuccessState = {
+    /** Whether the query is loading */
+    isLoading: false;
+    /** Whether the query has failed */
+    isError: false;
+    /** Whether the query has succeeded */
+    isSuccess: true;
+    /** The error if any occurred */
+    error: undefined;
+    /** The result data if the query has succeeded */
+    data: QueryResultData;
+    /** The status of the query execution */
+    status: 'success';
+};
+export type QueryAction = {
+    type: 'loading';
+} | {
+    type: 'success';
+    data: QueryResultData;
+} | {
+    type: 'error';
+    error: Error;
+};
+export declare function queryStateReducer(state: QueryState, action: QueryAction): QueryState;

package/dist/query-execution/use-execute-query-by-widget-id.d.ts

@@ -0,0 +1,71 @@
+import { type Filter } from '@sisense/sdk-data';
+import { ExecuteQueryParams } from './index.js';
+import { QueryState } from './query-state-reducer.js';
+import { FiltersMergeStrategy } from '../dashboard-widget/types.js';
+import { ClientApplication } from '../app/client-application.js';
+/**
+ * Parameters for {@link useExecuteQueryByWidgetId} hook.
+ */
+export interface ExecuteQueryByWidgetIdParams {
+    /** {@inheritDoc ExecuteQueryByWidgetIdProps.widgetOid} */
+    widgetOid: string;
+    /** {@inheritDoc ExecuteQueryByWidgetIdProps.dashboardOid} */
+    dashboardOid: string;
+    /** {@inheritDoc ExecuteQueryByWidgetIdProps.filters} */
+    filters?: Filter[];
+    /** {@inheritDoc ExecuteQueryByWidgetIdProps.highlights} */
+    highlights?: Filter[];
+    /** {@inheritDoc ExecuteQueryProps.count} */
+    count?: number;
+    /** {@inheritDoc ExecuteQueryProps.offset} */
+    offset?: number;
+    /** {@inheritDoc ExecuteQueryByWidgetIdProps.filtersMergeStrategy} */
+    filtersMergeStrategy?: FiltersMergeStrategy;
+}
+export type QueryByWidgetIdState = QueryState & {
+    /** Query parameters constructed over the widget */
+    query: ExecuteQueryParams | undefined;
+};
+/**
+ * React hook that executes a data query extracted from an existing widget in the Sisense instance.
+ *
+ * This approach, which offers an alternative to {@link ExecuteQueryByWidgetId} component, is similar to React Query's `useQuery` hook.
+ *
+ *
+ * @example
+ * The example below executes a query over the existing dashboard widget with the specified widget and dashboard OIDs.
+ ```tsx
+  const { data, isLoading, isError } = useExecuteQueryByWidgetId({
+    widgetOid: '64473e07dac1920034bce77f'
+    dashboardOid: '6441e728dac1920034bce737'
+  });
+  if (isLoading) {
+    return <div>Loading...</div>;
+  }
+  if (isError) {
+    return <div>Error</div>;
+  }
+  if (data) {
+    return <div>{`Total Rows: ${data.rows.length}`}</div>;
+  }
+  return null;
+ ```
+ * See also hook {@link useExecuteQuery}, which execute a query specified in code.
+ * @param params - Parameters to identify the target widget
+ * @returns Query state that contains the status of the query execution, the result data, the constructed query parameters, or the error if any occurred
+ */
+export declare const useExecuteQueryByWidgetId: (params: ExecuteQueryByWidgetIdParams) => QueryByWidgetIdState;
+/**
+ * Checks if the parameters have changed by deep comparison.
+ *
+ * @param prevParams - Previous query parameters
+ * @param newParams - New query parameters
+ */
+export declare function isParamsChanged(prevParams: ExecuteQueryByWidgetIdParams | undefined, newParams: ExecuteQueryByWidgetIdParams): boolean;
+/** @internal */
+export declare function executeQueryByWidgetId({ widgetOid, dashboardOid, filters, highlights, filtersMergeStrategy, count, offset, app, }: ExecuteQueryByWidgetIdParams & {
+    app: ClientApplication;
+}): Promise<{
+    data: import("@sisense/sdk-data").QueryResultData;
+    query: ExecuteQueryParams;
+}>;

package/dist/query-execution/use-execute-query.d.ts

@@ -0,0 +1,70 @@
+import { Attribute, DataSource, Filter, Measure } from '@sisense/sdk-data';
+import { QueryState } from './query-state-reducer';
+/**
+ * Parameters for {@link useExecuteQuery} hook.
+ */
+export type ExecuteQueryParams = {
+    /**
+     * Data source the query is run against - e.g. `Sample ECommerce`
+     *
+     * If not specified, the query will use the `defaultDataSource` specified in the parent {@link SisenseContextProvider} component.
+     */
+    dataSource?: DataSource;
+    /** Dimensions of the query */
+    dimensions?: Attribute[];
+    /** Measures of the query */
+    measures?: Measure[];
+    /** Filters that will slice query results */
+    filters?: Filter[];
+    /** Highlight filters that will highlight results that pass filter criteria */
+    highlights?: Filter[];
+    /** {@inheritDoc ExecuteQueryProps.count} */
+    count?: number;
+    /** {@inheritDoc ExecuteQueryProps.offset} */
+    offset?: number;
+    /**
+     * Boolean flag to control if query is executed
+     *
+     * If not specified, the default value is `true`
+     */
+    enabled?: boolean;
+};
+/**
+ * React hook that executes a data query.
+ * This approach, which offers an alternative to {@link ExecuteQuery} component, is similar to React Query's `useQuery` hook.
+ *
+ * @example
+ ```tsx
+  const { data, isLoading, isError } = useExecuteQuery({
+    dataSource: DM.DataSource,
+    dimensions: [DM.Commerce.AgeRange],
+    measures: [measures.sum(DM.Commerce.Revenue)],
+    filters: [filters.greaterThan(DM.Commerce.Revenue, 1000)],
+  });
+  if (isLoading) {
+    return <div>Loading...</div>;
+  }
+  if (isError) {
+    return <div>Error</div>;
+  }
+  if (data) {
+    return <div>{`Total Rows: ${data.rows.length}`}</div>;
+  }
+  return null;
+ ```
+
+ * See also hook {@link useExecuteQueryByWidgetId}, which extracts data from an existing widget in the Sisense instance.
+ *
+ * See [this blog post]( https://www.sisense.com/blog/take-control-of-your-data-visualizations/) for examples
+ * of using the hook to fetch data from Sisense for third-party charts.
+ * @param params - Parameters of the query
+ * @returns Query state that contains the status of the query execution, the result data, or the error if any occurred
+ */
+export declare const useExecuteQuery: (params: ExecuteQueryParams) => QueryState;
+/**
+ * Hook that returns the value from the previous render.
+ *
+ * @param value - Value to return from the previous render.
+ * @returns Value from the previous render.
+ */
+export declare function usePrevious<T>(value: T): T | undefined;

package/dist/query-execution/utils.d.ts

@@ -0,0 +1,9 @@
+import type { ExecuteQueryParams } from './index';
+import type { WidgetDto } from '../dashboard-widget/types';
+/**
+ * Extracts query parameters from a widget object.
+ *
+ * @param {WidgetDto} widget - The widget from which to extract query parameters.
+ * @returns {ExecuteQueryParams} An object containing extracted query parameters.
+ */
+export declare function extractQueryFromWidget(widget: WidgetDto): ExecuteQueryParams;

package/dist/scatter-chart.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="react" />
+import { ScatterChartProps } from './props';
+/**
+ * A React component displaying the distribution of two variables on an X-Axis, Y-Axis,
+ * and two additional fields of data that are shown as colored circles scattered across the chart.
+ *
+ * **Point**: A field that for each of its members a scatter point is drawn. The maximum amount of data points is 500.
+ *
+ * **Size**: An optional field represented by the size of the circles.
+ * If omitted, all scatter points are equal in size. If used, the circle size is relative to their value.
+ *
+ * See [Scatter Chart](https://docs.sisense.com/main/SisenseLinux/scatter-chart.htm) for more information.
+ *
+ * @example
+ * An example of using the component to visualize the `Sample ECommerce` data source.
+ *
+ * The chart shows top Categories by Total Revenue on the x-axis, and Total Quantity on the y-axis in logarithmic scale
+ * with Gender breakdown by color and Total Cost encoded by the size of the bubbles.
+ * ```tsx
+ * <ScatterChart
+ *   dataSet={DM.DataSource}
+ *   filters={[filters.greaterThan(DM.Commerce.Revenue, 10)]}
+ *   dataOptions={{
+ *     x: measures.sum(DM.Commerce.Revenue),
+ *     y: measures.sum(DM.Commerce.Quantity),
+ *     breakByPoint: DM.Category.Category,
+ *     breakByColor: DM.Commerce.Gender,
+ *     size: measures.sum(DM.Commerce.Cost),
+ *   }}
+ *   styleOptions={{
+ *     xAxis: {
+ *       enabled: true,
+ *       gridLines: true,
+ *       isIntervalEnabled: false,
+ *       labels: {
+ *         enabled: true,
+ *       },
+ *       logarithmic: true,
+ *       title: {
+ *         enabled: true,
+ *         text: 'Total Revenue',
+ *       },
+ *     },
+ *     yAxis: {
+ *       enabled: true,
+ *       gridLines: true,
+ *       isIntervalEnabled: false,
+ *       labels: {
+ *         enabled: true,
+ *       },
+ *       logarithmic: true,
+ *       title: {
+ *         enabled: true,
+ *         text: 'Total Quantity',
+ *       },
+ *     },
+ *   }}
+ *   onDataPointClick={(point, nativeEvent) => {
+ *     console.log('clicked', point, nativeEvent);
+ *   }}
+ * />
+ * ```
+ *
+ * <img src="media://scatter-chart-example-1.png" width="800px" />
+ * @param props - Scatter chart properties
+ * @returns Scatter Chart component
+ */
+export declare const ScatterChart: import("react").FunctionComponent<ScatterChartProps>;

package/dist/sisense-chart.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { ChartDataOptionsInternal } from './chart-data-options/types';
+import { ChartData } from './chart-data/types';
+import { DataPointEventHandler, DataPointsEventHandler, ScatterDataPointEventHandler, ScatterDataPointsEventHandler } from './chart-options-processor/apply-event-handlers';
+import { BeforeRenderHandler } from './props';
+import { ChartDesignOptions } from './chart-options-processor/translations/types';
+import { ChartType, CompleteThemeSettings } from './types';
+interface Props {
+    chartType: ChartType;
+    chartData: ChartData;
+    chartDataOptions: ChartDataOptionsInternal;
+    designOptions: ChartDesignOptions;
+    themeSettings?: CompleteThemeSettings;
+    onDataPointClick?: DataPointEventHandler | ScatterDataPointEventHandler;
+    onDataPointContextMenu?: DataPointEventHandler | ScatterDataPointEventHandler;
+    onDataPointsSelected?: DataPointsEventHandler | ScatterDataPointsEventHandler;
+    onBeforeRender?: BeforeRenderHandler;
+}
+/**
+ * @internal
+ */
+export declare const SisenseChart: ({ chartType, chartData, chartDataOptions, designOptions, themeSettings, onDataPointClick, onDataPointContextMenu, onDataPointsSelected, onBeforeRender, }: Props) => JSX.Element | null;
+export {};

package/dist/sisense-context/custom-sisense-context-provider.d.ts

@@ -0,0 +1,19 @@
+import { PropsWithChildren, type FunctionComponent } from 'react';
+import { SisenseContextPayload } from './sisense-context';
+/** @internal */
+export type CustomSisenseContext = SisenseContextPayload & {
+    showRuntimeErrors: boolean;
+};
+/** @internal */
+export type CustomSisenseContextProviderProps = {
+    context?: CustomSisenseContext;
+    error?: Error;
+};
+/**
+ * Custom Sisense Context Provider component that allows passing external context.
+ *
+ * Note: it specifically designed to serve as a bridge for passing context between an external wrapper and child React components.
+ *
+ * @internal
+ */
+export declare const CustomSisenseContextProvider: FunctionComponent<PropsWithChildren<CustomSisenseContextProviderProps>>;

package/dist/sisense-context/sisense-context-provider.d.ts

@@ -0,0 +1,36 @@
+import { PropsWithChildren, type FunctionComponent } from 'react';
+import { SisenseContextProviderProps } from '../props';
+/**
+ * Sisense Context Provider Component allowing you to connect to
+ * a Sisense instance and provide that context
+ * to all Compose SDK components in your application.
+ *
+ * @example
+ * Add SisenseContextProvider to the main component of your app as below and then wrap
+ * other SDK components inside this component.
+ *
+ * ```tsx
+ * import { Chart, SisenseContextProvider } from '@sisense/sdk-ui';
+ * import * as DM from './sample-ecommerce';
+ * import { measures } from '@sisense/sdk-data';
+ *
+ * function App() {
+ *   return (
+ *     <>
+ *       <SisenseContextProvider
+ *         url="<instance url>" // replace with the URL of your Sisense instance
+ *         token="<api token>" // replace with the API token of your user account
+ *       >
+ *         <OtherComponent1/>
+ *         <OtherComponent2/>
+ *       </SisenseContextProvider>
+ *     </>
+ *   );
+ * }
+ *
+ * export default App;
+ * ```
+ * @param props - Sisense context provider props
+ * @returns A Sisense Context Provider Component
+ */
+export declare const SisenseContextProvider: FunctionComponent<PropsWithChildren<SisenseContextProviderProps>>;

package/dist/sisense-context/sisense-context.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ClientApplication } from '../app/client-application';
+export type SisenseContextPayload = {
+    isInitialized: boolean;
+    app?: ClientApplication;
+    enableTracking: boolean;
+};
+export declare const SisenseContext: import("react").Context<SisenseContextPayload>;
+export declare const useSisenseContext: () => SisenseContextPayload;

package/dist/table/hooks/use-table-data.d.ts

@@ -0,0 +1,11 @@
+import { Data, DataSource, Filter } from '@sisense/sdk-data';
+import { TableDataOptionsInternal } from '../../chart-data-options/types';
+type UseDataProps = {
+    dataSet: Data | DataSource | undefined;
+    dataOptions: TableDataOptionsInternal | null;
+    filters: Filter[] | undefined;
+    count: number;
+    offset: number;
+};
+export declare const useTableData: ({ dataSet, dataOptions, filters, count, offset, }: UseDataProps) => Data | null;
+export {};

package/dist/table/hooks/use-table-datatable.d.ts

@@ -0,0 +1,11 @@
+import { Data } from '@sisense/sdk-data';
+import { TableDataOptionsInternal } from '../../chart-data-options/types';
+import { DataColumnNamesMapping } from '../../chart-data-options/validate-data-options';
+type UseTableDataTableProps = {
+    data: null | Data;
+    innerDataOptions: TableDataOptionsInternal | null;
+    dataColumnNamesMapping: DataColumnNamesMapping;
+    needToAggregate?: boolean;
+};
+export declare const useTableDataTable: ({ data, innerDataOptions, dataColumnNamesMapping, needToAggregate, }: UseTableDataTableProps) => import("../../chart-data-processor/table-processor").DataTable | null;
+export {};

package/dist/table/index.d.ts

@@ -0,0 +1 @@
+export { Table } from './table';

package/dist/table/styles/get-custom-pagination-styles.d.ts

@@ -0,0 +1,10 @@
+import { CompleteThemeSettings } from '../../types';
+export declare const getCustomPaginationStyles: (themeSettings: CompleteThemeSettings) => {
+    '& .MuiPaginationItem-circular.Mui-selected': {
+        color: string;
+    };
+    '& .MuiPaginationItem-circular': {
+        color: string;
+        fontFamily: string;
+    };
+};