@vizzly/services 0.15.0-dev-a9cfd8f38d3df28a319ca965d6e9d29e227fe3fe → 0.15.0-dev-89f22e757a24a3586c300b3ebb6b29827e8cc0e8

package/dist/types/shared-logic/src/Translations/translations.d.ts

@@ -0,0 +1,9 @@
+import { VizzlyTranslations } from './translation.types';
+import { TranslationOptions, TranslationInterpolation } from './types';
+export type VizzlyTranslationKey = keyof VizzlyTranslations;
+export declare function getTranslation(translations: Partial<VizzlyTranslations>, key: string): string | TranslationInterpolation | undefined;
+export declare const defaultText: (key: string, defaultValue: string, variables?: TranslationOptions, developerMode?: boolean) => string;
+export declare const generateTranslation: (key: string, defaultValue: string, variables?: TranslationOptions, translations?: Partial<VizzlyTranslations>, developerMode?: boolean) => string;
+export declare function buildTextOverrides(translations?: Partial<VizzlyTranslations>, developerMode?: boolean): {
+    textOverride: (key: string, value: string, options?: TranslationOptions) => string;
+};

package/dist/types/shared-logic/src/Translations/types.d.ts

@@ -0,0 +1,13 @@
+export type TextOverride = (key: string, defaultValue: string, options?: TranslationOptions) => string;
+export type TranslationOptions = {
+    [key: string]: string | number | Pluralised;
+};
+export type Pluralised = {
+    count: number;
+    singular: string;
+    plural: string;
+};
+export type TranslationInterpolation = {
+    sentence: string;
+    [key: string]: string;
+};

package/dist/types/shared-logic/src/Translations/validation.d.ts

@@ -0,0 +1 @@
+export declare const isValidFormattedText: (text: string) => boolean;

package/dist/types/shared-logic/src/Trends/linearForecasting.d.ts

@@ -0,0 +1,8 @@
+import { TimeSeriesResultSet } from '../Result/Result';
+import { SupportedTimeFunctions } from './types';
+export declare const LINEAR_FORECAST_KEY = "forecast_linear_avg";
+export declare const CURRENT_FORECAST_KEY = "current_linear_avg";
+export declare function linearForecast(data: TimeSeriesResultSet[], forecastUnits: number, key: string, timeUnit: SupportedTimeFunctions, includeForecast?: boolean): {
+    [x: string]: number | Date | undefined;
+    x: Date;
+}[];

package/dist/types/shared-logic/src/Trends/trends.d.ts

@@ -0,0 +1,26 @@
+import { PivotConfig } from '../PivotConfig/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { TimeSeriesResultSet } from '../Result';
+import { Component } from '../Component/types';
+export declare const init: ({ pivotConfig, measures, resultSet, trends, timeDimension, }: {
+    pivotConfig: PivotConfig;
+    measures: QueryAttributes.Measure[];
+    resultSet: TimeSeriesResultSet[];
+    trends?: Component.Trends[];
+    timeDimension: QueryAttributes.TimeDimension | null;
+}) => {
+    data: {
+        [x: string]: number | Date | undefined;
+        x: Date;
+    }[];
+    keys: string[];
+    colors: string[];
+    opacity: number[];
+    strokeWidth: number[];
+    strokeDasharray: number[];
+} | undefined;
+export declare function parseForecastKey(str: string): {
+    base: string;
+    trend?: string;
+};
+export declare const acceptedTimeDimensions: (timeDimension: QueryAttributes.TimeDimension | null) => boolean;

package/dist/types/shared-logic/src/Trends/trendsSchema.d.ts

@@ -0,0 +1,2 @@
+import Joi from '@vizzly/joi';
+export declare const trendsSchema: () => Joi.ArraySchema<any[]>;

package/dist/types/shared-logic/src/Trends/types.d.ts

@@ -0,0 +1,9 @@
+export declare enum TrendType {
+    Forecast = "Forecast",
+    MovingAverage = "Moving Average",
+    Trend = "Trend"
+}
+export type MovingAverage = {
+    value: number;
+};
+export type SupportedTimeFunctions = 'week' | 'quarter' | 'year' | 'month';

package/dist/types/shared-logic/src/ValueAlias/ValueAlias.d.ts

@@ -0,0 +1,7 @@
+import { AdditionalFilter } from '../AdditionalFilter/types';
+import { ValueAlias } from './types';
+export declare const build: (value: string | number | null, valueAlias?: ValueAlias, options?: {
+    fieldId?: string | null;
+    filter?: AdditionalFilter;
+    dataSetId?: string;
+}) => string | number | null | undefined;

package/dist/types/shared-logic/src/ValueAlias/types.d.ts

@@ -0,0 +1,10 @@
+import { Component } from '../Component/types';
+export type ValueAlias = {
+    [id: string]: string | number;
+} | ValueAliasFunction;
+export type ValueAliasFunction = (options?: Component.ValueAliasOptions) => string | number | undefined;
+export type ValueAliasFunctionV2 = (params: {
+    fieldId: string;
+    value: any;
+    function: string;
+}) => string | undefined;

package/dist/types/shared-logic/src/Variables/Variables.d.ts

@@ -0,0 +1,8 @@
+import { VariableList, VariablesCallback } from './types';
+export declare const defaultVariables: {};
+export declare const detect: (input: string) => string[] | undefined;
+export declare const build: (variables?: VariablesCallback) => VariableList;
+export declare const findVariable: (value: string, detect: (input: string) => string[] | undefined, variableList?: VariableList) => string[] | undefined;
+export declare const useValue: (value: any, variables?: VariableList) => any;
+export declare const validate: (value: string, variables?: VariableList) => boolean;
+export declare function extractValue(variables: VariableList, key: string): import("./types").VariableTypes;

package/dist/types/shared-logic/src/Variables/index.d.ts

@@ -0,0 +1 @@
+export * from './Variables';

package/dist/types/shared-logic/src/Variables/types.d.ts

@@ -0,0 +1,9 @@
+export type VariablesCallback = () => VariableList;
+export type VariableList = {
+    [key: string]: Variable;
+};
+export type Variable = {
+    value: VariableTypes;
+    description?: string;
+};
+export type VariableTypes = string | number | string[] | number[];

package/dist/types/shared-logic/src/ViewConfiguration/types.d.ts

@@ -0,0 +1,4 @@
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export type ViewConfiguration = {
+    queryEngineConfig: QueryEngineConfig;
+};

package/dist/types/shared-logic/src/VizzlyConfig/constants.d.ts

@@ -0,0 +1,18 @@
+import { DataType } from '../Field/types';
+import { Client } from './types';
+export declare const SUPPORTED_CLIENTS: Array<Client>;
+export declare const SUPPORTED_CLIENTS_WITH_JS: Array<Client | 'js'>;
+export declare const CLIENT_TO_TITLE: {
+    [key: string]: string;
+};
+export declare const NATIVE_DATA_TYPES: {
+    [client: string]: {
+        [dT: string]: string;
+    };
+};
+export declare const vizzlyToPossibleNativeDataTypes: (client: Client, dataType: DataType) => string[];
+export declare const ENVIRONMENT_VARIABLES_TO_REQUIRED: {
+    [client: string]: {
+        [key: string]: boolean;
+    };
+};

package/dist/types/shared-logic/src/VizzlyConfig/types.d.ts

@@ -0,0 +1 @@
+export type { Client } from '@vizzly/sqlbuilder-public';

package/dist/types/shared-logic/src/VizzlyState/index.d.ts

@@ -0,0 +1,68 @@
+import { AdditionalFilter, Field } from '../AdditionalFilter/types';
+import { SelectedDrilldown } from '../Drilldown/Drilldown';
+import { FeatureToggles } from '../FeatureToggle/types';
+import { VariableList } from '../Variables/types';
+import { AliasFields } from '../AliasFields/types';
+type UpdateFilterType = {
+    properties: Partial<Omit<AdditionalFilter, 'appliesToFields'>> & {
+        appliesToFields: Array<Field>;
+    };
+};
+export type StateOptions = {
+    addFilter?: {
+        properties: AdditionalFilter;
+    };
+    updateFilter?: UpdateFilterType;
+    updateFilters?: UpdateFilterType[];
+    removeFilter?: Array<Field>;
+    featureToggles?: Partial<FeatureToggles>;
+    variables?: VariableList;
+    aliasFields?: AliasFields;
+};
+export type Resizing = {
+    timeout?: number;
+} | boolean;
+export type Drilldown = SelectedDrilldown & {
+    viewId: string;
+};
+export type SubscriberOptions = StateOptions & {
+    reload?: boolean;
+    save?: boolean;
+    resizing?: Resizing;
+    variables?: VariableList;
+    drilldown?: Drilldown;
+    clearInMemoryDb?: boolean;
+};
+export type Subscriber = (data: SubscriberOptions) => void;
+export declare enum SavingState {
+    InProgress = "InProgress",
+    Saved = "Saved",
+    Undefined = "Undefined"
+}
+interface VizzlyState {
+    get: (identifier: string, listener: Subscriber) => () => void;
+    set: (identifier: string, data: StateOptions) => void;
+    reload: (identifier: string) => void;
+    inBrowserRefetchData: (identifier: string) => void;
+    save: (identifier: string) => void;
+    resizing: (identifier: string, resizing: boolean) => void;
+    drilldown: (identifier: string, params?: Drilldown) => void;
+}
+export declare class VizzlyStateManager implements VizzlyState {
+    private subscribers;
+    get(channel: string, listener: Subscriber): () => void;
+    set(channel: string, data: StateOptions): void;
+    reload(identifier: string): void;
+    inBrowserRefetchData(identifier: string): void;
+    save(identifier: string): void;
+    resizing(identifier: string, resizing: boolean, params?: {
+        timeout?: number;
+    }): void;
+    drilldown(identifier: string, params?: Drilldown): void;
+}
+/**
+ * @deprecated use `VizzlyState`
+ */
+export declare const vizzlyState: VizzlyStateManager;
+export declare const VizzlyState: VizzlyStateManager;
+export {};

package/dist/types/shared-logic/src/WaterfallChart/adjustTicks.d.ts

@@ -0,0 +1,3 @@
+import { WaterfallChartRepresentation } from './types';
+export declare const ASSUMED_AVERAGE_CHAR_WIDTH = 8.8;
+export declare const adjustTicks: (waterfallChartRepresentation: WaterfallChartRepresentation, width: number) => WaterfallChartRepresentation;

package/dist/types/shared-logic/src/WaterfallChart/attributesSchema.d.ts

@@ -0,0 +1,3 @@
+import Joi from '@vizzly/joi';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+export declare const attributesSchema: (config: ComponentInterfaceConfig) => Joi.ObjectSchema<any>;

package/dist/types/shared-logic/src/WaterfallChart/buildWaterfallChartRepresentation.d.ts

@@ -0,0 +1,38 @@
+import { Component, FormatType } from '../Component/types';
+import { PivotConfig } from '../PivotConfig/types';
+import { Result } from '../Result/types';
+import { ValueAlias } from '../ValueAlias/types';
+import { DateTimeFormatter, NumberFormatter, Step, WaterfallChartRepresentation } from './types';
+import { RulesField } from '../CustomField/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+export type WaterfallChartRepresentationArgs = {
+    approxYAxisLabelCount: number;
+    axisTitles?: Component.AxisTitles;
+    comparison: RulesField | null;
+    dateTimeFormatOptions: {
+        [id: string]: DateTimeFormatter;
+    };
+    defaultFormats: () => {
+        [functionId: string]: string;
+    };
+    measure: QueryAttributes.Measure[];
+    nullValue?: string;
+    numberFormatOptions: {
+        [id: string]: NumberFormatter;
+    };
+    pivotConfig: PivotConfig;
+    result: Result;
+    showTotalBar: boolean;
+    valueAlias?: ValueAlias;
+    xAxisFormat: FormatType;
+    xAxisPostfix: string;
+    xAxisPrefix: string;
+    yAxisFormat: FormatType;
+    yAxisPostfix: string;
+    yAxisPrefix: string;
+};
+export type WaterfallChartRepresentationResult = {
+    waterfallChartRepresentation: WaterfallChartRepresentation;
+    waterfallChartSteps: Step[];
+};
+export declare const buildWaterfallChartRepresentation: ({ approxYAxisLabelCount, axisTitles, comparison, dateTimeFormatOptions, defaultFormats, measure, nullValue, numberFormatOptions, pivotConfig, result, showTotalBar, valueAlias, xAxisFormat, xAxisPostfix, xAxisPrefix, yAxisFormat, yAxisPostfix, yAxisPrefix, }: WaterfallChartRepresentationArgs) => WaterfallChartRepresentationResult;

package/dist/types/shared-logic/src/WaterfallChart/constants.d.ts

@@ -0,0 +1,3 @@
+import { ViewConstants } from '../ComponentInterface/types/namespaces.types';
+declare const CONSTANTS: ViewConstants;
+export default CONSTANTS;

package/dist/types/shared-logic/src/WaterfallChart/getNiceInterval.d.ts

@@ -0,0 +1 @@
+export declare function getNiceInterval(interval: number): number;

package/dist/types/shared-logic/src/WaterfallChart/getRepresentationData.d.ts

@@ -0,0 +1,22 @@
+import { Tick } from '../ChartsV2/types';
+import { RulesField } from '../CustomField/types';
+import { FormattedChartData, Result } from '../Result/types';
+import { Data, Step } from './types';
+export type GetRepresentationDataArgs = {
+    content: FormattedChartData[][];
+    xKey: string;
+    yKey: string;
+    approxYAxisLabelCount: number;
+    showTotalBar: boolean;
+    formattingFunctionY: (value: any) => string;
+    comparison: RulesField | null;
+    metricField: Result.Field | undefined;
+};
+export declare const getRepresentationData: (args: GetRepresentationDataArgs) => {
+    data: Data[];
+    steps: Step[];
+    xTicks: Tick<string>[];
+    yTicks: Tick<number>[];
+    yMinValue: number;
+    yMaxValue: number;
+};

package/dist/types/shared-logic/src/WaterfallChart/getYTicks.d.ts

@@ -0,0 +1,8 @@
+import { Tick } from '../ChartsV2/types';
+export type GetYTicksArgs = {
+    yMinValue: number;
+    yMaxValue: number;
+    approxYAxisLabelCount: number;
+    formattingFunctionY: (value: any) => string;
+};
+export declare const getYTicks: ({ yMinValue, yMaxValue, approxYAxisLabelCount, formattingFunctionY, }: GetYTicksArgs) => Tick<number>[];

package/dist/types/shared-logic/src/WaterfallChart/index.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { LoadComponentInterface } from '../ComponentInterface/types';
+declare const WaterfallChart: LoadComponentInterface<Component.WaterfallChartAttributes, Component.WaterfallChartAttributes>;
+export default WaterfallChart;

package/dist/types/shared-logic/src/WaterfallChart/setAttributes.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+declare const _default: (config: ComponentInterfaceConfig) => (waterfallChart: Component.WaterfallChartAttributes, partial: Partial<Component.WaterfallChartAttributes>) => Component.WaterfallChartAttributes;
+export default _default;

package/dist/types/shared-logic/src/WaterfallChart/types.d.ts

@@ -0,0 +1,72 @@
+import { BaseChartRepresentation, Tick } from '../ChartsV2/types';
+import { DataType } from '../Field/types';
+export type KeyId = string;
+export type Operator = string;
+export type ConditionalFormattingRule = {
+    operator: Operator;
+    value: any;
+    color: string;
+    yKey: KeyId;
+};
+export type Axis<SupportedVizzlyDataTypes, AxisKeys> = {
+    ticks: Tick<SupportedVizzlyDataTypes>[];
+    scale: {
+        dataType: DataType;
+        key: KeyId | null;
+        ordering: 'asc' | 'desc' | null;
+        min: SupportedVizzlyDataTypes | null;
+        max: SupportedVizzlyDataTypes | null;
+    };
+    postfix: string;
+    prefix: string;
+    title: string | null;
+} & AxisKeys;
+export type Key = {
+    key: KeyId;
+    keyFormatted: string;
+    dataType: DataType;
+};
+export type DataItem = {
+    value: number | string | null;
+    formattedValue: string | null;
+};
+export type Data = {
+    [keyId: string]: DataItem;
+};
+export type Step = {
+    x: Date | string | number | null;
+    y: number;
+    start: number;
+    end: number;
+};
+export type DateTimeFormatter = {
+    formatter: (date: Date) => string;
+    description: string;
+};
+export type NumberFormatter = {
+    formatter: (number: number | undefined | null, noValueReplacement?: string) => string;
+    description: string;
+};
+export type WaterfallChartRepresentation = Omit<BaseChartRepresentation, 'y'> & {
+    y: Axis<number, {
+        key: KeyId;
+    }>;
+};
+export type WaterfallChartOptions = {
+    showTooltipRoundedTotal: boolean;
+    showLegend: boolean;
+    showLabels: boolean;
+    removeStroke: boolean;
+    axis: {
+        showXAxisLabels: boolean;
+        showYAxisLabels: boolean;
+    };
+};
+export type LegendItemStyle = {
+    type: 'bar';
+};
+export type LegendItem = {
+    yKey: KeyId;
+    color: string;
+    style: LegendItemStyle;
+};

package/dist/types/shared-logic/src/Webhook/Webhook.d.ts

@@ -0,0 +1,2 @@
+import { RawWebhook, Webhook } from './types';
+export declare const fromRaw: (rawWebhook: RawWebhook) => Webhook;

package/dist/types/shared-logic/src/Webhook/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Webhook';
+export * from './types';

package/dist/types/shared-logic/src/Webhook/types.d.ts

@@ -0,0 +1,25 @@
+export type Webhook = {
+    id: string;
+    name: string;
+    endpoint: string;
+    organisationId: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    project_id: string;
+};
+export type RawWebhook = {
+    id: string;
+    name: string;
+    endpoint: string;
+    organisation_id: string;
+    active: boolean;
+    created_at: string;
+    updated_at: string;
+    project_id: string;
+};
+export type WebhookHealthSummary = {
+    [webhookId: string]: {
+        [httpStatus: string]: number;
+    };
+};

package/dist/types/shared-logic/src/api/httpClient.d.ts

@@ -0,0 +1,7 @@
+import { ApiConfig } from '../ApiConfig';
+import { Request } from './types';
+export declare const httpClient: (config: ApiConfig) => <T>(request: Request<any>) => Promise<{
+    status: number;
+    body: T;
+    headers: Headers | null;
+}>;

package/dist/types/shared-logic/src/api/index.d.ts

@@ -0,0 +1,46 @@
+import { ApiConfig } from '../ApiConfig';
+/** @deprecated Use vizzly/api-client package instead */
+export declare const api: (config: ApiConfig) => {
+    /** @deprecated Use vizzly/api-client package instead */
+    config: ApiConfig;
+    /** @deprecated Use vizzly/api-client package instead */
+    getParentDashboards: () => Promise<{
+        id: string;
+        created_at: string;
+        updated_at: string;
+        webhook_id: string | null;
+    }[] | undefined>;
+    /** @deprecated Use vizzly/api-client package instead */
+    saveScheduledReport: (params: {
+        dashboardAccessToken: string;
+        scheduledReportId: string;
+        cronSchedule: string | null;
+    }) => Promise<boolean>;
+    /** @deprecated Use vizzly/api-client package instead */
+    askAi: (conversationId: string | undefined, currentAttributes: import("../../../shared-logic/src/Component/types").Component.Attributes, question: string, dashboardAccessToken: string, dataSets: import("../DataSet/types").DataSet[], queryEngineConfig: import("../QueryEngineConfig/types").QueryEngineConfig, abortSignal: AbortSignal) => Promise<import("./vizzly/aiHelpers/types").AiConversation>;
+    /** @deprecated Use vizzly/api-client package instead */
+    aiActions: (conversationId: string, messageId: string, dashboardAccessToken: string, options: import("./vizzly/aiActions").AIOptions) => Promise<import("./vizzly/aiActions").AIActionReponse>;
+    /** @deprecated Use vizzly/api-client package instead */
+    askAiForQuestionSuggestions: (dashboardAccessToken: string, dataSets: import("../DataSet/types").DataSet[]) => Promise<import("./vizzly/aiHelpers/types").AskAiQuestionSuggestions>;
+    /** @deprecated Use vizzly/api-client package instead */
+    createVizzlyConfigVersion: (projectId: string, encryptedVizzlyConfig: string) => Promise<boolean>;
+    /** @deprecated Use vizzly/api-client package instead */
+    createProjectApiKey: (projectId: string) => Promise<string>;
+    /** @deprecated Use vizzly/api-client package instead */
+    updateProjectApiKey: (projectId: string, projectApiKeyId: string, updateParams: {
+        disabled: boolean;
+    }) => Promise<string>;
+    /** @deprecated Use vizzly/api-client package instead */
+    getProjectAccessToken: (projectId: string, appSessionAuthToken?: string, resourceFilters?: string[]) => Promise<string | undefined>;
+    /** @deprecated Use vizzly/api-client package instead */
+    createSelfHostedQueryEngineProject: (appSessionToken?: string) => Promise<import("../Project/types").Project | undefined>;
+    /** @deprecated Use vizzly/api-client package instead */
+    createSelfHostedDynamicQueryEngineProject: (appSessionToken?: string) => Promise<import("../Project/types").Project | undefined>;
+    /** @deprecated Use vizzly/api-client package instead */
+    createSelfHostedInBrowserQueryEngineProject: (appSessionToken?: string) => Promise<import("../Project/types").Project | undefined>;
+    /** @deprecated Use vizzly/api-client package instead */
+    getManagedQueryEngineKeyPair: (managedProjectId: string, keyPairId: string, appSessionToken?: string) => Promise<{
+        publicKey: string;
+        privateKey: string | null;
+    } | undefined>;
+};

package/dist/types/shared-logic/src/api/queryEngine/createConfigFromUpload.d.ts

@@ -0,0 +1,2 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const createConfigFromUpload: (queryEngineEndpoint: QueryEngineEndpoint, queryEngineAccessToken: string, table: string, _configStoreId: string, fieldPublicNames: Array<string>) => Promise<boolean>;

package/dist/types/shared-logic/src/api/queryEngine/createResults.d.ts

@@ -0,0 +1,10 @@
+import { PreparedQuery, Query } from '../../Query/types';
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+type CreateResultsResponse = {
+    results: {
+        content: any[][];
+        hasMoreResults: boolean | null;
+    }[];
+};
+export declare const createResults: (queries: (Query | PreparedQuery)[], queryEngineEndpoint: QueryEngineEndpoint, dataAccessToken?: string, abortSignal?: AbortSignal) => Promise<CreateResultsResponse | null>;
+export {};

package/dist/types/shared-logic/src/api/queryEngine/createSqlPreview.d.ts

@@ -0,0 +1,5 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+import { Result } from '../../Result/types';
+export declare const createSqlPreview: (queryEngineEndpoint: QueryEngineEndpoint, sql: string, parameters: string | undefined, limit: number, connectionId: string | undefined, dataSets: any[] | undefined, abortSignal?: AbortSignal) => Promise<Result & {
+    statement: string;
+}>;

package/dist/types/shared-logic/src/api/queryEngine/createUser.d.ts

@@ -0,0 +1,2 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const createUser: (queryEngineEndpoint: QueryEngineEndpoint, email: string, password: string, abortSignal?: AbortSignal) => Promise<boolean>;

package/dist/types/shared-logic/src/api/queryEngine/fetchDataSets.d.ts

@@ -0,0 +1,4 @@
+import { DataSet } from '../../DataSet/types';
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+declare const _default: (queryEngineEndpoint: QueryEngineEndpoint, accessToken: string, abortSignal?: AbortSignal) => Promise<DataSet[]>;
+export default _default;

package/dist/types/shared-logic/src/api/queryEngine/fetchSelfHostedQueryEngineConfig.d.ts

@@ -0,0 +1,3 @@
+import { QueryEngineConfig, QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+declare const fetchSelHostedQueryEngineConfig: (queryEngineEndpoint: QueryEngineEndpoint) => Promise<QueryEngineConfig | null>;
+export default fetchSelHostedQueryEngineConfig;

package/dist/types/shared-logic/src/api/queryEngine/getProject.d.ts

@@ -0,0 +1,3 @@
+import { Project } from '../../Project/types';
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const getProject: (queryEngineEndpoint: QueryEngineEndpoint, abortSignal?: AbortSignal) => Promise<Project | null>;

package/dist/types/shared-logic/src/api/queryEngine/getRunQueriesCallback.d.ts

@@ -0,0 +1,21 @@
+import { AdditionalFilter, FilterConfig, TimeRangeOptions } from '../../AdditionalFilter/types';
+import { CustomDriver } from 'results-driver/src/types';
+import { loadDataCallback } from '../../Callbacks/types';
+import { QueryEngineConfig as QueryEngineConfigType, QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+import { Component } from '../../Component/types';
+import { QueryAttributes } from '../../QueryAttributes/types';
+import { PreparedQuery } from '../../Query/types';
+import { Result } from '../../Result/types';
+import { DataSet } from '../../DataSet/types';
+import { IdentityConfig as IdentityConfigType } from '../../IdentityConfig/types';
+import { VariableList } from '../../Variables/types';
+import { AliasFields } from '../../AliasFields/types';
+type CallbackError = null;
+export type runQueriesCallback = (queries: Component.Attributes | AdditionalFilter | QueryAttributes[] | [PreparedQuery], params: {
+    dataSets: DataSet[];
+    abortSignal?: AbortSignal;
+    dataAccessToken?: string;
+    filterConfig?: FilterConfig;
+}) => Promise<(Result | null)[] | Array<Result['content'] | null> | CallbackError>;
+declare const getRunQueriesCallback: (identityConfig: IdentityConfigType, queryEngineConfig: QueryEngineConfigType, timeRangeOptions: TimeRangeOptions, variables: VariableList, aliasFields: AliasFields, runQueries?: CustomDriver["runQueries"], data?: loadDataCallback, queryEngineEndpoint?: QueryEngineEndpoint, timeZone?: string) => runQueriesCallback;
+export default getRunQueriesCallback;

package/dist/types/shared-logic/src/api/queryEngine/getStarted.d.ts

@@ -0,0 +1,2 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const getStarted: (queryEngineEndpoint: QueryEngineEndpoint, email: string, password: string, abortSignal?: AbortSignal) => Promise<boolean>;

package/dist/types/shared-logic/src/api/queryEngine/getTeamMembers.d.ts

@@ -0,0 +1,3 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+import { TeamMemberFromAPI } from '@vizzly/api-client';
+export declare const getTeamMembers: (queryEngineEndpoint: QueryEngineEndpoint, abortSignal?: AbortSignal) => Promise<Array<TeamMemberFromAPI> | undefined>;

package/dist/types/shared-logic/src/api/queryEngine/isVizzly.d.ts

@@ -0,0 +1,3 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+declare const _default: (queryEngineEndpoint: QueryEngineEndpoint) => Promise<boolean>;
+export default _default;

package/dist/types/shared-logic/src/api/queryEngine/queryEngineHttpClient.d.ts

@@ -0,0 +1,3 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+import { HttpClient } from '../types';
+export declare const queryEngineHttpClient: <T>(queryEngineEndpoint: QueryEngineEndpoint) => HttpClient;

package/dist/types/shared-logic/src/api/queryEngine/saveConfig.d.ts

@@ -0,0 +1,2 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const saveConfig: <R>(queryEngineEndpoint: QueryEngineEndpoint, config: any, abortSignal?: AbortSignal) => Promise<R | null>;

package/dist/types/shared-logic/src/api/queryEngine/saveConnection.d.ts

@@ -0,0 +1,7 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+import { Client } from '../../VizzlyConfig/types';
+type Response = {} | {
+    reason: string;
+};
+export declare const saveConnection: (queryEngineEndpoint: QueryEngineEndpoint, integrationClient: Client, connection: any, connectionId: string, abortSignal?: AbortSignal) => Promise<Response | null>;
+export {};

package/dist/types/shared-logic/src/api/queryEngine/signIn.d.ts

@@ -0,0 +1,8 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const signIn: (queryEngineEndpoint: QueryEngineEndpoint, queryEngineAccessToken: string, abortSignal?: AbortSignal) => Promise<boolean>;
+export declare const signInWithEmailAndPassword: (queryEngineEndpoint: QueryEngineEndpoint, email: string, password: string, abortSignal?: AbortSignal) => Promise<{
+    success: true;
+} | {
+    success: false;
+    message: string;
+}>;

package/dist/types/shared-logic/src/api/queryEngine/status.d.ts

@@ -0,0 +1,3 @@
+import { QueryEngineDescription } from '../../QueryEngine/types';
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const status: (queryEngineEndpoint: QueryEngineEndpoint, abortSignal?: AbortSignal) => Promise<QueryEngineDescription | null>;

package/dist/types/shared-logic/src/api/queryEngine/updateUser.d.ts

@@ -0,0 +1,2 @@
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const updateUser: (queryEngineEndpoint: QueryEngineEndpoint, queryEngineUserId: string, password: string, abortSignal?: AbortSignal) => Promise<boolean>;

package/dist/types/shared-logic/src/api/queryEngine/uploadDataToVizzlyCloud.d.ts

@@ -0,0 +1,3 @@
+import { Ingest } from '../../DataIngest/types';
+import { QueryEngineEndpoint } from '../../QueryEngineConfig/types';
+export declare const uploadDataToVizzlyCloud: (queryEngineEndpoint: QueryEngineEndpoint, queryEngineAccessToken: string, ingest: Ingest) => Promise<number>;