@levi-gemcommerce/analytics 0.0.1-dev.2 → 0.0.1-dev.4

package/dist/esm/core/gemxql/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCustomGemXQlQuery';
+export * from './useGemxQlNamedQuery';

package/dist/esm/core/gemxql/api/useCustomGemXQlQuery.d.ts

@@ -0,0 +1,16 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { GemxQlQueryResponse, GemxQlQueryVariables } from '../graphql';
+type GemXQlCustomFetcher<TData, TVariables> = (document: string, variables: TVariables) => () => Promise<TData>;
+export interface BaseHeaderResponse {
+    'x-cache'?: string;
+    'x-request-id'?: string;
+}
+export interface CustomGemXQlResponse extends GemxQlQueryResponse {
+    headers: BaseHeaderResponse;
+}
+type GemXQlQueryOptions<TData, TError> = Omit<UseQueryOptions<CustomGemXQlResponse, TError, TData, QueryKey>, 'queryKey' | 'queryFn'>;
+export declare const useCustomGemXQlQuery: {
+    <TData = CustomGemXQlResponse, TError = unknown>(variables: GemxQlQueryVariables, fetcher: GemXQlCustomFetcher<CustomGemXQlResponse, GemxQlQueryVariables>, options?: GemXQlQueryOptions<TData, TError>): UseQueryResult<TData, TError>;
+    getKey(variables: GemxQlQueryVariables): (string | GemxQlQueryVariables)[];
+};
+export {};

package/dist/esm/core/gemxql/api/useGemxQlNamedQuery.d.ts

@@ -0,0 +1,14 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { GemxQlQueryResponse, GemxQlQueryVariables } from '../graphql';
+type GemXQlFetcher<TData, TVariables> = (document: string, variables: TVariables) => () => Promise<TData>;
+interface UseGemxQlNamedQueryParams {
+    name: string;
+    variables: GemxQlQueryVariables;
+    fetcher: GemXQlFetcher<GemxQlQueryResponse, GemxQlQueryVariables>;
+}
+type GemXQlNamedQueryOptions<TData, TError> = Omit<UseQueryOptions<GemxQlQueryResponse, TError, TData, QueryKey>, 'queryKey' | 'queryFn'>;
+export declare const useGemxQlNamedQuery: {
+    <TData = GemxQlQueryResponse, TError = unknown>({ name, variables, fetcher }: UseGemxQlNamedQueryParams, options?: GemXQlNamedQueryOptions<TData, TError>): UseQueryResult<TData, TError>;
+    getKey(name: string, variables: GemxQlQueryVariables): (string | GemxQlQueryVariables)[];
+};
+export {};

package/dist/esm/core/gemxql/builder/build-gemxql-query.d.ts

@@ -0,0 +1,15 @@
+import type { IBuildConditionQueryParams } from './clauses/condition-query';
+import type { IBuildFromQueryParams } from './clauses/from-query';
+import type { IBuildGroupQueryParams } from './clauses/group-query';
+import type { IBuildLimitQueryParams } from './clauses/limit-query';
+import type { IBuildModeQueryParams } from './clauses/mode-query';
+import type { IBuildOffsetQueryParams } from './clauses/offset-query';
+import type { IBuildOrderByQueryParams } from './clauses/order-by-query';
+import type { IBuildShowQueryParams } from './clauses/show-query';
+import type { IBuildTimeQueryParams } from './clauses/time-query';
+import type { IBuildTimeSeriesQueryParams } from './clauses/time-series-query';
+import type { IBuildTimezoneQueryParams } from './clauses/timezone-query';
+export type IBuildGemXQlQueryParams = IBuildModeQueryParams & IBuildFromQueryParams & IBuildShowQueryParams & IBuildGroupQueryParams & IBuildTimeQueryParams & IBuildTimeSeriesQueryParams & IBuildTimezoneQueryParams & IBuildOrderByQueryParams & IBuildConditionQueryParams & IBuildLimitQueryParams & IBuildOffsetQueryParams & {
+    extraOrderByFields?: string[];
+};
+export declare const buildGemXQlQuery: (params: IBuildGemXQlQueryParams) => string;

package/dist/esm/core/gemxql/builder/clauses/condition-query.d.ts

@@ -0,0 +1,12 @@
+import type { GemXQlFilters, GemXQlVersionIds, IExtraCondition } from '../../types';
+import type { IBuildFilterConditionsParams, IBuildVersionIdConditionParams } from '../filters/build-filter-conditions';
+export interface IBuildConditionQueryParams extends IBuildFilterConditionsParams, IBuildVersionIdConditionParams {
+    extraConditions?: IExtraCondition[];
+}
+export type IParseConditionQueryResult = {
+    filters: GemXQlFilters;
+    versionIds?: GemXQlVersionIds;
+};
+declare const build: ({ filters, overrideFilters, versionIds, extraConditions }: IBuildConditionQueryParams) => string;
+declare const parse: (query: string) => IParseConditionQueryResult;
+export { build as buildConditionQuery, parse as parseConditionQuery };

package/dist/esm/core/gemxql/builder/clauses/from-query.d.ts

@@ -0,0 +1,6 @@
+export interface IBuildFromQueryParams {
+    sources: string[];
+}
+declare const build: (sources: string[]) => string;
+declare const parse: (query: string) => string[];
+export { build as buildFromQuery, parse as parseFromQuery };

package/dist/esm/core/gemxql/builder/clauses/group-query.d.ts

@@ -0,0 +1,11 @@
+import { EGroupWithClause } from '../../types';
+export interface IBuildGroupQueryParams {
+    dimensions: string[];
+    groupWithClause?: EGroupWithClause;
+}
+declare const build: (dimensions: string[], withClause?: EGroupWithClause) => string;
+declare const parse: (query: string) => {
+    dimensions: string[];
+    groupWithClause?: EGroupWithClause;
+};
+export { build as buildGroupQuery, parse as parseGroupQuery };

package/dist/esm/core/gemxql/builder/clauses/index.d.ts

@@ -0,0 +1,11 @@
+export * from './condition-query';
+export * from './from-query';
+export * from './group-query';
+export * from './limit-query';
+export * from './mode-query';
+export * from './offset-query';
+export * from './order-by-query';
+export * from './show-query';
+export * from './time-query';
+export * from './time-series-query';
+export * from './timezone-query';

package/dist/esm/core/gemxql/builder/clauses/limit-query.d.ts

@@ -0,0 +1,6 @@
+export interface IBuildLimitQueryParams {
+    limit?: number;
+}
+declare const build: (limit?: number) => string;
+declare const parse: (query: string) => number | undefined;
+export { build as buildLimitQuery, parse as parseLimitQuery };

package/dist/esm/core/gemxql/builder/clauses/mode-query.d.ts

@@ -0,0 +1,7 @@
+import type { EAnalyticMode } from '../../types';
+export interface IBuildModeQueryParams {
+    mode: EAnalyticMode;
+}
+declare const build: (mode: EAnalyticMode) => string;
+declare const parse: (query: string) => EAnalyticMode | undefined;
+export { build as buildModeQuery, parse as parseModeQuery };

package/dist/esm/core/gemxql/builder/clauses/offset-query.d.ts

@@ -0,0 +1,6 @@
+export interface IBuildOffsetQueryParams {
+    offset?: number;
+}
+declare const build: (offset?: number) => string;
+declare const parse: (query: string) => number | undefined;
+export { build as buildOffsetQuery, parse as parseOffsetQuery };

package/dist/esm/core/gemxql/builder/clauses/order-by-query.d.ts

@@ -0,0 +1,7 @@
+import type { OrderByFields } from '../../types';
+export interface IBuildOrderByQueryParams {
+    orderBy?: OrderByFields;
+}
+declare const build: (orderBy?: OrderByFields, columns?: string[]) => string;
+declare const parse: (query: string) => OrderByFields | undefined;
+export { build as buildOrderByQuery, parse as parseOrderByQuery };

package/dist/esm/core/gemxql/builder/clauses/show-query.d.ts

@@ -0,0 +1,6 @@
+export interface IBuildShowQueryParams {
+    metrics: string[];
+}
+declare const build: (metrics: string[]) => string;
+declare const parse: (query: string) => string[];
+export { build as buildShowQuery, parse as parseShowQuery };

package/dist/esm/core/gemxql/builder/clauses/time-query.d.ts

@@ -0,0 +1,16 @@
+import type { AnalyticDateFilter, GemXQlFilters, GemXQlOverrideFilters } from '../../types';
+export interface IBuildTimeQueryParams {
+    dateRange?: AnalyticDateFilter;
+    compareDateRange?: AnalyticDateFilter;
+    overrideFilters?: GemXQlOverrideFilters;
+    timeDimension?: string;
+}
+export type IParseTimeQueryResult = {
+    dateRange?: Pick<AnalyticDateFilter, 'startDate' | 'endDate'>;
+    compareDateRange?: Pick<AnalyticDateFilter, 'startDate' | 'endDate'>;
+    timeDimension?: string;
+    overrideFilters?: GemXQlFilters;
+};
+declare const build: (data: IBuildTimeQueryParams) => string;
+declare const parse: (query: string) => IParseTimeQueryResult;
+export { build as buildTimeQuery, parse as parseTimeQuery };

package/dist/esm/core/gemxql/builder/clauses/time-series-query.d.ts

@@ -0,0 +1,6 @@
+export interface IBuildTimeSeriesQueryParams {
+    timeDimension?: string;
+}
+declare const build: (time?: string) => string;
+declare const parse: (query: string) => string | undefined;
+export { build as buildTimeSeriesQuery, parse as parseTimeSeriesQuery };

package/dist/esm/core/gemxql/builder/clauses/timezone-query.d.ts

@@ -0,0 +1,6 @@
+export interface IBuildTimezoneQueryParams {
+    timezone?: string;
+}
+declare const build: (timezone?: string) => string;
+declare const parse: (query: string) => string | undefined;
+export { build as buildTimezoneQuery, parse as parseTimezoneQuery };

package/dist/esm/core/gemxql/builder/configs/date-formats.d.ts

@@ -0,0 +1 @@
+export declare const DATE_QUERY_FORMAT = "YYYY-MM-DDTHH:mm:ss";

package/dist/esm/core/gemxql/builder/configs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './date-formats';
+export * from './keywords';
+export * from './query-defaults';

package/dist/esm/core/gemxql/builder/configs/keywords.d.ts

@@ -0,0 +1,2 @@
+export declare const CLAUSE_KEYWORDS: readonly ["MODE", "FROM", "SHOW", "GROUP BY", "TIMESERIES", "SINCE", "DURING", "TIMEZONE", "WHERE", "ORDER BY", "LIMIT", "OFFSET"];
+export declare const CLAUSE_KEYWORD_BOUNDARY: string;

package/dist/esm/core/gemxql/builder/configs/query-defaults.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_QUERY_LIMIT = 1000;

package/dist/esm/core/gemxql/builder/filters/build-extra-conditions.d.ts

@@ -0,0 +1,3 @@
+import type { IExtraCondition } from '../../types';
+export declare const buildExtraCondition: (condition: IExtraCondition) => string;
+export declare const buildExtraConditions: (conditions?: IExtraCondition[]) => string[];

package/dist/esm/core/gemxql/builder/filters/build-filter-conditions.d.ts

@@ -0,0 +1,22 @@
+import type { GemXQlFilters, GemXQlOverrideFilters, GemXQlVersionIds, OrderByFields } from '../../types';
+import { EFilterField, EOperatorField } from '../../types';
+export interface IBuildFilterConditionsParams {
+    filters: GemXQlFilters;
+    overrideFilters?: GemXQlOverrideFilters;
+}
+export interface IBuildVersionIdConditionParams {
+    versionIds?: GemXQlVersionIds;
+}
+interface FilterConfig {
+    operator?: EOperatorField;
+    operatorVal?: string;
+    singleField: EFilterField;
+    multiField: EFilterField;
+    condition?: EFilterField;
+    fieldName?: EFilterField;
+}
+export declare const filterConfigs: FilterConfig[];
+export declare const generateFilterConditions: (filters: GemXQlFilters, overrideFilters?: GemXQlOverrideFilters) => string[];
+export declare const buildVersionIdCondition: (versionIds?: GemXQlVersionIds) => string[];
+export declare const getFirstMetricInOrderBy: (orderBy: OrderByFields | undefined, metrics: string[]) => string[];
+export {};

package/dist/esm/core/gemxql/builder/filters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './build-extra-conditions';
+export * from './build-filter-conditions';

package/dist/esm/core/gemxql/builder/helpers/date-query-helpers.d.ts

@@ -0,0 +1,5 @@
+import type { AnalyticDateFilter } from '../../types';
+export declare const getDateRangeForQuery: (dateRange: AnalyticDateFilter) => {
+    dateGTE: string;
+    dateLTE: string;
+};

package/dist/esm/core/gemxql/builder/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './is-valid-query-input';

package/dist/esm/core/gemxql/builder/helpers/is-valid-query-input.d.ts

@@ -0,0 +1 @@
+export declare function isValidQueryInput(query: string): boolean;

package/dist/esm/core/gemxql/builder/index.d.ts

@@ -0,0 +1,6 @@
+export * from './build-gemxql-query';
+export * from './clauses';
+export * from './configs';
+export * from './filters';
+export * from './helpers';
+export * from './parse-gemxql-query';

package/dist/esm/core/gemxql/builder/parse-gemxql-query.d.ts

@@ -0,0 +1,4 @@
+import type { IBuildGemXQlQueryParams } from './build-gemxql-query';
+export type IParsedGemXQlQuery = Partial<IBuildGemXQlQueryParams>;
+declare const parse: (query: string) => IParsedGemXQlQuery;
+export { parse as parseGemXQlQuery };

package/dist/esm/core/gemxql/constants/analytic-data.d.ts

@@ -0,0 +1,2 @@
+export declare const NONE_VALUE = "None";
+export declare const PLACEHOLDER_VALUE = "-";

package/dist/esm/core/gemxql/constants/column-keys.d.ts

@@ -0,0 +1,4 @@
+export declare const TOTALS_SUFFIX = "___totals";
+export declare const COMPARE_PREFIX = "comparison___";
+export declare const COMPARE_SUFFIX = "___previous_period";
+export declare const COMPARE_TOTALS_SUFFIX = "___previous_period___totals";

package/dist/esm/core/gemxql/constants/index.d.ts

@@ -0,0 +1,4 @@
+export * from './analytic-data';
+export * from './column-keys';
+export * from './operators';
+export * from './row-reader-mode';

package/dist/esm/core/gemxql/constants/operators.d.ts

@@ -0,0 +1,2 @@
+export declare const OPERATOR_IS = "is";
+export declare const OPERATOR_IS_ONE_OF = "is_one_of";

package/dist/esm/core/gemxql/constants/row-reader-mode.d.ts

@@ -0,0 +1,5 @@
+import { ERowReaderMode } from '../types';
+export declare const ROW_READER_MODE_CONFIG: Record<ERowReaderMode, {
+    prefix: string;
+    suffix: string;
+}>;

package/dist/esm/core/gemxql/graphql/fragments/gemxql.generated.d.ts

@@ -0,0 +1,23 @@
+export type Maybe<T> = T | null | undefined;
+export type TableDataType = 'ARRAY' | 'CURRENCY' | 'DATE' | 'DAY_TIMESTAMP' | 'DURATION' | 'HOUR_TIMESTAMP' | 'INTEGER' | 'MONTH_TIMESTAMP' | 'OBJECT' | 'PERCENT' | 'QUARTER_TIMESTAMP' | 'STRING' | 'WEEK_TIMESTAMP' | 'YEAR_TIMESTAMP';
+export interface IColumn {
+    dataType: TableDataType;
+    displayName?: Maybe<string>;
+    name: string;
+}
+export interface ITableData {
+    rows: unknown;
+    columns?: Maybe<Array<Maybe<IColumn>>>;
+}
+export type ColumnSelectFragment = Pick<IColumn, 'dataType' | 'displayName' | 'name'>;
+export type TableDataSelectFragment = Pick<ITableData, 'rows'> & {
+    columns?: Maybe<Array<Maybe<Pick<IColumn, 'dataType' | 'displayName' | 'name'>>>>;
+};
+export type GemXqlResultSelectFragment = {
+    tableData?: Maybe<Pick<ITableData, 'rows'> & {
+        columns?: Maybe<Array<Maybe<Pick<IColumn, 'dataType' | 'displayName' | 'name'>>>>;
+    }>;
+};
+export declare const ColumnSelectFragmentDoc = "\n    fragment ColumnSelect on Column {\n  dataType\n  displayName\n  name\n}\n    ";
+export declare const TableDataSelectFragmentDoc = "\n    fragment TableDataSelect on TableData {\n  columns {\n    ...ColumnSelect\n  }\n  rows\n}\n    ";
+export declare const GemXqlResultSelectFragmentDoc = "\n    fragment GemXQLResultSelect on GemxQLResult {\n  tableData {\n    ...TableDataSelect\n  }\n}\n    ";

package/dist/esm/core/gemxql/graphql/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fragments/gemxql.generated';
+export * from './queries/gemxql.generated';

package/dist/esm/core/gemxql/graphql/queries/gemxql.generated.d.ts

@@ -0,0 +1,9 @@
+import type { Maybe } from '../fragments/gemxql.generated';
+import { type GemXqlResultSelectFragment } from '../fragments/gemxql.generated';
+export type GemxQlQueryVariables = {
+    input: string;
+};
+export type GemxQlQueryResponse = {
+    gemxQLQuery?: Maybe<GemXqlResultSelectFragment>;
+};
+export declare const GemxQlDocument = "\n    query GemxQL($input: String!) {\n  gemxQLQuery(query: $input) {\n    ...GemXQLResultSelect\n  }\n}\n    \n    fragment GemXQLResultSelect on GemxQLResult {\n  tableData {\n    ...TableDataSelect\n  }\n}\n    \n\n    fragment TableDataSelect on TableData {\n  columns {\n    ...ColumnSelect\n  }\n  rows\n}\n    \n\n    fragment ColumnSelect on Column {\n  dataType\n  displayName\n  name\n}\n    ";

package/dist/esm/core/gemxql/helpers/columnKeys.d.ts

@@ -0,0 +1,3 @@
+export declare const getTotalsKey: (metric: string) => string;
+export declare const getComparisonKey: (metric: string) => string;
+export declare const getComparisonTotalsKey: (metric: string) => string;

package/dist/esm/core/gemxql/helpers/extractQueryData.d.ts

@@ -0,0 +1,5 @@
+import type { GemxQlQueryResponse, TableDataType } from '../graphql';
+export type ColumnTypesMap = Record<string, TableDataType>;
+export declare const extractQueryRows: (response?: GemxQlQueryResponse) => Record<string, unknown>[];
+export declare const extractQueryColumns: (response?: GemxQlQueryResponse) => import("../graphql").Maybe<Pick<import("../graphql").IColumn, "displayName" | "dataType" | "name">>[];
+export declare const extractColumnTypes: (response?: GemxQlQueryResponse) => ColumnTypesMap;

package/dist/esm/core/gemxql/helpers/formatAnalyticData.d.ts

@@ -0,0 +1,10 @@
+import type { AnalyticValueType } from '../types';
+export type IGetTextPrice = (price?: number | string | null, hasCurrency?: boolean, options?: {
+    compact?: boolean;
+}) => string;
+export declare const formatAnalyticData: ({ value, formatter, getTextPrice, name, }: {
+    value: AnalyticValueType;
+    formatter?: string;
+    getTextPrice?: IGetTextPrice;
+    name?: string;
+}) => AnalyticValueType;

package/dist/esm/core/gemxql/helpers/formatAnalyticDate.d.ts

@@ -0,0 +1 @@
+export declare const formatAnalyticDate: (dateString: string | number | null) => string;

package/dist/esm/core/gemxql/helpers/getTimeDimension.d.ts

@@ -0,0 +1,3 @@
+import type { Dayjs } from '../utils/dayjs';
+import { ETimeDimension } from '../types';
+export declare const getTimeDimensionByDate: (startDate: Dayjs, endDate: Dayjs) => ETimeDimension;

package/dist/esm/core/gemxql/helpers/hasMetricData.d.ts

@@ -0,0 +1 @@
+export declare const hasMetricData: (metric?: Record<string, unknown>) => boolean;

package/dist/esm/core/gemxql/helpers/index.d.ts

@@ -0,0 +1,8 @@
+export * from './columnKeys';
+export * from './extractQueryData';
+export * from './formatAnalyticData';
+export * from './formatAnalyticDate';
+export * from './getTimeDimension';
+export * from './hasMetricData';
+export * from './parseJsonFields';
+export * from './readNumeric';

package/dist/esm/core/gemxql/helpers/parseJsonFields.d.ts

@@ -0,0 +1,9 @@
+import type { IPageItemsPayload } from '../types';
+export interface IBreakdownItem<T extends string = string> {
+    type: T;
+    total: number;
+}
+export declare const parseJsonObject: <T extends object>(value: unknown) => T | null;
+export declare const parseJsonArray: <T>(raw: unknown) => T[] | undefined;
+export declare const parseBreakdownItems: <T extends string = string>(raw: unknown) => IBreakdownItem<T>[] | undefined;
+export declare const parsePageItems: (value: unknown) => IPageItemsPayload | null;

package/dist/esm/core/gemxql/helpers/readNumeric.d.ts

@@ -0,0 +1,3 @@
+import { ERowReaderMode } from '../types';
+export declare const readNumeric: (metric: Record<string, unknown> | undefined, key: string) => number;
+export declare const createNumericRowReader: (row: Record<string, unknown>, mode?: ERowReaderMode) => (key: string) => number;

package/dist/esm/core/gemxql/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useAnalyticData';
+export * from './useGemXQlPagination';

package/dist/esm/core/gemxql/hooks/useAnalyticData.d.ts

@@ -0,0 +1,24 @@
+import type { IGetTextPrice } from '../helpers/formatAnalyticData';
+import type { AnalyticValueType } from '../types';
+interface IFormatDataParams {
+    value: AnalyticValueType;
+    formatter?: string;
+    name?: string;
+}
+type MetricRecord = Record<string, unknown>;
+interface IComputeMetricParams {
+    metric?: MetricRecord;
+    previousMetric?: MetricRecord;
+    metricKey: string;
+    formatter?: string;
+}
+interface IComputeMetricResult {
+    value: AnalyticValueType;
+    change: number | string;
+}
+interface IUseAnalyticDataReturn {
+    formatData: (params: IFormatDataParams) => AnalyticValueType;
+    computeMetric: (params: IComputeMetricParams) => IComputeMetricResult;
+}
+export declare const useAnalyticData: (getTextPrice?: IGetTextPrice) => IUseAnalyticDataReturn;
+export {};

package/dist/esm/core/gemxql/hooks/useGemXQlPagination.d.ts

@@ -0,0 +1,25 @@
+export declare enum GPaginationDirection {
+    NEXT = "NEXT",
+    PREV = "PREV"
+}
+export interface GPaginationProps {
+    currentPage: number;
+    totalPages: number;
+    loading?: boolean;
+    handlePageChange: (direction: GPaginationDirection) => void;
+}
+interface IUseGemXQlPaginationProps {
+    resetKey: unknown;
+    itemsPerPage: number;
+}
+interface IBuildPaginationPropsParams {
+    totalRecords: number;
+    isLoading?: boolean;
+}
+interface IUseGemXQlPaginationReturn {
+    currentPage: number;
+    offset: number;
+    buildPagination: (params: IBuildPaginationPropsParams) => GPaginationProps;
+}
+export declare const useGemXQlPagination: ({ resetKey, itemsPerPage, }: IUseGemXQlPaginationProps) => IUseGemXQlPaginationReturn;
+export {};

package/dist/esm/core/gemxql/index.d.ts

@@ -0,0 +1,10 @@
+export * from './api';
+export * from './builder';
+export * from './constants';
+export * from './graphql';
+export * from './helpers';
+export * from './hooks';
+export * from './types';
+export { AnalyticInterval, getFormattedByInterval, getTimeDurationLabel, numberWithCommas } from './utils/analytics';
+export { convertDateToTz, dayjsTz, getInitialTimezone, setTz } from './utils/dayjs';
+export type { Dayjs } from './utils/dayjs';

package/dist/esm/core/gemxql/types/analytic-data.d.ts

@@ -0,0 +1,24 @@
+export declare enum EAnalyticDataType {
+    DATE = "DATE",
+    ARRAY = "ARRAY",
+    OBJECT = "OBJECT",
+    STRING = "STRING",
+    INTEGER = "INTEGER",
+    CURRENCY = "CURRENCY",
+    PERCENT = "PERCENT",
+    DURATION = "DURATION",
+    MONTH = "MONTH_TIMESTAMP",
+    QUARTER = "QUARTER_TIMESTAMP",
+    DAY = "DAY_TIMESTAMP",
+    WEEK = "WEEK_TIMESTAMP",
+    YEAR = "YEAR_TIMESTAMP",
+    HOUR = "HOUR_TIMESTAMP"
+}
+export declare enum EAnalyticColumnKey {
+    CAMPAIGNS = "experiments",
+    VISITOR_ITEMS = "visitor_items",
+    DEVICE_ITEMS = "device_items",
+    TRAFFIC_SOURCE_ITEMS = "traffic_source_items"
+}
+export type AnalyticPrimitiveValueType = string | number | null;
+export type AnalyticValueType = AnalyticPrimitiveValueType;

package/dist/esm/core/gemxql/types/analytic-mode.d.ts

@@ -0,0 +1,5 @@
+export declare enum EAnalyticMode {
+    ALL_SESSION = "ALL_SESSION",
+    FIRST_SESSION = "FIRST_SESSION",
+    PAGE_ONLY = "PAGE_ONLY"
+}

package/dist/esm/core/gemxql/types/analytic-source.d.ts

@@ -0,0 +1,4 @@
+export declare enum EAnalyticSource {
+    SESSIONS = "sessions",
+    SALES = "sales"
+}

package/dist/esm/core/gemxql/types/breakdown-items.d.ts

@@ -0,0 +1,19 @@
+export declare enum EVisitorType {
+    NEW = "new",
+    RETURNING = "returning"
+}
+export declare enum EDeviceType {
+    DESKTOP = "desktop",
+    MOBILE = "mobile",
+    TABLET = "tablet"
+}
+export declare enum ETrafficSourceType {
+    DIRECT = "direct",
+    EMAIL = "email",
+    REFERRAL = "referral",
+    ORGANIC_SOCIAL = "organic-social",
+    ORGANIC_SEARCH = "organic-search",
+    PAID_SOCIAL = "paid-social",
+    PAID_SEARCH = "paid-search",
+    SMS = "sms"
+}

package/dist/esm/core/gemxql/types/date-filter.d.ts

@@ -0,0 +1,10 @@
+import type { Dayjs } from '../utils/dayjs';
+export interface AnalyticDateFilter {
+    versionId?: string;
+    startDate: Dayjs | string;
+    endDate: Dayjs | string;
+    alias: string;
+    since?: string | number;
+    until?: string | number;
+    title?: string;
+}

package/dist/esm/core/gemxql/types/extra-condition.d.ts

@@ -0,0 +1,28 @@
+export declare enum EComparisonOperator {
+    EQ = "=",
+    IN = "IN",
+    LIKE = "LIKE"
+}
+export declare enum EGroupOperator {
+    OR = "OR",
+    AND = "AND"
+}
+export type IExtraConditionEq = {
+    operator: EComparisonOperator.EQ;
+    fields: string[];
+    value: string | number;
+    groupOperator?: EGroupOperator;
+};
+export type IExtraConditionIn = {
+    operator: EComparisonOperator.IN;
+    fields: string[];
+    values: Array<string | number>;
+    groupOperator?: EGroupOperator;
+};
+export type IExtraConditionLike = {
+    operator: EComparisonOperator.LIKE;
+    fields: string[];
+    value: string;
+    groupOperator?: EGroupOperator;
+};
+export type IExtraCondition = IExtraConditionEq | IExtraConditionIn | IExtraConditionLike;

package/dist/esm/core/gemxql/types/field-filters.d.ts

@@ -0,0 +1,18 @@
+export declare enum EFilterField {
+    DEVICE = "device",
+    DEVICES = "devices",
+    VISITOR = "visitor_type",
+    VISITORS = "visitor_types",
+    TRAFFIC_SOURCE = "traffic_source",
+    TRAFFIC_SOURCES = "traffic_sources",
+    VERSION = "version",
+    VERSIONS = "versions",
+    SINGLE_PAGE = "page_path",
+    LIST_PAGE = "page_paths",
+    GROUP_CAMPAIGN_ITEM = "group_campaign_item",
+    GROUP_CAMPAIGN_ITEMS = "group_campaign_items",
+    SINGLE_CAMPAIGN = "experiment_id",
+    GROUP_CAMPAIGN = "experiment_group_id",
+    CAMPAIGN_VERSION_ID = "version_id",
+    GROUP_CAMPAIGN_VERSION_ID = "group_version_id"
+}

package/dist/esm/core/gemxql/types/field-operators.d.ts

@@ -0,0 +1,8 @@
+export declare enum EOperatorField {
+    DEVICE_OPERATOR = "deviceOperator",
+    VISITOR_OPERATOR = "visitorOperator",
+    TRAFFIC_SOURCE_OPERATOR = "trafficSourceOperator",
+    VERSION_OPERATOR = "versionOperator",
+    PAGE_OPERATOR = "pageOperator",
+    CAMPAIGN_ITEM_OPERATOR = "campaignItemOperator"
+}

package/dist/esm/core/gemxql/types/filter-types.d.ts

@@ -0,0 +1,28 @@
+import type { EFilterField } from './field-filters';
+import type { EOperatorField } from './field-operators';
+export type GemXQlFilters = {
+    [EFilterField.DEVICE]?: string;
+    [EFilterField.VISITOR]?: string;
+    [EFilterField.TRAFFIC_SOURCE]?: string;
+    [EFilterField.VERSION]?: string;
+    [EFilterField.SINGLE_PAGE]?: string;
+    [EFilterField.GROUP_CAMPAIGN_ITEM]?: string;
+    [EFilterField.SINGLE_CAMPAIGN]?: string;
+    [EFilterField.CAMPAIGN_VERSION_ID]?: string;
+    [EFilterField.GROUP_CAMPAIGN_VERSION_ID]?: string;
+    [EFilterField.DEVICES]?: string[];
+    [EFilterField.VISITORS]?: string[];
+    [EFilterField.TRAFFIC_SOURCES]?: string[];
+    [EFilterField.VERSIONS]?: string[];
+    [EFilterField.LIST_PAGE]?: string[];
+    [EFilterField.GROUP_CAMPAIGN_ITEMS]?: string[];
+    [EFilterField.GROUP_CAMPAIGN]?: string[];
+    [EOperatorField.DEVICE_OPERATOR]?: string;
+    [EOperatorField.VISITOR_OPERATOR]?: string;
+    [EOperatorField.TRAFFIC_SOURCE_OPERATOR]?: string;
+    [EOperatorField.VERSION_OPERATOR]?: string;
+    [EOperatorField.PAGE_OPERATOR]?: string;
+    [EOperatorField.CAMPAIGN_ITEM_OPERATOR]?: string;
+};
+export type GemXQlOverrideFilters = GemXQlFilters;
+export type GemXQlVersionIds = Record<string, string | undefined>;

package/dist/esm/core/gemxql/types/group-with-clause.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Controls which totals columns are appended to the query result.
+ *
+ * - NONE   → no totals, GROUP BY only.
+ * - TOTALS → adds `<metric>___totals` (grand total only). Use with single-dimension GROUP BY.
+ * - ALL    → adds subtotals per dimension group + grand total. Use with multi-dimension GROUP BY.
+ */
+export declare enum EGroupWithClause {
+    NONE = "",
+    TOTALS = "TOTALS",
+    ALL = "WITH GROUP_TOTALS, TOTALS"
+}