@keboola/api-client 32.0.0 → 34.0.0

package/dist/sdk/semanticLayer/index.cjs

@@ -1,360 +1,22 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_concurrent = require("../../concurrent-tbiIa0UL.cjs");
-const require_generateUUID = require("../../generateUUID-C6qKBPIv.cjs");
-let zod = require("zod");
-//#region src/sdks/semanticLayer/semanticLayerSdk.ts
-/**
-* Thrown by `deleteModel` when the child cascade partially fails. Every child delete has
-* settled by the time this is thrown — nothing keeps deleting in the background — and the
-* model itself was kept, so the exact remaining state is knowable: `deletedChildren` are gone,
-* `failedChildren` (and the model) still exist. `errors` carries the per-child rejection
-* reasons, AggregateError-style.
-*/
-var SemanticLayerCascadeDeleteError = class extends AggregateError {
-	modelUUID;
-	deletedChildren;
-	failedChildren;
-	constructor({ modelUUID, deletedChildren, failedChildren }) {
-		const total = deletedChildren.length + failedChildren.length;
-		super(failedChildren.map((failure) => failure.error), `The model was kept because ${failedChildren.length} of its ${total} child objects could not be deleted (${deletedChildren.length} deleted).`);
-		this.name = "SemanticLayerCascadeDeleteError";
-		this.modelUUID = modelUUID;
-		this.deletedChildren = deletedChildren;
-		this.failedChildren = failedChildren;
-	}
-};
-const SEMANTIC_OBJECT_TYPE = {
-	MODEL: "semantic-model",
-	DATASET: "semantic-dataset",
-	METRIC: "semantic-metric",
-	RELATIONSHIP: "semantic-relationship",
-	GLOSSARY: "semantic-glossary",
-	CONSTRAINT: "semantic-constraint"
-};
-/**
-* `readonly` because this drives `createModelTree`, `listModelChildren` and `deleteModel` —
-* a consumer-side `.push()` would silently change what a cascade delete touches.
-*/
-const MODEL_CHILD_OBJECT_TYPES = [
-	SEMANTIC_OBJECT_TYPE.DATASET,
-	SEMANTIC_OBJECT_TYPE.METRIC,
-	SEMANTIC_OBJECT_TYPE.RELATIONSHIP,
-	SEMANTIC_OBJECT_TYPE.GLOSSARY,
-	SEMANTIC_OBJECT_TYPE.CONSTRAINT
-];
-/**
-* 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.
-*/
-const SQL_DIALECTS = ["Snowflake", "BigQuery"];
-/** The metastore's constraint kinds. Runtime counterpart to `SemanticConstraintType`. */
-const CONSTRAINT_TYPES = [
-	"inequality",
-	"equality",
-	"range",
-	"composition",
-	"exclusion",
-	"temporal",
-	"conditional"
-];
-const DEFAULT_BRANCH = "main";
-const WRITE_CONCURRENCY = 5;
-const mapObject = (item) => ({
-	uuid: item.id,
-	data: item.attributes,
-	meta: item.meta
-});
-const deriveOptionalObjectName = (data) => {
-	if (typeof data.name === "string") return data.name;
-	if (typeof data.term === "string") return data.term;
-};
-const deriveObjectName = (data) => deriveOptionalObjectName(data) ?? require_generateUUID.generateUUID();
-/**
-* The label a UI shows for an object, as opposed to the identifier it is addressed by.
-*
-* Constraints carry an optional `displayName`; kbc-ui's constraint tables already render
-* `displayName ?? name`, so a confirmation listing what a cascade delete would destroy has to
-* agree with them or it names objects the user can't find on screen.
-*
-* Deliberately **not** used for lookup: `displayName` is optional and not unique, so matching on
-* it would make `findObjectsByName` ambiguous for callers that resolve a write target by name.
-*/
-const deriveObjectLabel = (data) => {
-	if (typeof data.displayName === "string" && data.displayName !== "") return data.displayName;
-	return deriveOptionalObjectName(data);
-};
-const createSemanticLayerSdk = ({ metastoreClient }) => {
-	const _listObjects = async (objectType, signal) => {
-		return (await metastoreClient.repository.getMetaObjects({ objectType }, signal)).data.map(mapObject);
-	};
-	const listModels = async (signal) => _listObjects(SEMANTIC_OBJECT_TYPE.MODEL, signal);
-	const createModel = async (data, meta = {}) => {
-		const response = await metastoreClient.repository.createMetaObject({
-			objectType: SEMANTIC_OBJECT_TYPE.MODEL,
-			data,
-			branch: DEFAULT_BRANCH,
-			...meta,
-			name: data.name
-		});
-		return mapObject(response.data);
-	};
-	const updateModel = async (modelUUID, data, meta = {}) => {
-		const response = await metastoreClient.repository.updateMetaObject({
-			objectType: SEMANTIC_OBJECT_TYPE.MODEL,
-			UUID: modelUUID,
-			data,
-			...meta,
-			...data.name ? { name: data.name } : {}
-		});
-		return mapObject(response.data);
-	};
-	const listObjects = async (objectType, modelUUID, signal) => {
-		return (await _listObjects(objectType, signal)).filter((object) => object.data.modelUUID === modelUUID);
-	};
-	/**
-	* Find a model's child objects by their user-facing name.
-	*
-	* Returns every match rather than resolving to one, because a name is not unique: the caller
-	* decides whether that's an error (an agent needs an unambiguous target) or a choice to offer
-	* (a UI can render a picker). Glossary entries key on `term`, so both are matched.
-	*/
-	const findObjectsByName = async (objectType, name, modelUUID, signal) => {
-		return (await listObjects(objectType, modelUUID, signal)).filter((object) => deriveOptionalObjectName(object.data) === name);
-	};
-	const createObject = async (objectType, data, meta = {}) => {
-		const response = await metastoreClient.repository.createMetaObject({
-			objectType,
-			data,
-			branch: DEFAULT_BRANCH,
-			...meta,
-			name: deriveObjectName(data)
-		});
-		return mapObject(response.data);
-	};
-	const createObjects = async (objectType, items, meta = {}) => require_concurrent.concurrent({
-		items,
-		process: async (data) => createObject(objectType, data, meta),
-		concurrency: WRITE_CONCURRENCY
-	});
-	const createModelTree = async (model, children, meta = {}) => {
-		const createdModel = await createModel(model, meta);
-		const items = MODEL_CHILD_OBJECT_TYPES.flatMap((objectType) => (children[objectType] ?? []).map((data) => ({
-			objectType,
-			data: {
-				...data,
-				modelUUID: createdModel.uuid
-			}
-		})));
-		return {
-			model: createdModel,
-			children: await require_concurrent.concurrent({
-				items,
-				process: async ({ objectType, data }) => createObject(objectType, data, meta),
-				concurrency: WRITE_CONCURRENCY
-			})
-		};
-	};
-	const updateObject = async (objectType, objectUUID, data, meta = {}) => {
-		const name = deriveOptionalObjectName(data);
-		const response = await metastoreClient.repository.updateMetaObject({
-			objectType,
-			UUID: objectUUID,
-			data,
-			...meta,
-			...name ? { name } : {}
-		});
-		return mapObject(response.data);
-	};
-	const deleteObject = async (objectType, objectUUID) => {
-		await metastoreClient.repository.deleteMetaObject({
-			objectType,
-			UUID: objectUUID
-		});
-	};
-	/**
-	* Every child object of a model, across all five types, flattened.
-	*
-	* `deleteModel` uses this to find what to remove; callers can use it to say what a delete
-	* would destroy *before* asking the user to confirm. Each entry's `name` is the object's
-	* display label (a constraint's `displayName` in preference to its `name`, matching what the
-	* SL tables render), so a confirmation lists objects as the user sees them on screen.
-	*
-	* Costs five list requests: the metastore has no per-model filter, so `listObjects`
-	* fetches each collection and filters client-side.
-	*/
-	const listModelChildren = async (modelUUID, signal) => {
-		return (await Promise.all(MODEL_CHILD_OBJECT_TYPES.map(async (objectType) => {
-			return (await listObjects(objectType, modelUUID, signal)).map((object) => ({
-				objectType,
-				objectUUID: object.uuid,
-				name: deriveObjectLabel(object.data)
-			}));
-		}))).flat();
-	};
-	/**
-	* Cascade delete: every child object first, the model itself only once its whole tree is
-	* gone. Child deletes all settle — a failing child never aborts the others, so no delete
-	* runs on detached after this rejects — and a partial failure surfaces as
-	* `SemanticLayerCascadeDeleteError`, which says exactly which children were deleted and
-	* which survived. The model is kept on any child failure so it never orphans children.
-	*/
-	const deleteModel = async (modelUUID) => {
-		const children = await listModelChildren(modelUUID);
-		const outcomes = await require_concurrent.concurrent({
-			items: children,
-			process: async (child) => {
-				try {
-					await deleteObject(child.objectType, child.objectUUID);
-					return {
-						ok: true,
-						child
-					};
-				} catch (error) {
-					return {
-						ok: false,
-						child,
-						error
-					};
-				}
-			},
-			concurrency: WRITE_CONCURRENCY
-		});
-		const deletedChildren = [];
-		const failedChildren = [];
-		for (const outcome of outcomes) if (outcome.ok) deletedChildren.push(outcome.child);
-		else failedChildren.push({
-			...outcome.child,
-			error: outcome.error
-		});
-		if (failedChildren.length > 0) throw new SemanticLayerCascadeDeleteError({
-			modelUUID,
-			deletedChildren,
-			failedChildren
-		});
-		await metastoreClient.repository.deleteMetaObject({
-			objectType: SEMANTIC_OBJECT_TYPE.MODEL,
-			UUID: modelUUID
-		});
-	};
-	/**
-	* Replace the sibling projects granted GET/consumption access to a `targeted`-scope object.
-	*
-	* Passing an empty array clears every grant, leaving the object visible to its owning project
-	* only. A grant conveys read access alone — the target projects can consume the definition but
-	* never edit it, which is enforced metastore-side rather than here.
-	*/
-	const replaceTargetProjects = async (objectType, objectUUID, targetProjectIds) => {
-		await metastoreClient.repository.replaceTargetProjects({
-			objectType,
-			UUID: objectUUID,
-			targetProjectIds
-		});
-	};
-	/**
-	* Step a project-scoped object up to the organization scope, in place.
-	*
-	* The object keeps its UUID and revision history; the step-up writes a new revision whose
-	* `project_id` is null. Requires the caller to hold the organization-admin role for the target
-	* organization — a project-admin gets 403 from the metastore, which callers should surface
-	* rather than pre-empt (the same person is often both).
-	*/
-	const promoteToOrganizationScope = async (objectType, objectUUID) => {
-		const response = await metastoreClient.repository.updateMetaObject({
-			objectType,
-			UUID: objectUUID,
-			scope: "organization"
-		});
-		return mapObject(response.data);
-	};
-	return {
-		listModels,
-		createModel,
-		updateModel,
-		deleteModel,
-		listModelChildren,
-		listObjects,
-		findObjectsByName,
-		createObject,
-		createObjects,
-		createModelTree,
-		updateObject,
-		deleteObject,
-		replaceTargetProjects,
-		promoteToOrganizationScope
-	};
-};
-//#endregion
-//#region src/sdks/semanticLayer/schemas.ts
-/**
-* 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.
-*/
-const semanticModelSchema = zod.z.looseObject({
-	name: zod.z.string().min(1),
-	sql_dialect: zod.z.enum(SQL_DIALECTS)
-});
-const semanticDatasetSchema = zod.z.looseObject({
-	name: zod.z.string().min(1),
-	tableId: zod.z.string().min(1),
-	fqn: zod.z.string().min(1)
-});
-const semanticMetricSchema = zod.z.looseObject({
-	name: zod.z.string().min(1),
-	sql: zod.z.string().min(1)
-});
-const semanticRelationshipSchema = zod.z.looseObject({
-	from: zod.z.string().min(1),
-	to: zod.z.string().min(1),
-	on: zod.z.string().min(1)
-});
-const semanticGlossarySchema = zod.z.looseObject({
-	term: zod.z.string().min(1),
-	definition: zod.z.string().min(1)
-});
-const semanticConstraintSchema = zod.z.looseObject({
-	name: zod.z.string().min(1),
-	constraintType: zod.z.enum(CONSTRAINT_TYPES),
-	metrics: zod.z.array(zod.z.string()),
-	rule: zod.z.string().min(1)
-});
-/** Keyed by object type so a caller can pick the schema from a `SemanticChildObjectType`. */
-const SEMANTIC_CHILD_OBJECT_SCHEMAS = {
-	"semantic-dataset": semanticDatasetSchema,
-	"semantic-metric": semanticMetricSchema,
-	"semantic-relationship": semanticRelationshipSchema,
-	"semantic-glossary": semanticGlossarySchema,
-	"semantic-constraint": semanticConstraintSchema
-};
-//#endregion
-exports.CONSTRAINT_TYPES = CONSTRAINT_TYPES;
-exports.MODEL_CHILD_OBJECT_TYPES = MODEL_CHILD_OBJECT_TYPES;
-exports.SEMANTIC_CHILD_OBJECT_SCHEMAS = SEMANTIC_CHILD_OBJECT_SCHEMAS;
-exports.SEMANTIC_OBJECT_TYPE = SEMANTIC_OBJECT_TYPE;
-exports.SQL_DIALECTS = SQL_DIALECTS;
-exports.SemanticLayerCascadeDeleteError = SemanticLayerCascadeDeleteError;
-exports.createSemanticLayerSdk = createSemanticLayerSdk;
-exports.semanticConstraintSchema = semanticConstraintSchema;
-exports.semanticDatasetSchema = semanticDatasetSchema;
-exports.semanticGlossarySchema = semanticGlossarySchema;
-exports.semanticMetricSchema = semanticMetricSchema;
-exports.semanticModelSchema = semanticModelSchema;
-exports.semanticRelationshipSchema = semanticRelationshipSchema;
-
-//# sourceMappingURL=index.cjs.map
+const require_semanticLayer = require("../../semanticLayer-E0Vilu8u.cjs");
+exports.CONSTRAINT_SCOPES = require_semanticLayer.CONSTRAINT_SCOPES;
+exports.CONSTRAINT_SEVERITIES = require_semanticLayer.CONSTRAINT_SEVERITIES;
+exports.CONSTRAINT_TYPES = require_semanticLayer.CONSTRAINT_TYPES;
+exports.FIELD_ROLES = require_semanticLayer.FIELD_ROLES;
+exports.MODEL_CHILD_OBJECT_TYPES = require_semanticLayer.MODEL_CHILD_OBJECT_TYPES;
+exports.RELATIONSHIP_JOIN_TYPES = require_semanticLayer.RELATIONSHIP_JOIN_TYPES;
+exports.RULE_OPERATORS = require_semanticLayer.RULE_OPERATORS;
+exports.SEMANTIC_CHILD_OBJECT_SCHEMAS = require_semanticLayer.SEMANTIC_CHILD_OBJECT_SCHEMAS;
+exports.SEMANTIC_OBJECT_TYPE = require_semanticLayer.SEMANTIC_OBJECT_TYPE;
+exports.SQL_DIALECTS = require_semanticLayer.SQL_DIALECTS;
+exports.SemanticLayerCascadeDeleteError = require_semanticLayer.SemanticLayerCascadeDeleteError;
+exports.SemanticLayerUnreadableChildrenError = require_semanticLayer.SemanticLayerUnreadableChildrenError;
+exports.createSemanticLayerSdk = require_semanticLayer.createSemanticLayerSdk;
+exports.metastoreErrorMessage = require_semanticLayer.metastoreErrorMessage;
+exports.semanticConstraintSchema = require_semanticLayer.semanticConstraintSchema;
+exports.semanticDatasetSchema = require_semanticLayer.semanticDatasetSchema;
+exports.semanticGlossarySchema = require_semanticLayer.semanticGlossarySchema;
+exports.semanticMetricSchema = require_semanticLayer.semanticMetricSchema;
+exports.semanticModelSchema = require_semanticLayer.semanticModelSchema;
+exports.semanticRelationshipSchema = require_semanticLayer.semanticRelationshipSchema;

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

@@ -1,5 +1,19 @@
-import { _ as SemanticObject, a as SemanticChildObjectType, b as SemanticRelationshipData, f as SemanticGlossaryData, g as SemanticModelData, h as SemanticModelChildRef, i as SemanticChildObjectDataMap, l as SemanticDatasetData, m as SemanticModelChildDeleteFailure, n as MetastoreClient, o as SemanticConstraintData, p as SemanticMetricData, t as CreateSemanticObjectMeta, w as UpdateSemanticObjectMeta, y as SemanticObjectType } from "../../types-B2vmg_UF.cjs";
+import { A as CONSTRAINT_TYPES, D as UpdateSemanticObjectMeta, M as RELATIONSHIP_JOIN_TYPES, N as RULE_OPERATORS, O as CONSTRAINT_SCOPES, P as SQL_DIALECTS, T as SemanticUnreadableObjectRef, _ as SemanticModelData, a as SemanticChildObjectType, b as SemanticObjectType, g as SemanticModelChildRef, h as SemanticModelChildDeleteFailure, i as SemanticChildObjectDataMap, j as FIELD_ROLES, k as CONSTRAINT_SEVERITIES, m as SemanticMetricData, n as MetastoreClient, o as SemanticConstraintData, p as SemanticGlossaryData, t as CreateSemanticObjectMeta, u as SemanticDatasetData, v as SemanticObject, x as SemanticRelationshipData } from "../../types-fX4gbxfV.cjs";
 import { z } from "zod";
+//#region src/sdks/semanticLayer/errorMessage.d.ts
+/**
+ * The message out of a metastore error body.
+ *
+ * - The metastore reports what is actually wrong with a write only inside `errors[].message`
+ *   (`missing property 'fqn'`). The HTTP status and the response's own message say no more than
+ *   "Validation failed", so a caller that renders those alone tells a user nothing actionable.
+ * - Every shape that is not that envelope returns `undefined` rather than a placeholder, so the
+ *   caller keeps its own fallback (`?? error.message`) instead of rendering a stand-in for one.
+ * - Only the first error: the metastore reports fields one at a time, so a list would be a list
+ *   of one.
+ */
+declare const metastoreErrorMessage: (data: unknown) => string | undefined;
+//#endregion
 //#region src/sdks/semanticLayer/schemas.d.ts
 /**
  * Runtime validators for the semantic-layer payload shapes.
@@ -111,6 +125,25 @@ declare class SemanticLayerCascadeDeleteError extends AggregateError {
     failedChildren: SemanticModelChildDeleteFailure[];
   });
 }
+/**
+ * Thrown by `listModelChildren` when a read that has to be complete was not.
+ *
+ * - A dropped object is invisible to the caller, and two of this SDK's answers cannot survive
+ *   that: what a delete would destroy, and whether a model still has children.
+ * - So this one read fails closed where a display read degrades. `deleteModel` calls it before
+ *   the cascade starts, so nothing is deleted when it throws.
+ * - `unreadable` lists what could not be parsed. `modelUUID` is `null` when that field is itself
+ *   part of what failed — an object that cannot name its model is counted against every model,
+ *   because the alternative is deleting the model it turns out to belong to.
+ */
+declare class SemanticLayerUnreadableChildrenError extends Error {
+  readonly modelUUID: string;
+  readonly unreadable: SemanticUnreadableObjectRef[];
+  constructor({ modelUUID, unreadable }: {
+    modelUUID: string;
+    unreadable: SemanticUnreadableObjectRef[];
+  });
+}
 declare const SEMANTIC_OBJECT_TYPE: {
   readonly MODEL: 'semantic-model';
   readonly DATASET: 'semantic-dataset';
@@ -124,17 +157,6 @@ declare const SEMANTIC_OBJECT_TYPE: {
  * 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;
 };
@@ -158,5 +180,5 @@ declare const createSemanticLayerSdk: ({ metastoreClient }: Options) => {
   promoteToOrganizationScope: (objectType: SemanticObjectType, objectUUID: string) => Promise<SemanticObject<Record<string, unknown>>>;
 };
 //#endregion
-export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, SemanticLayerCascadeDeleteError, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
+export { CONSTRAINT_SCOPES, CONSTRAINT_SEVERITIES, CONSTRAINT_TYPES, FIELD_ROLES, MODEL_CHILD_OBJECT_TYPES, RELATIONSHIP_JOIN_TYPES, RULE_OPERATORS, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, SemanticLayerCascadeDeleteError, SemanticLayerUnreadableChildrenError, createSemanticLayerSdk, metastoreErrorMessage, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1,5 +1,19 @@
-import { _ as SemanticObject, a as SemanticChildObjectType, b as SemanticRelationshipData, f as SemanticGlossaryData, g as SemanticModelData, h as SemanticModelChildRef, i as SemanticChildObjectDataMap, l as SemanticDatasetData, m as SemanticModelChildDeleteFailure, n as MetastoreClient, o as SemanticConstraintData, p as SemanticMetricData, t as CreateSemanticObjectMeta, w as UpdateSemanticObjectMeta, y as SemanticObjectType } from "../../types-RfaldD4P.js";
+import { A as CONSTRAINT_TYPES, D as UpdateSemanticObjectMeta, M as RELATIONSHIP_JOIN_TYPES, N as RULE_OPERATORS, O as CONSTRAINT_SCOPES, P as SQL_DIALECTS, T as SemanticUnreadableObjectRef, _ as SemanticModelData, a as SemanticChildObjectType, b as SemanticObjectType, g as SemanticModelChildRef, h as SemanticModelChildDeleteFailure, i as SemanticChildObjectDataMap, j as FIELD_ROLES, k as CONSTRAINT_SEVERITIES, m as SemanticMetricData, n as MetastoreClient, o as SemanticConstraintData, p as SemanticGlossaryData, t as CreateSemanticObjectMeta, u as SemanticDatasetData, v as SemanticObject, x as SemanticRelationshipData } from "../../types-C2vefB4D.js";
 import { z } from "zod";
+//#region src/sdks/semanticLayer/errorMessage.d.ts
+/**
+ * The message out of a metastore error body.
+ *
+ * - The metastore reports what is actually wrong with a write only inside `errors[].message`
+ *   (`missing property 'fqn'`). The HTTP status and the response's own message say no more than
+ *   "Validation failed", so a caller that renders those alone tells a user nothing actionable.
+ * - Every shape that is not that envelope returns `undefined` rather than a placeholder, so the
+ *   caller keeps its own fallback (`?? error.message`) instead of rendering a stand-in for one.
+ * - Only the first error: the metastore reports fields one at a time, so a list would be a list
+ *   of one.
+ */
+declare const metastoreErrorMessage: (data: unknown) => string | undefined;
+//#endregion
 //#region src/sdks/semanticLayer/schemas.d.ts
 /**
  * Runtime validators for the semantic-layer payload shapes.
@@ -111,6 +125,25 @@ declare class SemanticLayerCascadeDeleteError extends AggregateError {
     failedChildren: SemanticModelChildDeleteFailure[];
   });
 }
+/**
+ * Thrown by `listModelChildren` when a read that has to be complete was not.
+ *
+ * - A dropped object is invisible to the caller, and two of this SDK's answers cannot survive
+ *   that: what a delete would destroy, and whether a model still has children.
+ * - So this one read fails closed where a display read degrades. `deleteModel` calls it before
+ *   the cascade starts, so nothing is deleted when it throws.
+ * - `unreadable` lists what could not be parsed. `modelUUID` is `null` when that field is itself
+ *   part of what failed — an object that cannot name its model is counted against every model,
+ *   because the alternative is deleting the model it turns out to belong to.
+ */
+declare class SemanticLayerUnreadableChildrenError extends Error {
+  readonly modelUUID: string;
+  readonly unreadable: SemanticUnreadableObjectRef[];
+  constructor({ modelUUID, unreadable }: {
+    modelUUID: string;
+    unreadable: SemanticUnreadableObjectRef[];
+  });
+}
 declare const SEMANTIC_OBJECT_TYPE: {
   readonly MODEL: 'semantic-model';
   readonly DATASET: 'semantic-dataset';
@@ -124,17 +157,6 @@ declare const SEMANTIC_OBJECT_TYPE: {
  * 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;
 };
@@ -158,5 +180,5 @@ declare const createSemanticLayerSdk: ({ metastoreClient }: Options) => {
   promoteToOrganizationScope: (objectType: SemanticObjectType, objectUUID: string) => Promise<SemanticObject<Record<string, unknown>>>;
 };
 //#endregion
-export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, SemanticLayerCascadeDeleteError, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
+export { CONSTRAINT_SCOPES, CONSTRAINT_SEVERITIES, CONSTRAINT_TYPES, FIELD_ROLES, MODEL_CHILD_OBJECT_TYPES, RELATIONSHIP_JOIN_TYPES, RULE_OPERATORS, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, SemanticLayerCascadeDeleteError, SemanticLayerUnreadableChildrenError, createSemanticLayerSdk, metastoreErrorMessage, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
 //# sourceMappingURL=index.d.ts.map