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

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

@@ -0,0 +1,1191 @@
+import { z } from 'zod';
+import { DatasetsInterface, SemanticTriggersInterface, ConnectorsInterface } from './index';
+export declare const TemplateSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    prefix: z.ZodString;
+    description: z.ZodString;
+    datasets: 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("./index").FiltersInterface, z.ZodTypeDef, import("./index").FiltersInterface>>;
+        }, "strip", z.ZodTypeAny, {
+            filters?: import("./index").FiltersInterface;
+            collection?: string;
+        }, {
+            filters?: import("./index").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("./index").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("./index").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("./index").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("./index").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.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, {
+    identifier?: string;
+    version?: string;
+    name?: string;
+    description?: string;
+    prefix?: string;
+    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("./index").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;
+        }[];
+    }>;
+}, {
+    identifier?: string;
+    version?: string;
+    name?: string;
+    description?: string;
+    prefix?: string;
+    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("./index").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 interface TemplateInterface {
+    id: string;
+    identifier: string;
+    version: string;
+    name: string;
+    prefix: string;
+    description: string;
+    datasets: DatasetsInterface;
+    semanticTriggers: SemanticTriggersInterface;
+    connectors?: ConnectorsInterface;
+}
+export interface PostTemplateInterface extends Omit<TemplateInterface, 'id'> {
+    identifier: string;
+    version: string;
+    name: string;
+    prefix: string;
+    description: string;
+    datasets: DatasetsInterface;
+    semanticTriggers: SemanticTriggersInterface;
+    connectors?: ConnectorsInterface;
+}
+export interface TemplateVersionInterface {
+    version: string;
+    createdAt: Date;
+    count: number;
+}
+export interface TemplateDetailInterface extends TemplateInterface {
+    versions: Array<TemplateVersionInterface>;
+}