@transai/connector-runner-ez-mes 0.9.1

package/libs/connector-runtime-sdk/src/lib/sdk/sdk.interface.d.ts

@@ -0,0 +1,31 @@
+import { BaseConnectorConfig } from '@xip-online-data/types';
+import { FilesSDKInterface } from './files.sdk.interface';
+import { HttpClientSDKInterface, HttpConfig } from './http-client.interface';
+import { LoggerSDKInterface } from './logger.sdk.interface';
+import { OffsetStoreSDKInterface } from './offset-store.sdk.interface';
+import { ProcessingSDKInterface } from './processing.sdk.interface';
+import { ReceiverSDKInterface } from './receiver.sdk.interface';
+import { SenderSDKInterface } from './sender.sdk.interface';
+import { TelemetrySDKInterface } from './telemetry.sdk.interface';
+import { TemplatingSDKInterface } from './templating.sdk.interface';
+export interface ConnectorSDKInterface<T = BaseConnectorConfig> {
+    get config(): T;
+    get logger(): LoggerSDKInterface;
+    get sender(): SenderSDKInterface;
+    get receiver(): ReceiverSDKInterface;
+    get templating(): TemplatingSDKInterface;
+    /**
+     * Service to schedule and manage processing tasks that need monitoring and retries.
+     */
+    get processing(): ProcessingSDKInterface;
+    get offsetStore(): OffsetStoreSDKInterface;
+    /**
+     * Ability to send telemetry data such as gauges and increments on how the connector is performing.
+     */
+    get telemetry(): TelemetrySDKInterface;
+    /**
+     * Get file service instance to access files using a specified DSN. If no DSN is provided, defaults to local file system tmp dir.
+     */
+    files(dsn?: string): FilesSDKInterface;
+    httpClient(httpConfig?: HttpConfig): HttpClientSDKInterface;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/sender.sdk.interface.d.ts

@@ -0,0 +1,22 @@
+export interface Metric {
+    key: string;
+    value: number;
+}
+export type Metadata = {
+    [key: string]: string;
+};
+export interface Context {
+    timestamp?: Date;
+    ttl?: number;
+    extraPayload?: {
+        [key: string]: string;
+    };
+}
+export type Result = boolean | {
+    [index: number]: boolean;
+};
+export interface SenderSDKInterface {
+    metrics(metrics: Array<Metric>, metadata?: Metadata, context?: Context): Promise<Result>;
+    metricsLegacy<T = never>(metrics: Array<T>, metadata?: Metadata, context?: Context, topic?: string): Promise<Result>;
+    documents<T = object>(documents: Array<T>, metadata?: Metadata, context?: Context): Promise<Result>;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/telemetry.sdk.interface.d.ts

@@ -0,0 +1,15 @@
+export interface TelemetrySDKInterface {
+    /**
+     * Increment a telemetry counter by 1.
+     */
+    increment(key: string): void;
+    /**
+     * Increment a telemetry counter by a specified value. 0 doesn't send any telemetry.
+     * A negative value will decrement the counter.
+     */
+    increment(key: string, value: number): void;
+    /**
+     * Send a gauge telemetry metric.
+     */
+    gauge(key: string, value: number): void;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/templating.sdk.interface.d.ts

@@ -0,0 +1,12 @@
+export type RuntimeOptions = {
+    partial?: boolean;
+};
+export type CompileDelegate<T = unknown> = {
+    (context: T, options?: RuntimeOptions): string;
+};
+export type CompileOptions = {
+    strict?: boolean;
+};
+export interface TemplatingSDKInterface {
+    compile<T = unknown>(input: string, options?: CompileOptions): CompileDelegate<T>;
+}

package/libs/connector-runtime-sdk/src/lib/support/index.d.ts

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

package/libs/connector-runtime-sdk/src/lib/support/null-logger.d.ts

@@ -0,0 +1,8 @@
+import { LoggerSDKInterface } from '../sdk';
+export declare class NullLogger implements LoggerSDKInterface {
+    info(): void;
+    debug(): void;
+    error(): void;
+    warn(): void;
+    verbose(): void;
+}

package/libs/types/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/types';
+export * from './lib/response.types';
+export * from './lib/message.types';
+export * from './lib/cube-query-config.types';
+export * from './lib/file-action.types';
+export * from './lib/management-api';
+export * from './lib/http-status-codes.enum';

package/libs/types/src/lib/cube-query-config.types.d.ts

@@ -0,0 +1,20 @@
+import { Query } from '@cubejs-client/core';
+export interface CubeQueryConfig {
+    tenantId: string;
+    query: Query;
+    nullable?: boolean;
+    subqueries: Array<CubeSubQueryConfig>;
+}
+export interface CubeSubQueryConfig {
+    tenantId?: string;
+    query: Query;
+    nullable?: boolean;
+    field: string;
+    joinConditions: Array<CubeJoinCondition>;
+}
+export interface CubeJoinCondition {
+    selectField: string;
+    operator: string;
+    valueField: Array<string>;
+    valueMap?: Array<any>;
+}

package/libs/types/src/lib/file-action.types.d.ts

@@ -0,0 +1,5 @@
+export declare enum FileActionType {
+    ACTION_MOVE = "move",
+    ACTION_DELETE = "delete",
+    ACTION_NOTHING = "nothing"
+}

package/libs/types/src/lib/http-status-codes.enum.d.ts

@@ -0,0 +1,64 @@
+export declare enum HttpStatusCode {
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    OK = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    IMUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    PayloadTooLarge = 413,
+    URITooLong = 414,
+    UnsupportedMediaType = 415,
+    RangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    ImATeapot = 418,
+    MisdirectedRequest = 421,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    TooEarly = 425,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    UnavailableForLegalReasons = 451,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HTTPVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511,
+    Aborted = 512
+}

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

@@ -0,0 +1,12 @@
+import { TenantInterface } from './tenant.interface';
+import { CubeQueryConfig } from '../cube-query-config.types';
+export interface ActionDefinitionInterface {
+    tenant: TenantInterface;
+    eventType: string;
+    eventTopic: string;
+    destinationTopic: string;
+    actionIdentifier: string;
+    template: string;
+    fileNameTemplate: string | undefined;
+    queryConfig: CubeQueryConfig | undefined;
+}

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

@@ -0,0 +1,9 @@
+export interface ChartInterface {
+    dashboards: Array<number>;
+    owners: Array<number>;
+    params: string;
+    slice_name: string;
+    viz_type: string;
+    id: string;
+    supersetId: number;
+}

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { BaseConnectorConfig, ConfiguredConnectorTypes } from '../../types';
+import { ConnectorOrigin } from '../type-enums';
+import { ActionInterface } from '../workflow';
+export declare const ConnectorSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    connectorType: z.ZodEnum<typeof 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 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>;
+export interface ConnectorInterface<T = Partial<BaseConnectorConfig>> {
+    identifier: string;
+    connectorType: ConfiguredConnectorTypes;
+    tenantIdentifier: string;
+    name: string;
+    location: string;
+    config?: T;
+    enabled: boolean;
+    actions?: Array<ActionInterface>;
+    mode?: ConnectorOrigin;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export type CreateConnectorInterface<T = Partial<BaseConnectorConfig>> = Omit<ConnectorInterface<T>, 'id' | 'createdAt' | 'updatedAt' | 'mode'>;
+export type UpdateConnectorInterface<T = Partial<BaseConnectorConfig>> = Partial<Omit<ConnectorInterface<T>, 'id' | 'tenantIdentifier' | 'identifier' | 'createdAt' | 'mode'>>;

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { ConnectorInterface } from '../index';
+export declare const ConnectorsSchema: 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]>>;
+export interface ConnectorsInterface {
+    [key: string]: ConnectorInterface | boolean;
+}

package/libs/types/src/lib/management-api/connector-orchestrator-config.interface.d.ts

@@ -0,0 +1,14 @@
+import { ConnectorInterface } from './connector/connector.interface';
+export interface ConnectorOrchestratorConfigInterface {
+    awsAccessKeyId?: string;
+    awsSecretAccessKey?: string;
+    awsRegion?: string;
+    datadogApiKey?: string;
+}
+export interface ConnectorOrchestratorConfigWithKafkaInterface extends ConnectorOrchestratorConfigInterface {
+    kafkaBrokers?: Array<string>;
+}
+export interface ConnectorOrchestratorFullConfigurationInterface {
+    config: ConnectorOrchestratorConfigWithKafkaInterface;
+    connectors: Array<ConnectorInterface>;
+}

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

@@ -0,0 +1,93 @@
+import { MetaInterface } from './dataset/meta.interface';
+export interface CubePreAggregationInterface {
+    type?: 'rollup' | 'original_sql' | 'rollup_join';
+    measures?: Array<string>;
+    dimensions?: Array<string>;
+    segments?: Array<string>;
+    timeDimension?: string;
+    granularity?: string;
+    rollups?: Array<string>;
+    refreshKeySql?: string;
+    refreshKeyEvery?: string;
+    refreshKeyIncremental?: boolean;
+    refreshKeyUpdateWindow?: string;
+    lambdaAggregation?: boolean;
+}
+export interface CubePreAggregationsInterface {
+    [key: string]: CubePreAggregationInterface;
+}
+export interface CubeDatasetInterface {
+    id: string;
+    dataSource: string;
+    name: string;
+    description: string;
+    tenantId: string;
+    parentId?: string;
+    sql?: string;
+    refreshSql?: string;
+    meta?: MetaInterface;
+    dimensions: CubeDimensionsInterface;
+    segments?: CubeSegmentsInterface;
+    relations?: CubeRelationsInterface;
+    measures?: CubeMeasuresInterface;
+    preAggregations?: CubePreAggregationsInterface;
+}
+export interface CubeDimensionsInterface {
+    [key: string]: CubeDimensionInterface;
+}
+export interface CubeDimensionInterface {
+    title: string;
+    description: string;
+    index?: boolean;
+    type: string;
+    format?: string;
+    primaryKey?: boolean;
+    public?: boolean;
+    subQuery?: boolean;
+    sql?: string;
+    case?: CubeDimensionCaseInterface;
+    meta?: MetaInterface;
+    granularities?: {
+        [key: string]: {
+            interval: string;
+        };
+    };
+}
+export interface CubeDimensionCaseInterface {
+    when: Array<CubeDimensionCaseWhenInterface>;
+    else: {
+        label: string;
+    };
+}
+export interface CubeDimensionCaseWhenInterface {
+    label: string;
+    sql: string;
+}
+export interface CubeRelationsInterface {
+    [key: string]: CubeRelationInterface;
+}
+export interface CubeRelationInterface {
+    relationship: string;
+    sql: string;
+}
+export interface CubeSegmentsInterface {
+    [key: string]: CubeSegmentInterface;
+}
+export interface CubeSegmentInterface {
+    public: boolean;
+    sql: string;
+    title?: string;
+    description?: string;
+}
+export interface CubeMeasuresInterface {
+    [key: string]: CubeMeasureInterface;
+}
+export interface CubeMeasureInterface {
+    title: string;
+    description?: string;
+    public?: boolean;
+    type: string;
+    format?: string;
+    sql: string;
+    meta?: MetaInterface;
+}

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

@@ -0,0 +1,35 @@
+export type DashboardPositionValue = string | number | boolean | null | Record<string, unknown> | Array<unknown>;
+export interface DashboardPositionJson {
+    [key: string]: DashboardPositionValue;
+}
+export interface CreateDashboardInterface {
+    id: number;
+    title: string | null;
+    slug: string | null;
+    description: string | null;
+    positionJson: DashboardPositionJson | null;
+    isPublished: boolean;
+    tenantIdentifier: string;
+    charts: Array<number>;
+    roles: Array<string>;
+    supersetId: number | null;
+}
+export interface UpdateDashboardInterface {
+    title: string | null;
+    slug: string | null;
+    description: string | null;
+    positionJson: DashboardPositionJson | null;
+    isPublished: boolean;
+    roles: Array<string>;
+    charts: Array<number>;
+    supersetId: number | null;
+}
+export interface DashboardInterface extends CreateDashboardInterface {
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface DashboardExportInterface {
+    exportData: DashboardInterface;
+    exportType: string;
+    exportedAt: string;
+}

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { FiltersInterface } from './filters.interface';
+export declare const CollectionSchema: z.ZodObject<{
+    collection: z.ZodString;
+    filters: z.ZodOptional<z.ZodType<FiltersInterface, unknown, z.core.$ZodTypeInternals<FiltersInterface, unknown>>>;
+}, z.core.$strip>;
+export interface CollectionInterface {
+    collection: string;
+    filters?: FiltersInterface;
+}

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

@@ -0,0 +1,5 @@
+import { DatasetInterface } from './dataset.interface';
+export interface DatasetRecordInterface extends DatasetInterface {
+    id: string;
+    tenantId: string;
+}

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

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+import { DatasetTypeEnum } from '../type-enums';
+import { CollectionInterface } from './collection.interface';
+import { DimensionsInterface } from './dimensions.interface';
+import { SegmentsInterface } from './segments.interface';
+import { RelationsInterface } from './relations.interface';
+import { MeasuresInterface } from './measures.interface';
+import { MetaInterface } from './meta.interface';
+import { PreAggregationsInterface } from './pre-aggregations.interface';
+export declare const DatasetSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<typeof 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("./filters.interface").FiltersInterface, unknown, z.core.$ZodTypeInternals<import("./filters.interface").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>;
+export interface DatasetInterface {
+    name: string;
+    description: string;
+    type: DatasetTypeEnum;
+    prefix: string;
+    parent?: string;
+    sql?: string;
+    refreshSql?: string;
+    meta?: MetaInterface;
+    collection?: CollectionInterface;
+    dimensions?: DimensionsInterface;
+    segments?: SegmentsInterface;
+    relations?: RelationsInterface;
+    measures?: MeasuresInterface;
+    preAggregations?: PreAggregationsInterface;
+}