@keboola/api-client 20.0.0 → 23.0.0

package/dist/sdk/semanticLayer/index.d.cts

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+import { SemanticChildObjectType, MetastoreClient, SemanticObject, SemanticModelData, CreateSemanticObjectMeta, UpdateSemanticObjectMeta, SemanticChildObjectDataMap, SemanticDatasetData, SemanticMetricData, SemanticRelationshipData, SemanticGlossaryData, SemanticConstraintData } from './types.cjs';
+import '../../metastore/index.cjs';
+import '../../types-22LtuLPM.cjs';
+import '../../types-BbM5WDSR.cjs';
+import '../../createOpenapiFetchClient-pguVgT7R.cjs';
+import '../../types-DqxZDbM1.cjs';
+import 'qs';
+
+/**
+ * Runtime validators for the semantic-layer payload shapes.
+ *
+ * These exist because the metastore's validation errors are opaque — a missing or misspelled
+ * field surfaces only as a generic "Validation failed", and a wrong `sql_dialect` casing as a
+ * 422 that names neither the field nor the accepted values. Parsing first turns those into a
+ * message that says what is wrong.
+ *
+ * **Only the fields the SDK types mark as required are declared.** The metastore owns each
+ * object type's full schema, so every schema is a `looseObject`: unknown fields pass through
+ * untouched rather than being stripped or rejected. Re-declaring the optional fields here
+ * would create a second source of truth that silently drops whatever the metastore adds next.
+ *
+ * The SDK does **not** parse on its own writes — these are for callers that accept untrusted
+ * or hand-authored input (an agent's tool call, a form submission) and want to fail early.
+ * `modelUUID` is omitted throughout: the SDK injects it, so callers never supply it.
+ */
+declare const semanticModelSchema: z.ZodObject<{
+    name: z.ZodString;
+    sql_dialect: z.ZodEnum<{
+        Snowflake: "Snowflake";
+        BigQuery: "BigQuery";
+    }>;
+}, z.core.$loose>;
+declare const semanticDatasetSchema: z.ZodObject<{
+    name: z.ZodString;
+    tableId: z.ZodString;
+    fqn: z.ZodString;
+}, z.core.$loose>;
+declare const semanticMetricSchema: z.ZodObject<{
+    name: z.ZodString;
+    sql: z.ZodString;
+}, z.core.$loose>;
+declare const semanticRelationshipSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    on: z.ZodString;
+}, z.core.$loose>;
+declare const semanticGlossarySchema: z.ZodObject<{
+    term: z.ZodString;
+    definition: z.ZodString;
+}, z.core.$loose>;
+declare const semanticConstraintSchema: z.ZodObject<{
+    name: z.ZodString;
+    constraintType: z.ZodEnum<{
+        inequality: "inequality";
+        equality: "equality";
+        range: "range";
+        composition: "composition";
+        exclusion: "exclusion";
+        temporal: "temporal";
+        conditional: "conditional";
+    }>;
+    metrics: z.ZodArray<z.ZodString>;
+    rule: z.ZodString;
+}, z.core.$loose>;
+/** Keyed by object type so a caller can pick the schema from a `SemanticChildObjectType`. */
+declare const SEMANTIC_CHILD_OBJECT_SCHEMAS: {
+    readonly 'semantic-dataset': z.ZodObject<{
+        name: z.ZodString;
+        tableId: z.ZodString;
+        fqn: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-metric': z.ZodObject<{
+        name: z.ZodString;
+        sql: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-relationship': z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        on: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-glossary': z.ZodObject<{
+        term: z.ZodString;
+        definition: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-constraint': z.ZodObject<{
+        name: z.ZodString;
+        constraintType: z.ZodEnum<{
+            inequality: "inequality";
+            equality: "equality";
+            range: "range";
+            composition: "composition";
+            exclusion: "exclusion";
+            temporal: "temporal";
+            conditional: "conditional";
+        }>;
+        metrics: z.ZodArray<z.ZodString>;
+        rule: z.ZodString;
+    }, z.core.$loose>;
+};
+
+declare const SEMANTIC_OBJECT_TYPE: {
+    readonly MODEL: "semantic-model";
+    readonly DATASET: "semantic-dataset";
+    readonly METRIC: "semantic-metric";
+    readonly RELATIONSHIP: "semantic-relationship";
+    readonly GLOSSARY: "semantic-glossary";
+    readonly CONSTRAINT: "semantic-constraint";
+};
+/**
+ * `readonly` because this drives `createModelTree`, `listModelChildren` and `deleteModel` —
+ * a consumer-side `.push()` would silently change what a cascade delete touches.
+ */
+declare const MODEL_CHILD_OBJECT_TYPES: readonly SemanticChildObjectType[];
+/**
+ * The dialects the metastore accepts, exactly as it spells them. A lowercase value is
+ * rejected with `422 value must be one of 'Snowflake', 'BigQuery'`, which surfaces only as a
+ * generic "Validation failed" — so callers need the real set rather than a bare `string`.
+ *
+ * `SemanticModelData.sql_dialect` stays `string` for now: narrowing it would break any caller
+ * passing a `string` variable, which is a major bump. Validate against this instead.
+ */
+declare const SQL_DIALECTS: readonly ["Snowflake", "BigQuery"];
+/** The metastore's constraint kinds. Runtime counterpart to `SemanticConstraintType`. */
+declare const CONSTRAINT_TYPES: readonly ["inequality", "equality", "range", "composition", "exclusion", "temporal", "conditional"];
+type Options = {
+    metastoreClient: MetastoreClient;
+};
+declare const createSemanticLayerSdk: ({ metastoreClient }: Options) => {
+    listModels: (signal?: AbortSignal) => Promise<SemanticObject<SemanticModelData>[]>;
+    createModel: (data: SemanticModelData, meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticModelData>>;
+    updateModel: (modelUUID: string, data: Partial<SemanticModelData>, meta?: UpdateSemanticObjectMeta) => Promise<SemanticObject<SemanticModelData>>;
+    deleteModel: (modelUUID: string) => Promise<void>;
+    listModelChildren: (modelUUID: string, signal?: AbortSignal) => Promise<{
+        objectType: keyof SemanticChildObjectDataMap;
+        objectUUID: string;
+        name: string | undefined;
+    }[]>;
+    listObjects: <T extends SemanticChildObjectType>(objectType: T, modelUUID: string, signal?: AbortSignal) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
+    findObjectsByName: <T extends SemanticChildObjectType>(objectType: T, name: string, modelUUID: string, signal?: AbortSignal) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
+    createObject: <T extends SemanticChildObjectType>(objectType: T, data: SemanticChildObjectDataMap[T], meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>>;
+    createObjects: <T extends SemanticChildObjectType>(objectType: T, items: SemanticChildObjectDataMap[T][], meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
+    createModelTree: (model: SemanticModelData, children: Partial<{ [T in SemanticChildObjectType]: Omit<SemanticChildObjectDataMap[T], "modelUUID">[]; }>, meta?: CreateSemanticObjectMeta) => Promise<{
+        model: SemanticObject<SemanticModelData>;
+        children: SemanticObject<SemanticDatasetData | SemanticMetricData | SemanticRelationshipData | SemanticGlossaryData | SemanticConstraintData>[];
+    }>;
+    updateObject: <T extends SemanticChildObjectType>(objectType: T, objectUUID: string, data: Partial<SemanticChildObjectDataMap[T]>, meta?: UpdateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>>;
+    deleteObject: (objectType: SemanticChildObjectType, objectUUID: string) => Promise<void>;
+};
+
+export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };

package/dist/sdk/semanticLayer/index.d.ts

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+import { SemanticChildObjectType, MetastoreClient, SemanticObject, SemanticModelData, CreateSemanticObjectMeta, UpdateSemanticObjectMeta, SemanticChildObjectDataMap, SemanticDatasetData, SemanticMetricData, SemanticRelationshipData, SemanticGlossaryData, SemanticConstraintData } from './types.js';
+import '../../metastore/index.js';
+import '../../types-Dz4Yc-Mu.js';
+import '../../types-BbM5WDSR.js';
+import '../../createOpenapiFetchClient-BX7_szVZ.js';
+import '../../types-DqxZDbM1.js';
+import 'qs';
+
+/**
+ * Runtime validators for the semantic-layer payload shapes.
+ *
+ * These exist because the metastore's validation errors are opaque — a missing or misspelled
+ * field surfaces only as a generic "Validation failed", and a wrong `sql_dialect` casing as a
+ * 422 that names neither the field nor the accepted values. Parsing first turns those into a
+ * message that says what is wrong.
+ *
+ * **Only the fields the SDK types mark as required are declared.** The metastore owns each
+ * object type's full schema, so every schema is a `looseObject`: unknown fields pass through
+ * untouched rather than being stripped or rejected. Re-declaring the optional fields here
+ * would create a second source of truth that silently drops whatever the metastore adds next.
+ *
+ * The SDK does **not** parse on its own writes — these are for callers that accept untrusted
+ * or hand-authored input (an agent's tool call, a form submission) and want to fail early.
+ * `modelUUID` is omitted throughout: the SDK injects it, so callers never supply it.
+ */
+declare const semanticModelSchema: z.ZodObject<{
+    name: z.ZodString;
+    sql_dialect: z.ZodEnum<{
+        Snowflake: "Snowflake";
+        BigQuery: "BigQuery";
+    }>;
+}, z.core.$loose>;
+declare const semanticDatasetSchema: z.ZodObject<{
+    name: z.ZodString;
+    tableId: z.ZodString;
+    fqn: z.ZodString;
+}, z.core.$loose>;
+declare const semanticMetricSchema: z.ZodObject<{
+    name: z.ZodString;
+    sql: z.ZodString;
+}, z.core.$loose>;
+declare const semanticRelationshipSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    on: z.ZodString;
+}, z.core.$loose>;
+declare const semanticGlossarySchema: z.ZodObject<{
+    term: z.ZodString;
+    definition: z.ZodString;
+}, z.core.$loose>;
+declare const semanticConstraintSchema: z.ZodObject<{
+    name: z.ZodString;
+    constraintType: z.ZodEnum<{
+        inequality: "inequality";
+        equality: "equality";
+        range: "range";
+        composition: "composition";
+        exclusion: "exclusion";
+        temporal: "temporal";
+        conditional: "conditional";
+    }>;
+    metrics: z.ZodArray<z.ZodString>;
+    rule: z.ZodString;
+}, z.core.$loose>;
+/** Keyed by object type so a caller can pick the schema from a `SemanticChildObjectType`. */
+declare const SEMANTIC_CHILD_OBJECT_SCHEMAS: {
+    readonly 'semantic-dataset': z.ZodObject<{
+        name: z.ZodString;
+        tableId: z.ZodString;
+        fqn: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-metric': z.ZodObject<{
+        name: z.ZodString;
+        sql: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-relationship': z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        on: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-glossary': z.ZodObject<{
+        term: z.ZodString;
+        definition: z.ZodString;
+    }, z.core.$loose>;
+    readonly 'semantic-constraint': z.ZodObject<{
+        name: z.ZodString;
+        constraintType: z.ZodEnum<{
+            inequality: "inequality";
+            equality: "equality";
+            range: "range";
+            composition: "composition";
+            exclusion: "exclusion";
+            temporal: "temporal";
+            conditional: "conditional";
+        }>;
+        metrics: z.ZodArray<z.ZodString>;
+        rule: z.ZodString;
+    }, z.core.$loose>;
+};
+
+declare const SEMANTIC_OBJECT_TYPE: {
+    readonly MODEL: "semantic-model";
+    readonly DATASET: "semantic-dataset";
+    readonly METRIC: "semantic-metric";
+    readonly RELATIONSHIP: "semantic-relationship";
+    readonly GLOSSARY: "semantic-glossary";
+    readonly CONSTRAINT: "semantic-constraint";
+};
+/**
+ * `readonly` because this drives `createModelTree`, `listModelChildren` and `deleteModel` —
+ * a consumer-side `.push()` would silently change what a cascade delete touches.
+ */
+declare const MODEL_CHILD_OBJECT_TYPES: readonly SemanticChildObjectType[];
+/**
+ * The dialects the metastore accepts, exactly as it spells them. A lowercase value is
+ * rejected with `422 value must be one of 'Snowflake', 'BigQuery'`, which surfaces only as a
+ * generic "Validation failed" — so callers need the real set rather than a bare `string`.
+ *
+ * `SemanticModelData.sql_dialect` stays `string` for now: narrowing it would break any caller
+ * passing a `string` variable, which is a major bump. Validate against this instead.
+ */
+declare const SQL_DIALECTS: readonly ["Snowflake", "BigQuery"];
+/** The metastore's constraint kinds. Runtime counterpart to `SemanticConstraintType`. */
+declare const CONSTRAINT_TYPES: readonly ["inequality", "equality", "range", "composition", "exclusion", "temporal", "conditional"];
+type Options = {
+    metastoreClient: MetastoreClient;
+};
+declare const createSemanticLayerSdk: ({ metastoreClient }: Options) => {
+    listModels: (signal?: AbortSignal) => Promise<SemanticObject<SemanticModelData>[]>;
+    createModel: (data: SemanticModelData, meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticModelData>>;
+    updateModel: (modelUUID: string, data: Partial<SemanticModelData>, meta?: UpdateSemanticObjectMeta) => Promise<SemanticObject<SemanticModelData>>;
+    deleteModel: (modelUUID: string) => Promise<void>;
+    listModelChildren: (modelUUID: string, signal?: AbortSignal) => Promise<{
+        objectType: keyof SemanticChildObjectDataMap;
+        objectUUID: string;
+        name: string | undefined;
+    }[]>;
+    listObjects: <T extends SemanticChildObjectType>(objectType: T, modelUUID: string, signal?: AbortSignal) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
+    findObjectsByName: <T extends SemanticChildObjectType>(objectType: T, name: string, modelUUID: string, signal?: AbortSignal) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
+    createObject: <T extends SemanticChildObjectType>(objectType: T, data: SemanticChildObjectDataMap[T], meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>>;
+    createObjects: <T extends SemanticChildObjectType>(objectType: T, items: SemanticChildObjectDataMap[T][], meta?: CreateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>[]>;
+    createModelTree: (model: SemanticModelData, children: Partial<{ [T in SemanticChildObjectType]: Omit<SemanticChildObjectDataMap[T], "modelUUID">[]; }>, meta?: CreateSemanticObjectMeta) => Promise<{
+        model: SemanticObject<SemanticModelData>;
+        children: SemanticObject<SemanticDatasetData | SemanticMetricData | SemanticRelationshipData | SemanticGlossaryData | SemanticConstraintData>[];
+    }>;
+    updateObject: <T extends SemanticChildObjectType>(objectType: T, objectUUID: string, data: Partial<SemanticChildObjectDataMap[T]>, meta?: UpdateSemanticObjectMeta) => Promise<SemanticObject<SemanticChildObjectDataMap[T]>>;
+    deleteObject: (objectType: SemanticChildObjectType, objectUUID: string) => Promise<void>;
+};
+
+export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };

package/dist/sdk/semanticLayer/index.js

@@ -0,0 +1,5 @@
+export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema } from '../../chunk-UP5SEEYZ.js';
+import '../../chunk-T526LPBK.js';
+import '../../chunk-SJZ66FD5.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/sdk/semanticLayer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/sdk/semanticLayer/types.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=types.cjs.map
+//# sourceMappingURL=types.cjs.map

package/dist/sdk/semanticLayer/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.cjs"}

package/dist/sdk/semanticLayer/types.d.cts

@@ -0,0 +1,132 @@
+import { createMetastoreClient } from '../../metastore/index.cjs';
+import { C as CreateMetaObjectInput, U as UpdateMetaObjectInput } from '../../types-22LtuLPM.cjs';
+import '../../createOpenapiFetchClient-pguVgT7R.cjs';
+import '../../types-DqxZDbM1.cjs';
+import 'qs';
+import '../../types-BbM5WDSR.cjs';
+
+type MetastoreClient = ReturnType<typeof createMetastoreClient>;
+
+type SemanticFieldRole = 'key' | 'dimension' | 'measure' | 'timestamp';
+type SemanticAiMetadata = {
+    synonyms?: string[];
+    keywords?: string[];
+    antiKeywords?: string[];
+    hints?: string[];
+    warnings?: string[];
+};
+type SemanticModelData = {
+    name: string;
+    description?: string;
+    sql_dialect: string;
+};
+type SemanticFieldData = {
+    name: string;
+    description?: string;
+    type?: string;
+    role?: SemanticFieldRole;
+    values?: string[];
+    ai?: SemanticAiMetadata;
+};
+type SemanticDatasetData = {
+    modelUUID: string;
+    name: string;
+    tableId: string;
+    fqn: string;
+    description?: string;
+    grain?: string;
+    primaryKey?: string[];
+    fields?: SemanticFieldData[];
+    ai?: SemanticAiMetadata;
+};
+type SemanticMetricData = {
+    modelUUID: string;
+    name: string;
+    sql: string;
+    dataset?: string;
+    description?: string;
+};
+type SemanticRelationshipData = {
+    modelUUID: string;
+    name?: string;
+    from: string;
+    to: string;
+    on: string;
+    type?: 'left' | 'inner';
+};
+type SemanticGlossaryData = {
+    modelUUID: string;
+    term: string;
+    definition: string;
+    seeAlso?: string[];
+};
+type SemanticConstraintType = 'inequality' | 'equality' | 'range' | 'composition' | 'exclusion' | 'temporal' | 'conditional';
+type SemanticConstraintScope = 'global' | 'per_location' | 'per_date' | 'per_category';
+type SemanticRuleOperator = '<' | '<=' | '=' | '>=' | '>' | '!=' | 'between' | 'in' | 'sum_equals' | 'ratio_between';
+type SemanticRuleExpression = {
+    operator?: SemanticRuleOperator;
+    left?: string;
+    right?: string;
+    bounds?: {
+        min?: number;
+        max?: number;
+    };
+};
+type SemanticValidationQuery = {
+    default?: string;
+    snowflake?: string;
+    bigquery?: string;
+};
+type SemanticConstraintData = {
+    modelUUID: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    constraintType: SemanticConstraintType;
+    metrics: string[];
+    datasets?: string[];
+    rule: string;
+    ruleExpression?: SemanticRuleExpression;
+    validationQuery?: SemanticValidationQuery;
+    severity?: 'error' | 'warning' | 'info';
+    errorMessage?: string;
+    remediation?: string;
+    isActive?: boolean;
+    scope?: SemanticConstraintScope;
+    owner?: string;
+    tags?: string[];
+};
+type SemanticChildObjectDataMap = {
+    'semantic-dataset': SemanticDatasetData;
+    'semantic-metric': SemanticMetricData;
+    'semantic-relationship': SemanticRelationshipData;
+    'semantic-glossary': SemanticGlossaryData;
+    'semantic-constraint': SemanticConstraintData;
+};
+type SemanticChildObjectType = keyof SemanticChildObjectDataMap;
+type SemanticObjectType = SemanticChildObjectType | 'semantic-model';
+type SemanticObjectMeta = {
+    name?: string;
+    branch?: string;
+    projectId?: number;
+    organizationId?: string;
+    revision?: number;
+    schemaVersion?: string;
+    createdAt?: string;
+    lastUpdated?: string;
+    revisionCreatedAt?: string;
+};
+/**
+ * Normalized metastore object as returned by this SDK. Matches the live metastore
+ * envelope ({ type, id, attributes: <data payload>, meta: {...} }), which differs
+ * from the legacy wrapper types in clients/metastore/repository/types.ts.
+ */
+type SemanticObject<TData> = {
+    uuid: string;
+    data: TData;
+    meta: SemanticObjectMeta;
+};
+type CreateSemanticObjectMeta = Omit<CreateMetaObjectInput, 'data' | 'objectType'>;
+type UpdateSemanticObjectMeta = Omit<UpdateMetaObjectInput, 'data' | 'objectType' | 'UUID'>;
+
+export type { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRuleExpression, SemanticRuleOperator, SemanticValidationQuery, UpdateSemanticObjectMeta };

package/dist/sdk/semanticLayer/types.d.ts

@@ -0,0 +1,132 @@
+import { createMetastoreClient } from '../../metastore/index.js';
+import { C as CreateMetaObjectInput, U as UpdateMetaObjectInput } from '../../types-Dz4Yc-Mu.js';
+import '../../createOpenapiFetchClient-BX7_szVZ.js';
+import '../../types-DqxZDbM1.js';
+import 'qs';
+import '../../types-BbM5WDSR.js';
+
+type MetastoreClient = ReturnType<typeof createMetastoreClient>;
+
+type SemanticFieldRole = 'key' | 'dimension' | 'measure' | 'timestamp';
+type SemanticAiMetadata = {
+    synonyms?: string[];
+    keywords?: string[];
+    antiKeywords?: string[];
+    hints?: string[];
+    warnings?: string[];
+};
+type SemanticModelData = {
+    name: string;
+    description?: string;
+    sql_dialect: string;
+};
+type SemanticFieldData = {
+    name: string;
+    description?: string;
+    type?: string;
+    role?: SemanticFieldRole;
+    values?: string[];
+    ai?: SemanticAiMetadata;
+};
+type SemanticDatasetData = {
+    modelUUID: string;
+    name: string;
+    tableId: string;
+    fqn: string;
+    description?: string;
+    grain?: string;
+    primaryKey?: string[];
+    fields?: SemanticFieldData[];
+    ai?: SemanticAiMetadata;
+};
+type SemanticMetricData = {
+    modelUUID: string;
+    name: string;
+    sql: string;
+    dataset?: string;
+    description?: string;
+};
+type SemanticRelationshipData = {
+    modelUUID: string;
+    name?: string;
+    from: string;
+    to: string;
+    on: string;
+    type?: 'left' | 'inner';
+};
+type SemanticGlossaryData = {
+    modelUUID: string;
+    term: string;
+    definition: string;
+    seeAlso?: string[];
+};
+type SemanticConstraintType = 'inequality' | 'equality' | 'range' | 'composition' | 'exclusion' | 'temporal' | 'conditional';
+type SemanticConstraintScope = 'global' | 'per_location' | 'per_date' | 'per_category';
+type SemanticRuleOperator = '<' | '<=' | '=' | '>=' | '>' | '!=' | 'between' | 'in' | 'sum_equals' | 'ratio_between';
+type SemanticRuleExpression = {
+    operator?: SemanticRuleOperator;
+    left?: string;
+    right?: string;
+    bounds?: {
+        min?: number;
+        max?: number;
+    };
+};
+type SemanticValidationQuery = {
+    default?: string;
+    snowflake?: string;
+    bigquery?: string;
+};
+type SemanticConstraintData = {
+    modelUUID: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    constraintType: SemanticConstraintType;
+    metrics: string[];
+    datasets?: string[];
+    rule: string;
+    ruleExpression?: SemanticRuleExpression;
+    validationQuery?: SemanticValidationQuery;
+    severity?: 'error' | 'warning' | 'info';
+    errorMessage?: string;
+    remediation?: string;
+    isActive?: boolean;
+    scope?: SemanticConstraintScope;
+    owner?: string;
+    tags?: string[];
+};
+type SemanticChildObjectDataMap = {
+    'semantic-dataset': SemanticDatasetData;
+    'semantic-metric': SemanticMetricData;
+    'semantic-relationship': SemanticRelationshipData;
+    'semantic-glossary': SemanticGlossaryData;
+    'semantic-constraint': SemanticConstraintData;
+};
+type SemanticChildObjectType = keyof SemanticChildObjectDataMap;
+type SemanticObjectType = SemanticChildObjectType | 'semantic-model';
+type SemanticObjectMeta = {
+    name?: string;
+    branch?: string;
+    projectId?: number;
+    organizationId?: string;
+    revision?: number;
+    schemaVersion?: string;
+    createdAt?: string;
+    lastUpdated?: string;
+    revisionCreatedAt?: string;
+};
+/**
+ * Normalized metastore object as returned by this SDK. Matches the live metastore
+ * envelope ({ type, id, attributes: <data payload>, meta: {...} }), which differs
+ * from the legacy wrapper types in clients/metastore/repository/types.ts.
+ */
+type SemanticObject<TData> = {
+    uuid: string;
+    data: TData;
+    meta: SemanticObjectMeta;
+};
+type CreateSemanticObjectMeta = Omit<CreateMetaObjectInput, 'data' | 'objectType'>;
+type UpdateSemanticObjectMeta = Omit<UpdateMetaObjectInput, 'data' | 'objectType' | 'UUID'>;
+
+export type { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRuleExpression, SemanticRuleOperator, SemanticValidationQuery, UpdateSemanticObjectMeta };

package/dist/sdk/semanticLayer/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/sdk/semanticLayer/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/dist/sdk/storage/index.cjs

@@ -1,48 +1,49 @@
 'use strict';
 
-var chunkAWRMGLMT_cjs = require('../../chunk-AWRMGLMT.cjs');
+var chunk35MODDCL_cjs = require('../../chunk-35MODDCL.cjs');
+require('../../chunk-QHD4LPAQ.cjs');
 
 
 
 Object.defineProperty(exports, "FQID_TYPES", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.FQID_TYPES; }
+  get: function () { return chunk35MODDCL_cjs.FQID_TYPES; }
 });
 Object.defineProperty(exports, "constructFQID", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.constructFQID; }
+  get: function () { return chunk35MODDCL_cjs.constructFQID; }
 });
 Object.defineProperty(exports, "createStorageSdk", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.createStorageSdk; }
+  get: function () { return chunk35MODDCL_cjs.createStorageSdk; }
 });
 Object.defineProperty(exports, "parse", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.parse; }
+  get: function () { return chunk35MODDCL_cjs.parse; }
 });
 Object.defineProperty(exports, "parseCurrentDevBranchIdFromUrl", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.parseCurrentDevBranchIdFromUrl; }
+  get: function () { return chunk35MODDCL_cjs.parseCurrentDevBranchIdFromUrl; }
 });
 Object.defineProperty(exports, "parseDevBranchId", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.parseDevBranchId; }
+  get: function () { return chunk35MODDCL_cjs.parseDevBranchId; }
 });
 Object.defineProperty(exports, "parseFQID", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.parseFQID; }
+  get: function () { return chunk35MODDCL_cjs.parseFQID; }
 });
 Object.defineProperty(exports, "prefixTagsWithDevBranchId", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.prefixTagsWithDevBranchId; }
+  get: function () { return chunk35MODDCL_cjs.prefixTagsWithDevBranchId; }
 });
 Object.defineProperty(exports, "removeBranchFromUrl", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.removeBranchFromUrl; }
+  get: function () { return chunk35MODDCL_cjs.removeBranchFromUrl; }
 });
 Object.defineProperty(exports, "tableIdParser", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.tableIdParser; }
+  get: function () { return chunk35MODDCL_cjs.tableIdParser; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map