@transai/connector-runner-otto-fleet-manager-v2 0.6.1

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { FilterGroupInterface } from './filter-group.interface';
+import { FilterInterface } from './filter.interface';
+export declare const FiltersSchema: z.ZodType<FiltersInterface>;
+export interface FiltersInterface {
+    [key: string]: FilterGroupInterface | FilterInterface | false;
+}

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { MeasureFormatsEnum, MeasureTypesEnum } from '../type-enums';
+import { MetaInterface } from './meta.interface';
+export declare const MeasureSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<typeof MeasureTypesEnum>;
+    format: z.ZodOptional<z.ZodEnum<typeof 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<readonly [z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, z.core.$strip>;
+export interface MeasureInterface {
+    name: string;
+    description?: string;
+    type: MeasureTypesEnum;
+    format?: MeasureFormatsEnum;
+    index?: string;
+    sql?: string;
+    dimension?: string;
+    public?: boolean;
+    meta?: MetaInterface;
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { MeasureInterface } from './measure.interface';
+export declare const MeasuresSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<typeof import("..").MeasureTypesEnum>;
+    format: z.ZodOptional<z.ZodEnum<typeof import("..").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<readonly [z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, z.core.$strip>, z.ZodLiteral<false>]>>;
+export interface MeasuresInterface {
+    [key: string]: MeasureInterface | false;
+}

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const LocaleSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+export declare const MetaSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+export interface LocaleInterface {
+    [key: string]: Record<string, string>;
+}
+export interface MetaInterface {
+    [key: string]: string | LocaleInterface;
+}

package/libs/types/src/lib/management-api/dataset/pre-aggregate.interface.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const PreAggregateSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<{
+        rollup: "rollup";
+        original_sql: "original_sql";
+        rollup_join: "rollup_join";
+    }>>;
+    measures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeDimension: z.ZodOptional<z.ZodString>;
+    granularity: z.ZodOptional<z.ZodString>;
+    partitionGranularity: z.ZodOptional<z.ZodString>;
+    rollups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    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>;
+}, z.core.$strip>;
+export interface PreAggregateInterface {
+    type?: 'rollup' | 'original_sql' | 'rollup_join';
+    measures?: Array<string>;
+    dimensions?: Array<string>;
+    segments?: Array<string>;
+    drillDown?: Array<string>;
+    timeDimension?: string;
+    granularity?: string;
+    partitionGranularity?: string;
+    rollups?: Array<string>;
+    refreshKeySql?: string;
+    refreshKeyEvery?: string;
+    refreshKeyIncremental?: boolean;
+    refreshKeyUpdateWindow?: string;
+    buildRangeStartSql?: string;
+    buildRangeEndSql?: string;
+    lambda?: boolean;
+    external?: boolean;
+}

package/libs/types/src/lib/management-api/dataset/pre-aggregations.interface.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { PreAggregateInterface } from './pre-aggregate.interface';
+export declare const PreAggregationsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<{
+        rollup: "rollup";
+        original_sql: "original_sql";
+        rollup_join: "rollup_join";
+    }>>;
+    measures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeDimension: z.ZodOptional<z.ZodString>;
+    granularity: z.ZodOptional<z.ZodString>;
+    partitionGranularity: z.ZodOptional<z.ZodString>;
+    rollups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    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>;
+}, z.core.$strip>, z.ZodLiteral<false>]>>;
+export interface PreAggregationsInterface {
+    [key: string]: PreAggregateInterface | false;
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { RelationTypesEnum } from '../type-enums';
+export declare const RelationSchema: z.ZodObject<{
+    type: z.ZodEnum<typeof RelationTypesEnum>;
+    dimension: z.ZodOptional<z.ZodString>;
+    targetDataset: z.ZodString;
+    targetDimension: z.ZodOptional<z.ZodString>;
+    sql: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface RelationInterface {
+    type: RelationTypesEnum;
+    dimension?: string;
+    targetDataset?: string;
+    targetDimension?: string;
+    sql?: string;
+}

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { RelationInterface } from './relation.interface';
+export declare const RelationsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<typeof import("..").RelationTypesEnum>;
+    dimension: z.ZodOptional<z.ZodString>;
+    targetDataset: z.ZodString;
+    targetDimension: z.ZodOptional<z.ZodString>;
+    sql: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodLiteral<false>]>>;
+export interface RelationsInterface {
+    [key: string]: RelationInterface | false;
+}

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { FilterInterface } from './filter.interface';
+export declare const SegmentSchema: z.ZodIntersection<z.ZodObject<{
+    sql: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodString>;
+    operator: z.ZodOptional<z.ZodEnum<typeof import("..").FilterOperatorsEnum>>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    public: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export interface SegmentInterface extends FilterInterface {
+    name?: string;
+    description?: string;
+    public?: boolean;
+}

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { SegmentInterface } from './segment.interface';
+export declare const SegmentsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+    sql: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodString>;
+    operator: z.ZodOptional<z.ZodEnum<typeof import("..").FilterOperatorsEnum>>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    public: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>, z.ZodLiteral<false>]>>;
+export interface SegmentsInterface {
+    [key: string]: SegmentInterface | false;
+}

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { WhenItemsInterface } from './when-items.interface';
+export declare const SwitchSchema: z.ZodObject<{
+    when: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        sql: z.ZodOptional<z.ZodString>;
+        dimension: z.ZodOptional<z.ZodString>;
+        operator: z.ZodOptional<z.ZodEnum<typeof import("..").FilterOperatorsEnum>>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>, z.ZodLiteral<false>]>>;
+    else: z.ZodOptional<z.ZodString>;
+    segment: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface SwitchInterface {
+    when: WhenItemsInterface;
+    else?: string;
+    segment?: boolean;
+}

package/libs/types/src/lib/management-api/dataset/when-item.interface.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { FilterInterface } from './filter.interface';
+export declare const WhenItemSchema: z.ZodIntersection<z.ZodObject<{
+    sql: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodString>;
+    operator: z.ZodOptional<z.ZodEnum<typeof import("..").FilterOperatorsEnum>>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export interface WhenItemInterface extends FilterInterface {
+    label: string;
+    description?: string;
+}

package/libs/types/src/lib/management-api/dataset/when-items.interface.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { WhenItemInterface } from './when-item.interface';
+export declare const WhenItemsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+    sql: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodOptional<z.ZodString>;
+    operator: z.ZodOptional<z.ZodEnum<typeof import("..").FilterOperatorsEnum>>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>, z.ZodLiteral<false>]>>;
+export interface WhenItemsInterface {
+    [key: string]: false | WhenItemInterface;
+}

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

@@ -0,0 +1,24 @@
+import { TriggerType } from './workflow';
+export interface EventOriginInterface {
+    type: TriggerType;
+    id: string;
+}
+export interface CreateEventInterface {
+    origin: EventOriginInterface;
+    payload: object;
+    testRun?: boolean;
+    workflowDrawingId?: string;
+}
+export interface XodTriggerPayloadType {
+    data?: Record<string, unknown> | Array<unknown>;
+    filter?: Record<string, unknown> | Array<unknown>;
+    global?: Record<string, unknown> | Array<unknown>;
+}
+export interface EventInterface {
+    id: string;
+    origin: EventOriginInterface;
+    payload: XodTriggerPayloadType;
+    tenantIdentifier: string;
+    testRun?: boolean;
+    workflowDrawingId?: string;
+}

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

@@ -0,0 +1,39 @@
+export * from './type-enums';
+export * from './action-definition.interface';
+export * from './tenant.interface';
+export * from './cube-dataset.interface';
+export * from './event-origin.interface';
+export * from './workflow';
+export * from './semantic-trigger';
+export * from './connector-orchestrator-config.interface';
+export * from './chart.interface';
+export * from './dashboard.interface';
+export * from './semantic-trigger';
+export * from './dataset/datasets.interface';
+export * from './dataset/dataset.interface';
+export * from './dataset/dataset-record.interface';
+export * from './dataset/collection.interface';
+export * from './dataset/filters.interface';
+export * from './dataset/filter.interface';
+export * from './connector/connector.interface';
+export * from './connector/connectors.interface';
+export * from './template.interface';
+export * from './template-implementation.interface';
+export * from './template-implementation-overrides.interface';
+export { FilterGroupInterface } from './dataset/filter-group.interface';
+export { DimensionsInterface } from './dataset/dimensions.interface';
+export { DimensionInterface } from './dataset/dimension.interface';
+export { SegmentsInterface } from './dataset/segments.interface';
+export { SegmentInterface } from './dataset/segment.interface';
+export { RelationsInterface } from './dataset/relations.interface';
+export { RelationInterface } from './dataset/relation.interface';
+export { MeasuresInterface } from './dataset/measures.interface';
+export { MeasureInterface } from './dataset/measure.interface';
+export { SwitchInterface } from './dataset/switch.interface';
+export { WhenItemsInterface } from './dataset/when-items.interface';
+export { WhenItemInterface } from './dataset/when-item.interface';
+export { MetaInterface } from './dataset/meta.interface';
+export { PreAggregationsInterface } from './dataset/pre-aggregations.interface';
+export { PreAggregateInterface } from './dataset/pre-aggregate.interface';
+export { TemplateImplementationOverridesInterface } from './template-implementation-overrides.interface';
+export * from './web';

package/libs/types/src/lib/management-api/semantic-trigger/custom-cron-trigger-record.interface.d.ts

@@ -0,0 +1,6 @@
+import { TriggerType } from '../workflow';
+export interface CustomCronTriggerRecord {
+    triggerType: TriggerType;
+    workflowIdentifier: string;
+    tenantIdentifier: string;
+}

package/libs/types/src/lib/management-api/semantic-trigger/index.d.ts

@@ -0,0 +1,6 @@
+export * from './custom-cron-trigger-record.interface';
+export * from './semantic-trigger-filter.interface';
+export * from './semantic-trigger-filters.interface';
+export * from './semantic-trigger-record.interface';
+export * from './semantic-trigger.interface';
+export * from './semantic-triggers.interface';

package/libs/types/src/lib/management-api/semantic-trigger/semantic-trigger-filter.interface.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { FilterValueType, SemanticTriggerFilterOperatorsEnum } from '../type-enums';
+export declare const SemanticTriggerFilterSchema: z.ZodObject<{
+    dimension: z.ZodString;
+    operator: z.ZodEnum<typeof SemanticTriggerFilterOperatorsEnum>;
+    values: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+}, z.core.$strip>;
+export interface SemanticTriggerFilterInterface {
+    dimension: string;
+    operator: SemanticTriggerFilterOperatorsEnum;
+    values: FilterValueType;
+}

package/libs/types/src/lib/management-api/semantic-trigger/semantic-trigger-filters.interface.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { SemanticTriggerFilterInterface } from './semantic-trigger-filter.interface';
+export declare const SemanticTriggerFiltersSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    dimension: z.ZodString;
+    operator: z.ZodEnum<typeof import("..").SemanticTriggerFilterOperatorsEnum>;
+    values: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+}, z.core.$strip>, z.ZodLiteral<false>]>>;
+export interface SemanticTriggerFiltersInterface {
+    [key: string]: SemanticTriggerFilterInterface | false;
+}

package/libs/types/src/lib/management-api/semantic-trigger/semantic-trigger-record.interface.d.ts

@@ -0,0 +1,6 @@
+import { SemanticTriggerInterface } from './semantic-trigger.interface';
+export interface SemanticTriggerRecordInterface extends SemanticTriggerInterface {
+    id: string;
+    tenantId: string;
+}
+export declare const SemanticTriggerIdentifier: (trigger: SemanticTriggerRecordInterface) => string;

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { SemanticTriggerFiltersInterface } from './semantic-trigger-filters.interface';
+export declare const SemanticTriggerSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    eventType: z.ZodString;
+    dataset: z.ZodString;
+    dimensions: z.ZodArray<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        dimension: z.ZodString;
+        operator: z.ZodEnum<typeof import("..").SemanticTriggerFilterOperatorsEnum>;
+        values: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+    }, z.core.$strip>, 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>;
+}, z.core.$strip>;
+export interface SemanticTriggerInterface {
+    name?: string;
+    description?: string;
+    eventType: string;
+    dataset: string;
+    dimensions: Array<string>;
+    measures?: Array<string>;
+    segments?: Array<string>;
+    limit?: number;
+    filters?: SemanticTriggerFiltersInterface | false;
+    cron?: string;
+    tz?: string;
+    incrementalField?: string;
+    keyField?: string;
+    ungrouped?: boolean;
+}

package/libs/types/src/lib/management-api/semantic-trigger/semantic-triggers.interface.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { SemanticTriggerInterface } from './semantic-trigger.interface';
+export declare const SemanticTriggersSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    eventType: z.ZodString;
+    dataset: z.ZodString;
+    dimensions: z.ZodArray<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        dimension: z.ZodString;
+        operator: z.ZodEnum<typeof import("..").SemanticTriggerFilterOperatorsEnum>;
+        values: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+    }, z.core.$strip>, 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>;
+}, z.core.$strip>, z.ZodBoolean]>>;
+export interface SemanticTriggersInterface {
+    [key: string]: SemanticTriggerInterface | boolean;
+}

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

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { SemanticTriggersInterface, DatasetsInterface, ConnectorsInterface } from './index';
+export declare const TemplateImplementationOverridesSchema: z.ZodObject<{
+    datasets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<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<readonly [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, unknown, z.core.$ZodTypeInternals<import("./index").FiltersInterface, unknown>>>;
+        }, z.core.$strip>>;
+        dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<typeof import("./type-enums").DimensionTypesEnum>;
+            format: z.ZodOptional<z.ZodEnum<typeof import("./type-enums").DimensionFormatsEnum>>;
+            explode: z.ZodOptional<z.ZodBoolean>;
+            index: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+            switch: z.ZodOptional<z.ZodObject<{
+                when: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+                    sql: z.ZodOptional<z.ZodString>;
+                    dimension: z.ZodOptional<z.ZodString>;
+                    operator: z.ZodOptional<z.ZodEnum<typeof import("./type-enums").FilterOperatorsEnum>>;
+                    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>, z.ZodLiteral<false>]>>;
+                else: z.ZodOptional<z.ZodString>;
+                segment: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            field: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            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<readonly [z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strip>, z.ZodLiteral<false>]>>>;
+        segments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+            sql: z.ZodOptional<z.ZodString>;
+            dimension: z.ZodOptional<z.ZodString>;
+            operator: z.ZodOptional<z.ZodEnum<typeof import("./type-enums").FilterOperatorsEnum>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+        }, z.core.$strip>, z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            public: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>, z.ZodLiteral<false>]>>>;
+        relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodEnum<typeof import("./type-enums").RelationTypesEnum>;
+            dimension: z.ZodOptional<z.ZodString>;
+            targetDataset: z.ZodString;
+            targetDimension: z.ZodOptional<z.ZodString>;
+            sql: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodLiteral<false>]>>>;
+        measures: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodEnum<typeof import("./type-enums").MeasureTypesEnum>;
+            format: z.ZodOptional<z.ZodEnum<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<readonly [z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strip>, z.ZodLiteral<false>]>>>;
+        preAggregations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodOptional<z.ZodEnum<{
+                rollup: "rollup";
+                original_sql: "original_sql";
+                rollup_join: "rollup_join";
+            }>>;
+            measures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            timeDimension: z.ZodOptional<z.ZodString>;
+            granularity: z.ZodOptional<z.ZodString>;
+            partitionGranularity: z.ZodOptional<z.ZodString>;
+            rollups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            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>;
+        }, z.core.$strip>, z.ZodLiteral<false>]>>>;
+    }, z.core.$strip>, z.ZodBoolean]>>>;
+    semanticTriggers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        eventType: z.ZodString;
+        dataset: z.ZodString;
+        dimensions: z.ZodArray<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            dimension: z.ZodString;
+            operator: z.ZodEnum<typeof import("./type-enums").SemanticTriggerFilterOperatorsEnum>;
+            values: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+        }, z.core.$strip>, 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>;
+    }, z.core.$strip>, z.ZodBoolean]>>>;
+    connectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        identifier: z.ZodString;
+        connectorType: z.ZodEnum<typeof import("../types").ConfiguredConnectorTypes>;
+        name: z.ZodString;
+        location: z.ZodString;
+        config: z.ZodObject<{}, z.core.$loose>;
+        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;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    array: "array";
+                }>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                items: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+            }, z.core.$strip>>;
+            outputParameters: z.ZodRecord<z.ZodString, z.ZodAny>;
+            mode: z.ZodOptional<z.ZodEnum<typeof import("./type-enums").ConnectorOrigin>>;
+            createdAt: z.ZodOptional<z.ZodDate>;
+            updatedAt: z.ZodOptional<z.ZodDate>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodDate>;
+        updatedAt: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip>, z.ZodBoolean]>>>;
+}, z.core.$strip>;
+export interface TemplateImplementationOverridesInterface {
+    datasets?: DatasetsInterface;
+    semanticTriggers?: SemanticTriggersInterface;
+    connectors?: ConnectorsInterface;
+}