@lightdash/common 0.1464.3 → 0.1466.0

package/dist/ee/Ai/schemas.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiFindFieldsToolSchema = exports.aiSummarySchema = exports.aiAskForAdditionalInformationSchema = exports.lighterMetricQuerySchema = exports.SortFieldSchema = exports.GenerateQueryFiltersToolSchema = exports.FilterSchema = exports.FilterGroupSchema = exports.FieldIdSchema = void 0;
+const zod_1 = require("zod");
+const conditionalRule_1 = require("../../types/conditionalRule");
+const filter_1 = require("../../types/filter");
+// TODO: most of the things should live in common and some of the existing types should be inferred from here
+// we can't reuse them because there's a bug with TSOA+ZOD - we can't use zod types in TSOA controllers
+exports.FieldIdSchema = zod_1.z
+    .string()
+    .min(1)
+    .describe(`Field ID is a unique identifier of a Metric or a Dimension within a project
+ID consists of the table name and field name separated by an underscore.
+@example: orders_status, customers_first_name, orders_total_order_amount, etc.`);
+// All the operators that can be applied to a filter, now we have a validator
+const FilterOperatorSchema = zod_1.z
+    .union([
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.NULL),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.NOT_NULL),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.EQUALS),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.NOT_EQUALS),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.STARTS_WITH),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.ENDS_WITH),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.INCLUDE),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.NOT_INCLUDE),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.LESS_THAN),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.LESS_THAN_OR_EQUAL),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.GREATER_THAN),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.GREATER_THAN_OR_EQUAL),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.IN_BETWEEN),
+])
+    .describe('Filter operators that can be applied to a filter');
+const DateFilterOperatorSchemaReqUnitOfTime = zod_1.z
+    .union([
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.IN_THE_PAST),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.NOT_IN_THE_PAST),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.IN_THE_NEXT),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.IN_THE_CURRENT),
+    zod_1.z.literal(conditionalRule_1.ConditionalOperator.NOT_IN_THE_CURRENT),
+])
+    .describe('Operators that require a unit of time to be applied on the filter');
+const FilterRuleSchemaBase = zod_1.z
+    .object({
+    id: zod_1.z.string().describe('A unique identifier for the filter'),
+    target: zod_1.z
+        .object({
+        fieldId: exports.FieldIdSchema,
+    })
+        .describe('Target field to apply the filter'),
+    operator: FilterOperatorSchema.describe('Filter operator to apply to the target field'),
+    values: zod_1.z
+        .array(zod_1.z.unknown())
+        .describe('Values to apply to the target field using the operator'),
+})
+    .describe('Base filter rule schema');
+const UnitOfTimeFilterRuleSchema = FilterRuleSchemaBase.merge(zod_1.z.object({
+    operator: DateFilterOperatorSchemaReqUnitOfTime.describe('The operator to apply the filter'),
+    settings: zod_1.z.object({
+        completed: zod_1.z
+            .boolean()
+            .describe("e.g. if it's a completed month or not"),
+        unitOfTime: zod_1.z
+            .nativeEnum(filter_1.UnitOfTime)
+            .describe('the unit of time to apply on the filter, e.g. month, year, etc'),
+    }),
+})).describe('Specific filter rule schema for filter operators that require unit of time');
+const FilterRuleSchema = zod_1.z.union([
+    FilterRuleSchemaBase,
+    UnitOfTimeFilterRuleSchema,
+]);
+const AndFilterGroupSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('A unique identifier for the filter group'),
+    and: zod_1.z
+        .array(FilterRuleSchema)
+        .describe('List of filters to apply to the query. Filters in AND groups can target both metrics and dimensions'),
+});
+const OrFilterGroupSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('A unique identifier for the filter group'),
+    or: zod_1.z
+        .array(FilterRuleSchema)
+        .describe('List of filters to apply to the query. Filters in OR groups need to target either only metrics or only dimensions'),
+});
+exports.FilterGroupSchema = zod_1.z.union([
+    AndFilterGroupSchema,
+    OrFilterGroupSchema,
+]);
+exports.FilterSchema = zod_1.z.object({
+    dimensions: exports.FilterGroupSchema.optional(),
+    metrics: exports.FilterGroupSchema.optional(),
+});
+exports.GenerateQueryFiltersToolSchema = zod_1.z.object({
+    exploreName: zod_1.z.string().describe('Name of the selected explore'),
+    filterGroup: exports.FilterGroupSchema.describe('Filters to apply to the query. Filtered fields must exist in the selected explore.'),
+});
+exports.SortFieldSchema = zod_1.z.object({
+    fieldId: exports.FieldIdSchema.describe('"fieldId" must come from the selected Metrics or Dimensions; otherwise, it will throw an error.'),
+    descending: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('(optional, default true). If true sorts in descending order, if false sorts in ascending order'),
+});
+// export const CompactOrAliasSchema = z
+//     .nativeEnum(Compact)
+//     .or(z.enum(CompactAlias));
+// export const CustomFormatSchema = z.object({
+//     type: z.nativeEnum(CustomFormatType).describe('Type of custom format'),
+//     round: z
+//         .number()
+//         .optional()
+//         .describe('Number of decimal places to round to'),
+//     separator: z
+//         .nativeEnum(NumberSeparator)
+//         .optional()
+//         .describe('Separator for thousands'),
+//     // TODO: this should be enum but currencies is loosely typed
+//     currency: z.string().optional().describe('Three-letter currency code'),
+//     compact: CompactOrAliasSchema.optional().describe('Compact number format'),
+//     prefix: z.string().optional().describe('Prefix to add to the number'),
+//     suffix: z.string().optional().describe('Suffix to add to the number'),
+// });
+// export const TableCalculationSchema = z.object({
+//   // TODO: I don't know what this is
+//   index: z.number().optional().describe('Index of the table calculation'),
+//   name: z.string().min(1).describe('Name of the table calculation'),
+//   displayName: z
+//       .string()
+//       .min(1)
+//       .describe('Display name of the table calculation'),
+//   sql: z.string().min(1).describe('SQL for the table calculation'),
+//   format: CustomFormatSchema.optional().describe(
+//       'Format of the table calculation',
+//   ),
+// });
+// TODO: fix me to be a complete schema and infer types from here.
+exports.lighterMetricQuerySchema = zod_1.z.object({
+    exploreName: zod_1.z
+        .string()
+        .describe('Name of the explore to query. @example: "users"'),
+    metrics: zod_1.z
+        .array(exports.FieldIdSchema)
+        .describe('Metrics (measures) to calculate over the table for this query. @example: ["payments_total_amount", "orders_total_shipping_cost"]'),
+    dimensions: zod_1.z
+        .array(exports.FieldIdSchema)
+        .describe('Dimensions to break down the metric into groups. @example: ["orders_status", "customers_first_name"]'),
+    filters: exports.FilterSchema.describe('Filters to apply to the query'),
+    sorts: zod_1.z
+        .array(exports.SortFieldSchema)
+        .describe('Sort configuration for the MetricQuery. Should be an empty array if no sorting is needed'),
+    limit: zod_1.z
+        .number()
+        .int()
+        .min(1)
+        .describe('Maximum number of rows to return from query'),
+    // tableCalculations: z
+    //     .array(TableCalculationSchema)
+    //     .describe(
+    //         'Calculations are freeform SQL expressions that can be used to create new columns in the result set',
+    //     ),
+    // TODO: at some point we should have a schema for additionalMetrics too but it's not needed for now
+    // additionalMetrics: z
+    //     .array(z.unknown())
+    //     .max(0)
+    //     .optional()
+    //     .describe(
+    //         'Additional metrics to compute in the explore - not supported yet',
+    //     ),
+    // TODO: at some point we should have a schema for customDimensions too but it's not needed for now
+    // customDimensions: z
+    //     .array(z.unknown())
+    //     .max(0)
+    //     .optional()
+    //     .describe('Custom dimensions to group by in the explore'),
+    // metadata: z
+    //     .object({
+    //         // TODO: zod pick type from CompiledDimension
+    //         hasADateDimension: z.object({
+    //             label: z.string().describe('Label of the date dimension'),
+    //             name: z.string().describe('Name of the date dimension'),
+    //         }),
+    //     })
+    //     .optional()
+    //     .describe('Metadata about the query'),
+});
+exports.aiAskForAdditionalInformationSchema = zod_1.z.object({
+    message: zod_1.z
+        .string()
+        .describe('The message to ask for additional information to the user'),
+});
+exports.aiSummarySchema = zod_1.z.object({
+    message: zod_1.z.string().describe('Summary message for the user'),
+});
+exports.aiFindFieldsToolSchema = zod_1.z.object({
+    exploreName: zod_1.z.string().describe('Name of the selected explore'),
+    embeddingSearchQueries: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string().describe('field_id of the field.'),
+        description: zod_1.z.string(),
+    }))
+        .describe(`Break down user input sentence into field names and descriptions to find the most relevant fields in the explore.`),
+});

package/dist/ee/Ai/types.d.ts

@@ -0,0 +1,136 @@
+import type { AnyType } from '../../types/any';
+export type AiThread = {
+    aiThreadUuid: string;
+    organizationUuid: string;
+    projectUuid: string;
+    createdAt: Date;
+    createdFrom: string;
+};
+export type CreateSlackThread = {
+    organizationUuid: string;
+    projectUuid: string;
+    createdFrom: 'slack' | 'web_app';
+    slackUserId: string;
+    slackChannelId: string;
+    slackThreadTs: string;
+};
+export type CreateWebAppThread = {
+    organizationUuid: string;
+    projectUuid: string;
+    userUuid: string;
+    createdFrom: 'web_app';
+};
+export type AiPrompt = {
+    organizationUuid: string;
+    projectUuid: string;
+    promptUuid: string;
+    threadUuid: string;
+    createdByUserUuid: string;
+    prompt: string;
+    createdAt: Date;
+    response: string;
+    filtersOutput: object | null;
+    vizConfigOutput: object | null;
+    humanScore: number | null;
+    metricQuery: object | null;
+};
+export type SlackPrompt = AiPrompt & {
+    response_slack_ts: string;
+    slackUserId: string;
+    slackChannelId: string;
+    promptSlackTs: string;
+    slackThreadTs: string;
+};
+export type AiWebAppPrompt = AiPrompt & {
+    userUuid: string;
+};
+export declare const isSlackPrompt: (prompt: AiPrompt) => prompt is SlackPrompt;
+export type CreateSlackPrompt = {
+    threadUuid: string;
+    createdByUserUuid: string;
+    prompt: string;
+    slackUserId: string;
+    slackChannelId: string;
+    promptSlackTs: string;
+};
+export type CreateWebAppPrompt = {
+    threadUuid: string;
+    createdByUserUuid: string;
+    prompt: string;
+};
+export type UpdateSlackResponse = {
+    promptUuid: string;
+    response?: string;
+    filtersOutput?: object | null;
+    vizConfigOutput?: object | null;
+    humanScore?: number | null;
+    metricQuery?: object | null;
+};
+export type UpdateWebAppResponse = {
+    promptUuid: string;
+    response: string;
+    filtersOutput?: object | null;
+    vizConfigOutput?: object | null;
+    humanScore?: number | null;
+    metricQuery?: object | null;
+};
+export type UpdateSlackResponseTs = {
+    promptUuid: string;
+    responseSlackTs: string;
+};
+export type SlackPromptJobPayload = {
+    slackPromptUuid: string;
+};
+export declare enum AiChatAgents {
+    HUMAN = "human",
+    AI = "ai"
+}
+export type AiChatMessage = {
+    agent: AiChatAgents;
+    message: string;
+};
+export type AiConversation = {
+    threadUuid: string;
+    createdAt: string | Date;
+    createdFrom: string;
+    firstMessage: string;
+    user: {
+        uuid: string;
+        name: string;
+    };
+};
+export type ApiAiConversations = {
+    status: 'ok';
+    results: AiConversation[];
+};
+type AiConversationMessageIncomplete = {
+    promptUuid: string;
+    message: string;
+    createdAt: string | Date;
+    user: {
+        uuid: string;
+        name: string;
+    };
+};
+type AiConversationComplete = AiConversationMessageIncomplete & {
+    response: string;
+    respondedAt: string | Date;
+    vizConfigOutput?: object;
+    filtersOutput?: object;
+    metricQuery?: object;
+    humanScore?: number;
+};
+export type AiConversationMessage = AiConversationMessageIncomplete | AiConversationComplete;
+export type ApiAiConversationMessages = {
+    status: 'ok';
+    results: AiConversationMessage[];
+};
+export type ApiAiConversationResponse = {
+    status: 'ok';
+    results: {
+        prompt: AiWebAppPrompt;
+        rows: Record<string, AnyType>[] | undefined;
+    };
+};
+export declare const isAiConversationMessageComplete: (message: AiConversationMessage) => message is AiConversationComplete;
+export {};

package/dist/ee/Ai/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAiConversationMessageComplete = exports.AiChatAgents = exports.isSlackPrompt = void 0;
+const isSlackPrompt = (prompt) => 'slackUserId' in prompt;
+exports.isSlackPrompt = isSlackPrompt;
+var AiChatAgents;
+(function (AiChatAgents) {
+    AiChatAgents["HUMAN"] = "human";
+    AiChatAgents["AI"] = "ai";
+})(AiChatAgents = exports.AiChatAgents || (exports.AiChatAgents = {}));
+const isAiConversationMessageComplete = (message) => 'response' in message && 'respondedAt' in message;
+exports.isAiConversationMessageComplete = isAiConversationMessageComplete;

package/dist/ee/commercialFeatureFlags.d.ts

@@ -0,0 +1,5 @@
+export declare enum CommercialFeatureFlags {
+    Embedding = "embedding",
+    Scim = "scim-token-management",
+    AiCopilot = "ai-copilot"
+}

package/dist/ee/commercialFeatureFlags.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommercialFeatureFlags = void 0;
+var CommercialFeatureFlags;
+(function (CommercialFeatureFlags) {
+    CommercialFeatureFlags["Embedding"] = "embedding";
+    CommercialFeatureFlags["Scim"] = "scim-token-management";
+    CommercialFeatureFlags["AiCopilot"] = "ai-copilot";
+})(CommercialFeatureFlags = exports.CommercialFeatureFlags || (exports.CommercialFeatureFlags = {}));

package/dist/ee/embed/index.d.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import { type LightdashUser } from '../../types/user';
+export type Embed = {
+    projectUuid: string;
+    encodedSecret: string;
+    dashboardUuids: string[];
+    createdAt: string;
+    user: Pick<LightdashUser, 'userUuid' | 'firstName' | 'lastName'>;
+};
+export type DecodedEmbed = Omit<Embed, 'encodedSecret'> & {
+    encodedSecret: undefined;
+    secret: string;
+};
+export type CreateEmbed = {
+    dashboardUuids: string[];
+};
+export declare enum FilterInteractivityValues {
+    some = "some",
+    all = "all",
+    none = "none"
+}
+export declare const FilterInteractivityValuesSchema: z.ZodEnum<[FilterInteractivityValues.some, FilterInteractivityValues.all, FilterInteractivityValues.none]>;
+export declare const DashboardFilterInteractivityOptionsSchema: z.ZodObject<{
+    enabled: z.ZodUnion<[z.ZodBoolean, z.ZodEnum<[FilterInteractivityValues.some, FilterInteractivityValues.all, FilterInteractivityValues.none]>]>;
+    allowedFilters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean | FilterInteractivityValues;
+    allowedFilters?: string[] | undefined;
+}, {
+    enabled: boolean | FilterInteractivityValues;
+    allowedFilters?: string[] | undefined;
+}>;
+export type DashboardFilterInteractivityOptions = z.infer<typeof DashboardFilterInteractivityOptionsSchema>;
+export declare const InteractivityOptionsSchema: z.ZodObject<{
+    dashboardFiltersInteractivity: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodUnion<[z.ZodBoolean, z.ZodEnum<[FilterInteractivityValues.some, FilterInteractivityValues.all, FilterInteractivityValues.none]>]>;
+        allowedFilters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean | FilterInteractivityValues;
+        allowedFilters?: string[] | undefined;
+    }, {
+        enabled: boolean | FilterInteractivityValues;
+        allowedFilters?: string[] | undefined;
+    }>>;
+    canExportCsv: z.ZodOptional<z.ZodBoolean>;
+    canExportImages: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    dashboardFiltersInteractivity?: {
+        enabled: boolean | FilterInteractivityValues;
+        allowedFilters?: string[] | undefined;
+    } | undefined;
+    canExportCsv?: boolean | undefined;
+    canExportImages?: boolean | undefined;
+}, {
+    dashboardFiltersInteractivity?: {
+        enabled: boolean | FilterInteractivityValues;
+        allowedFilters?: string[] | undefined;
+    } | undefined;
+    canExportCsv?: boolean | undefined;
+    canExportImages?: boolean | undefined;
+}>;
+export type InteractivityOptions = z.infer<typeof InteractivityOptionsSchema>;
+export declare const EmbedJwtSchema: z.ZodObject<{
+    userAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    user: z.ZodOptional<z.ZodObject<{
+        externalId: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        email?: string | undefined;
+        externalId?: string | undefined;
+    }, {
+        email?: string | undefined;
+        externalId?: string | undefined;
+    }>>;
+    content: z.ZodObject<z.objectUtil.extendShape<{
+        type: z.ZodLiteral<"dashboard">;
+        dashboardUuid: z.ZodString;
+        isPreview: z.ZodOptional<z.ZodBoolean>;
+    }, {
+        dashboardFiltersInteractivity: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodUnion<[z.ZodBoolean, z.ZodEnum<[FilterInteractivityValues.some, FilterInteractivityValues.all, FilterInteractivityValues.none]>]>;
+            allowedFilters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean | FilterInteractivityValues;
+            allowedFilters?: string[] | undefined;
+        }, {
+            enabled: boolean | FilterInteractivityValues;
+            allowedFilters?: string[] | undefined;
+        }>>;
+        canExportCsv: z.ZodOptional<z.ZodBoolean>;
+        canExportImages: z.ZodOptional<z.ZodBoolean>;
+    }>, "strip", z.ZodTypeAny, {
+        type: "dashboard";
+        dashboardUuid: string;
+        dashboardFiltersInteractivity?: {
+            enabled: boolean | FilterInteractivityValues;
+            allowedFilters?: string[] | undefined;
+        } | undefined;
+        canExportCsv?: boolean | undefined;
+        canExportImages?: boolean | undefined;
+        isPreview?: boolean | undefined;
+    }, {
+        type: "dashboard";
+        dashboardUuid: string;
+        dashboardFiltersInteractivity?: {
+            enabled: boolean | FilterInteractivityValues;
+            allowedFilters?: string[] | undefined;
+        } | undefined;
+        canExportCsv?: boolean | undefined;
+        canExportImages?: boolean | undefined;
+        isPreview?: boolean | undefined;
+    }>;
+    iat: z.ZodOptional<z.ZodNumber>;
+    exp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "dashboard";
+        dashboardUuid: string;
+        dashboardFiltersInteractivity?: {
+            enabled: boolean | FilterInteractivityValues;
+            allowedFilters?: string[] | undefined;
+        } | undefined;
+        canExportCsv?: boolean | undefined;
+        canExportImages?: boolean | undefined;
+        isPreview?: boolean | undefined;
+    };
+    exp: number;
+    user?: {
+        email?: string | undefined;
+        externalId?: string | undefined;
+    } | undefined;
+    userAttributes?: Record<string, unknown> | undefined;
+    iat?: number | undefined;
+}, {
+    content: {
+        type: "dashboard";
+        dashboardUuid: string;
+        dashboardFiltersInteractivity?: {
+            enabled: boolean | FilterInteractivityValues;
+            allowedFilters?: string[] | undefined;
+        } | undefined;
+        canExportCsv?: boolean | undefined;
+        canExportImages?: boolean | undefined;
+        isPreview?: boolean | undefined;
+    };
+    exp: number;
+    user?: {
+        email?: string | undefined;
+        externalId?: string | undefined;
+    } | undefined;
+    userAttributes?: Record<string, unknown> | undefined;
+    iat?: number | undefined;
+}>;
+export type EmbedJwt = z.infer<typeof EmbedJwtSchema>;
+export type CreateEmbedJwt = {
+    content: {
+        type: 'dashboard';
+        dashboardUuid: string;
+        isPreview?: boolean;
+        dashboardFiltersInteractivity?: {
+            enabled: FilterInteractivityValues | boolean;
+            allowedFilters?: string[];
+        };
+        canExportCsv?: boolean;
+        canExportImages?: boolean;
+    };
+    userAttributes?: {
+        [key: string]: string;
+    };
+    user?: {
+        email?: string;
+        externalId?: string;
+    };
+    expiresIn?: string;
+};
+export type EmbedUrl = {
+    url: string;
+};
+export declare function getFilterInteractivityValue(enabled: DashboardFilterInteractivityOptions['enabled']): FilterInteractivityValues;
+export declare function isFilterInteractivityEnabled(filterInteractivityOptions?: DashboardFilterInteractivityOptions): boolean | undefined;

package/dist/ee/embed/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFilterInteractivityEnabled = exports.getFilterInteractivityValue = exports.EmbedJwtSchema = exports.InteractivityOptionsSchema = exports.DashboardFilterInteractivityOptionsSchema = exports.FilterInteractivityValuesSchema = exports.FilterInteractivityValues = void 0;
+const tslib_1 = require("tslib");
+const zod_1 = require("zod");
+const assertUnreachable_1 = tslib_1.__importDefault(require("../../utils/assertUnreachable"));
+var FilterInteractivityValues;
+(function (FilterInteractivityValues) {
+    FilterInteractivityValues["some"] = "some";
+    FilterInteractivityValues["all"] = "all";
+    FilterInteractivityValues["none"] = "none";
+})(FilterInteractivityValues = exports.FilterInteractivityValues || (exports.FilterInteractivityValues = {}));
+exports.FilterInteractivityValuesSchema = zod_1.z.enum([
+    FilterInteractivityValues.some,
+    FilterInteractivityValues.all,
+    FilterInteractivityValues.none,
+]);
+exports.DashboardFilterInteractivityOptionsSchema = zod_1.z.object({
+    enabled: zod_1.z.union([zod_1.z.boolean(), exports.FilterInteractivityValuesSchema]),
+    allowedFilters: zod_1.z.array(zod_1.z.string()).optional(),
+});
+exports.InteractivityOptionsSchema = zod_1.z.object({
+    dashboardFiltersInteractivity: exports.DashboardFilterInteractivityOptionsSchema.optional(),
+    canExportCsv: zod_1.z.boolean().optional(),
+    canExportImages: zod_1.z.boolean().optional(),
+});
+exports.EmbedJwtSchema = zod_1.z
+    .object({
+    userAttributes: zod_1.z.record(zod_1.z.unknown()).optional(),
+    user: zod_1.z
+        .object({
+        externalId: zod_1.z.string().optional(),
+        email: zod_1.z.string().optional(),
+    })
+        .optional(),
+    content: zod_1.z
+        .object({
+        type: zod_1.z.literal('dashboard'),
+        dashboardUuid: zod_1.z.string(),
+        isPreview: zod_1.z.boolean().optional(),
+    })
+        .merge(exports.InteractivityOptionsSchema),
+    iat: zod_1.z.number().optional(),
+    exp: zod_1.z.number(),
+})
+    .describe('Configuration file for generating a CSV file from a query with metrics and dimensions');
+// allows for backwards compatibility with old filter interactivity boolean values
+function getFilterInteractivityValue(enabled) {
+    if (typeof enabled === 'boolean') {
+        return enabled
+            ? FilterInteractivityValues.all
+            : FilterInteractivityValues.none;
+    }
+    return enabled;
+}
+exports.getFilterInteractivityValue = getFilterInteractivityValue;
+function isFilterInteractivityEnabled(filterInteractivityOptions) {
+    if (!filterInteractivityOptions)
+        return false;
+    const filterInteractivityValue = getFilterInteractivityValue(filterInteractivityOptions.enabled);
+    switch (filterInteractivityValue) {
+        case FilterInteractivityValues.some:
+            return (filterInteractivityOptions.allowedFilters &&
+                filterInteractivityOptions.allowedFilters.length > 0);
+        case FilterInteractivityValues.all:
+            return true;
+        case FilterInteractivityValues.none:
+            return false;
+        default:
+            return (0, assertUnreachable_1.default)(filterInteractivityValue, `Unknown FilterInteractivityValue ${filterInteractivityValue}`);
+    }
+}
+exports.isFilterInteractivityEnabled = isFilterInteractivityEnabled;

package/dist/ee/index.d.ts

@@ -0,0 +1,14 @@
+export * from './Ai/schemas';
+export * from './Ai/types';
+export * from './commercialFeatureFlags';
+export * from './embed';
+export * from './scim/errors';
+export * from './scim/types';
+export declare enum ScimSchemaType {
+    ERROR = "urn:ietf:params:scim:api:messages:2.0:Error",
+    USER = "urn:ietf:params:scim:schemas:core:2.0:User",
+    GROUP = "urn:ietf:params:scim:schemas:core:2.0:Group",
+    LIST_RESPONSE = "urn:ietf:params:scim:api:messages:2.0:ListResponse",
+    SCHEMA = "urn:ietf:params:scim:schemas:core:2.0:Schema",
+    PATCH = "urn:ietf:params:scim:api:messages:2.0:PatchOp"
+}

package/dist/ee/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScimSchemaType = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Ai/schemas"), exports);
+tslib_1.__exportStar(require("./Ai/types"), exports);
+tslib_1.__exportStar(require("./commercialFeatureFlags"), exports);
+tslib_1.__exportStar(require("./embed"), exports);
+tslib_1.__exportStar(require("./scim/errors"), exports);
+tslib_1.__exportStar(require("./scim/types"), exports);
+var ScimSchemaType;
+(function (ScimSchemaType) {
+    ScimSchemaType["ERROR"] = "urn:ietf:params:scim:api:messages:2.0:Error";
+    ScimSchemaType["USER"] = "urn:ietf:params:scim:schemas:core:2.0:User";
+    ScimSchemaType["GROUP"] = "urn:ietf:params:scim:schemas:core:2.0:Group";
+    ScimSchemaType["LIST_RESPONSE"] = "urn:ietf:params:scim:api:messages:2.0:ListResponse";
+    ScimSchemaType["SCHEMA"] = "urn:ietf:params:scim:schemas:core:2.0:Schema";
+    ScimSchemaType["PATCH"] = "urn:ietf:params:scim:api:messages:2.0:PatchOp";
+})(ScimSchemaType = exports.ScimSchemaType || (exports.ScimSchemaType = {}));