@transai/connector-runner-microsoft-office365-email 0.1.0

package/libs/types/src/lib/management-api/template-implementation.interface.d.ts

@@ -0,0 +1,2860 @@
+import { z } from 'zod';
+import { TemplateInterface } from './template.interface';
+import { TemplateImplementationOverridesInterface } from './template-implementation-overrides.interface';
+export declare const TemplateImplementationSchema: z.ZodObject<{
+    templateVersion: z.ZodUnion<[z.ZodLiteral<"latest">, z.ZodString]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    overrides: z.ZodObject<{
+        datasets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodNativeEnum<typeof import("./type-enums").DatasetTypeEnum>;
+            prefix: z.ZodString;
+            parent: z.ZodOptional<z.ZodString>;
+            sql: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            collection: z.ZodOptional<z.ZodObject<{
+                collection: z.ZodString;
+                filters: z.ZodOptional<z.ZodType<import(".").FiltersInterface, z.ZodTypeDef, import(".").FiltersInterface>>;
+            }, "strip", z.ZodTypeAny, {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            }, {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            }>>;
+            dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                type: z.ZodNativeEnum<typeof import("./type-enums").DimensionTypesEnum>;
+                format: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").DimensionFormatsEnum>>;
+                explode: z.ZodOptional<z.ZodBoolean>;
+                index: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+                switch: z.ZodOptional<z.ZodObject<{
+                    when: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodIntersection<z.ZodEffects<z.ZodObject<{
+                        sql: z.ZodOptional<z.ZodString>;
+                        dimension: z.ZodOptional<z.ZodString>;
+                        operator: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").FilterOperatorsEnum>>;
+                        value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">]>>;
+                    }, "strip", z.ZodTypeAny, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }>, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }>, z.ZodObject<{
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        description?: string;
+                        label?: string;
+                    }, {
+                        description?: string;
+                        label?: string;
+                    }>>, z.ZodLiteral<false>]>>;
+                    else: z.ZodOptional<z.ZodString>;
+                    segment: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                }, {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                }>>;
+                field: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+                sql: z.ZodOptional<z.ZodString>;
+                public: z.ZodOptional<z.ZodBoolean>;
+                primaryKey: z.ZodOptional<z.ZodBoolean>;
+                subQuery: z.ZodOptional<z.ZodBoolean>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            }, "strip", z.ZodTypeAny, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, z.ZodLiteral<false>]>>>;
+            segments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodIntersection<z.ZodEffects<z.ZodObject<{
+                sql: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodOptional<z.ZodString>;
+                operator: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").FilterOperatorsEnum>>;
+                value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">]>>;
+            }, "strip", z.ZodTypeAny, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }>, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }>, z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                public: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            }, {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            }>>, z.ZodLiteral<false>]>>>;
+            relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+                type: z.ZodNativeEnum<typeof import("./type-enums").RelationTypesEnum>;
+                dimension: z.ZodOptional<z.ZodString>;
+                targetDataset: z.ZodString;
+                targetDimension: z.ZodOptional<z.ZodString>;
+                sql: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>, z.ZodLiteral<false>]>>>;
+            measures: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodNativeEnum<typeof import("./type-enums").MeasureTypesEnum>;
+                format: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").MeasureFormatsEnum>>;
+                index: z.ZodOptional<z.ZodString>;
+                sql: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodOptional<z.ZodString>;
+                public: z.ZodOptional<z.ZodBoolean>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            }, "strip", z.ZodTypeAny, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, z.ZodLiteral<false>]>>>;
+            preAggregations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<["rollup", "original_sql", "rollup_join"]>>;
+                measures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                dimensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                segments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                timeDimension: z.ZodOptional<z.ZodString>;
+                granularity: z.ZodOptional<z.ZodString>;
+                partitionGranularity: z.ZodOptional<z.ZodString>;
+                rollups: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                refreshKeySql: z.ZodOptional<z.ZodString>;
+                refreshKeyEvery: z.ZodOptional<z.ZodString>;
+                refreshKeyIncremental: z.ZodOptional<z.ZodBoolean>;
+                refreshKeyUpdateWindow: z.ZodOptional<z.ZodString>;
+                buildRangeStartSql: z.ZodOptional<z.ZodString>;
+                buildRangeEndSql: z.ZodOptional<z.ZodString>;
+                lambda: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }, {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>, z.ZodLiteral<false>]>>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>, z.ZodBoolean]>>>;
+        semanticTriggers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            eventType: z.ZodString;
+            dataset: z.ZodString;
+            dimensions: z.ZodArray<z.ZodString, "many">;
+            limit: z.ZodOptional<z.ZodNumber>;
+            filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+                dimension: z.ZodString;
+                operator: z.ZodNativeEnum<typeof import("./type-enums").SemanticTriggerFilterOperatorsEnum>;
+                values: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">]>;
+            }, "strip", z.ZodTypeAny, {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }, {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>, z.ZodLiteral<false>]>>>;
+            cron: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tz: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            incrementalField: z.ZodOptional<z.ZodString>;
+            ungrouped: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }, {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>, z.ZodBoolean]>>>;
+        connectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            identifier: z.ZodString;
+            connectorType: z.ZodNativeEnum<typeof import("../types").ConfiguredConnectorTypes>;
+            name: z.ZodString;
+            location: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodAny>;
+            enabled: z.ZodBoolean;
+            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                identifier: z.ZodString;
+                version: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                config: z.ZodRecord<z.ZodString, z.ZodAny>;
+                inputParameters: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodEnum<["string", "number", "boolean", "array"]>;
+                    required: z.ZodOptional<z.ZodBoolean>;
+                    items: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }, {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }>, "many">;
+                outputParameters: z.ZodAny;
+                mode: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").ConnectorOrigin>>;
+                createdAt: z.ZodOptional<z.ZodDate>;
+                updatedAt: z.ZodOptional<z.ZodDate>;
+            }, "strip", z.ZodTypeAny, {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }, {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }>, "many">>;
+            createdAt: z.ZodOptional<z.ZodDate>;
+            updatedAt: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }, {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>, z.ZodBoolean]>>>;
+    }, "strip", z.ZodTypeAny, {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    }, {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    description?: string;
+    templateVersion?: string;
+    overrides?: {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    };
+}, {
+    name?: string;
+    description?: string;
+    templateVersion?: string;
+    overrides?: {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    };
+}>;
+export declare const TemplateImplementationCreateSchema: z.ZodObject<{
+    templateVersion: z.ZodUnion<[z.ZodLiteral<"latest">, z.ZodString]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    overrides: z.ZodObject<{
+        datasets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodNativeEnum<typeof import("./type-enums").DatasetTypeEnum>;
+            prefix: z.ZodString;
+            parent: z.ZodOptional<z.ZodString>;
+            sql: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            collection: z.ZodOptional<z.ZodObject<{
+                collection: z.ZodString;
+                filters: z.ZodOptional<z.ZodType<import(".").FiltersInterface, z.ZodTypeDef, import(".").FiltersInterface>>;
+            }, "strip", z.ZodTypeAny, {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            }, {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            }>>;
+            dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                type: z.ZodNativeEnum<typeof import("./type-enums").DimensionTypesEnum>;
+                format: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").DimensionFormatsEnum>>;
+                explode: z.ZodOptional<z.ZodBoolean>;
+                index: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+                switch: z.ZodOptional<z.ZodObject<{
+                    when: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodIntersection<z.ZodEffects<z.ZodObject<{
+                        sql: z.ZodOptional<z.ZodString>;
+                        dimension: z.ZodOptional<z.ZodString>;
+                        operator: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").FilterOperatorsEnum>>;
+                        value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">]>>;
+                    }, "strip", z.ZodTypeAny, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }>, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }, {
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    }>, z.ZodObject<{
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        description?: string;
+                        label?: string;
+                    }, {
+                        description?: string;
+                        label?: string;
+                    }>>, z.ZodLiteral<false>]>>;
+                    else: z.ZodOptional<z.ZodString>;
+                    segment: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                }, {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                }>>;
+                field: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+                sql: z.ZodOptional<z.ZodString>;
+                public: z.ZodOptional<z.ZodBoolean>;
+                primaryKey: z.ZodOptional<z.ZodBoolean>;
+                subQuery: z.ZodOptional<z.ZodBoolean>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            }, "strip", z.ZodTypeAny, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, z.ZodLiteral<false>]>>>;
+            segments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodIntersection<z.ZodEffects<z.ZodObject<{
+                sql: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodOptional<z.ZodString>;
+                operator: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").FilterOperatorsEnum>>;
+                value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">]>>;
+            }, "strip", z.ZodTypeAny, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }>, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }, {
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            }>, z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                public: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            }, {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            }>>, z.ZodLiteral<false>]>>>;
+            relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+                type: z.ZodNativeEnum<typeof import("./type-enums").RelationTypesEnum>;
+                dimension: z.ZodOptional<z.ZodString>;
+                targetDataset: z.ZodString;
+                targetDimension: z.ZodOptional<z.ZodString>;
+                sql: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }, {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>, z.ZodLiteral<false>]>>>;
+            measures: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodNativeEnum<typeof import("./type-enums").MeasureTypesEnum>;
+                format: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").MeasureFormatsEnum>>;
+                index: z.ZodOptional<z.ZodString>;
+                sql: z.ZodOptional<z.ZodString>;
+                dimension: z.ZodOptional<z.ZodString>;
+                public: z.ZodOptional<z.ZodBoolean>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            }, "strip", z.ZodTypeAny, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }, {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>, z.ZodLiteral<false>]>>>;
+            preAggregations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<["rollup", "original_sql", "rollup_join"]>>;
+                measures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                dimensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                segments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                timeDimension: z.ZodOptional<z.ZodString>;
+                granularity: z.ZodOptional<z.ZodString>;
+                partitionGranularity: z.ZodOptional<z.ZodString>;
+                rollups: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                refreshKeySql: z.ZodOptional<z.ZodString>;
+                refreshKeyEvery: z.ZodOptional<z.ZodString>;
+                refreshKeyIncremental: z.ZodOptional<z.ZodBoolean>;
+                refreshKeyUpdateWindow: z.ZodOptional<z.ZodString>;
+                buildRangeStartSql: z.ZodOptional<z.ZodString>;
+                buildRangeEndSql: z.ZodOptional<z.ZodString>;
+                lambda: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }, {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>, z.ZodLiteral<false>]>>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }, {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>, z.ZodBoolean]>>>;
+        semanticTriggers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            eventType: z.ZodString;
+            dataset: z.ZodString;
+            dimensions: z.ZodArray<z.ZodString, "many">;
+            limit: z.ZodOptional<z.ZodNumber>;
+            filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+                dimension: z.ZodString;
+                operator: z.ZodNativeEnum<typeof import("./type-enums").SemanticTriggerFilterOperatorsEnum>;
+                values: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">]>;
+            }, "strip", z.ZodTypeAny, {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }, {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>, z.ZodLiteral<false>]>>>;
+            cron: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tz: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            incrementalField: z.ZodOptional<z.ZodString>;
+            ungrouped: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }, {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>, z.ZodBoolean]>>>;
+        connectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            identifier: z.ZodString;
+            connectorType: z.ZodNativeEnum<typeof import("../types").ConfiguredConnectorTypes>;
+            name: z.ZodString;
+            location: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodAny>;
+            enabled: z.ZodBoolean;
+            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                identifier: z.ZodString;
+                version: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                config: z.ZodRecord<z.ZodString, z.ZodAny>;
+                inputParameters: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodEnum<["string", "number", "boolean", "array"]>;
+                    required: z.ZodOptional<z.ZodBoolean>;
+                    items: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }, {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }>, "many">;
+                outputParameters: z.ZodAny;
+                mode: z.ZodOptional<z.ZodNativeEnum<typeof import("./type-enums").ConnectorOrigin>>;
+                createdAt: z.ZodOptional<z.ZodDate>;
+                updatedAt: z.ZodOptional<z.ZodDate>;
+            }, "strip", z.ZodTypeAny, {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }, {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }>, "many">>;
+            createdAt: z.ZodOptional<z.ZodDate>;
+            updatedAt: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }, {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>, z.ZodBoolean]>>>;
+    }, "strip", z.ZodTypeAny, {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    }, {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    }>;
+} & {
+    templateId: z.ZodString;
+    tenantId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    description?: string;
+    templateVersion?: string;
+    overrides?: {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    };
+    templateId?: string;
+    tenantId?: string;
+}, {
+    name?: string;
+    description?: string;
+    templateVersion?: string;
+    overrides?: {
+        datasets?: Record<string, boolean | {
+            type?: import("./type-enums").DatasetTypeEnum;
+            name?: string;
+            description?: string;
+            dimensions?: Record<string, false | {
+                type?: import("./type-enums").DimensionTypesEnum;
+                name?: string;
+                description?: string;
+                sql?: string;
+                format?: import("./type-enums").DimensionFormatsEnum;
+                explode?: boolean;
+                index?: string | boolean;
+                switch?: {
+                    when?: Record<string, false | ({
+                        value?: string | number | boolean | (string | number | boolean)[];
+                        dimension?: string;
+                        operator?: import("./type-enums").FilterOperatorsEnum;
+                        sql?: string;
+                    } & {
+                        description?: string;
+                        label?: string;
+                    })>;
+                    else?: string;
+                    segment?: boolean;
+                };
+                field?: string | string[];
+                public?: boolean;
+                primaryKey?: boolean;
+                subQuery?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            sql?: string;
+            collection?: {
+                filters?: import(".").FiltersInterface;
+                collection?: string;
+            };
+            meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            measures?: Record<string, false | {
+                type?: import("./type-enums").MeasureTypesEnum;
+                name?: string;
+                description?: string;
+                dimension?: string;
+                sql?: string;
+                format?: import("./type-enums").MeasureFormatsEnum;
+                index?: string;
+                public?: boolean;
+                meta?: Record<string, string | number | boolean | Record<string, Record<string, string>>>;
+            }>;
+            segments?: Record<string, false | ({
+                value?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").FilterOperatorsEnum;
+                sql?: string;
+            } & {
+                name?: string;
+                description?: string;
+                public?: boolean;
+            })>;
+            prefix?: string;
+            parent?: string;
+            relations?: Record<string, false | {
+                type?: import("./type-enums").RelationTypesEnum;
+                dimension?: string;
+                sql?: string;
+                targetDataset?: string;
+                targetDimension?: string;
+            }>;
+            preAggregations?: Record<string, false | {
+                type?: "rollup" | "original_sql" | "rollup_join";
+                dimensions?: string[];
+                measures?: string[];
+                segments?: string[];
+                timeDimension?: string;
+                granularity?: string;
+                partitionGranularity?: string;
+                rollups?: string[];
+                refreshKeySql?: string;
+                refreshKeyEvery?: string;
+                refreshKeyIncremental?: boolean;
+                refreshKeyUpdateWindow?: string;
+                buildRangeStartSql?: string;
+                buildRangeEndSql?: string;
+                lambda?: boolean;
+            }>;
+        }>;
+        semanticTriggers?: Record<string, boolean | {
+            name?: string;
+            description?: string;
+            eventType?: string;
+            dataset?: string;
+            dimensions?: string[];
+            limit?: number;
+            filters?: Record<string, false | {
+                values?: string | number | boolean | (string | number | boolean)[];
+                dimension?: string;
+                operator?: import("./type-enums").SemanticTriggerFilterOperatorsEnum;
+            }>;
+            cron?: string;
+            tz?: string;
+            incrementalField?: string;
+            ungrouped?: boolean;
+        }>;
+        connectors?: Record<string, boolean | {
+            createdAt?: Date;
+            identifier?: string;
+            name?: string;
+            config?: Record<string, any>;
+            updatedAt?: Date;
+            connectorType?: import("../types").ConfiguredConnectorTypes;
+            location?: string;
+            enabled?: boolean;
+            actions?: {
+                mode?: import("./type-enums").ConnectorOrigin;
+                createdAt?: Date;
+                identifier?: string;
+                version?: string;
+                name?: string;
+                description?: string;
+                config?: Record<string, any>;
+                inputParameters?: {
+                    type?: "string" | "number" | "boolean" | "array";
+                    name?: string;
+                    required?: boolean;
+                    items?: any[];
+                }[];
+                outputParameters?: any;
+                updatedAt?: Date;
+            }[];
+        }>;
+    };
+    templateId?: string;
+    tenantId?: string;
+}>;
+export interface TemplateImplementationInterface {
+    id: string;
+    templateId: string;
+    template: TemplateInterface;
+    templateVersion: string | 'latest';
+    tenantId: string;
+    name: string;
+    description: string;
+    overrides: TemplateImplementationOverridesInterface;
+}