@keboola/api-client 32.0.0 → 34.0.0

package/dist/sdk/semanticLayer/index.js

@@ -1,347 +1,2 @@
-import { t as concurrent } from "../../concurrent-CH9fbNr3.js";
-import { t as generateUUID } from "../../generateUUID-Dr8l-aoc.js";
-import { z } from "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) ?? 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 = {}) => 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 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 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 = z.looseObject({
-	name: z.string().min(1),
-	sql_dialect: z.enum(SQL_DIALECTS)
-});
-const semanticDatasetSchema = z.looseObject({
-	name: z.string().min(1),
-	tableId: z.string().min(1),
-	fqn: z.string().min(1)
-});
-const semanticMetricSchema = z.looseObject({
-	name: z.string().min(1),
-	sql: z.string().min(1)
-});
-const semanticRelationshipSchema = z.looseObject({
-	from: z.string().min(1),
-	to: z.string().min(1),
-	on: z.string().min(1)
-});
-const semanticGlossarySchema = z.looseObject({
-	term: z.string().min(1),
-	definition: z.string().min(1)
-});
-const semanticConstraintSchema = z.looseObject({
-	name: z.string().min(1),
-	constraintType: z.enum(CONSTRAINT_TYPES),
-	metrics: z.array(z.string()),
-	rule: 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
-export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, SemanticLayerCascadeDeleteError, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
-
-//# sourceMappingURL=index.js.map
+import { _ as RELATIONSHIP_JOIN_TYPES, a as createSemanticLayerSdk, b as metastoreErrorMessage, c as semanticDatasetSchema, d as semanticModelSchema, f as semanticRelationshipSchema, g as FIELD_ROLES, h as CONSTRAINT_TYPES, i as SemanticLayerUnreadableChildrenError, l as semanticGlossarySchema, m as CONSTRAINT_SEVERITIES, n as SEMANTIC_OBJECT_TYPE, o as SEMANTIC_CHILD_OBJECT_SCHEMAS, p as CONSTRAINT_SCOPES, r as SemanticLayerCascadeDeleteError, s as semanticConstraintSchema, t as MODEL_CHILD_OBJECT_TYPES, u as semanticMetricSchema, v as RULE_OPERATORS, y as SQL_DIALECTS } from "../../semanticLayer-CSqmtHRo.js";
+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 };

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

@@ -1,2 +1,2 @@
-import { C as SemanticValidationQuery, S as SemanticRuleOperator, _ as SemanticObject, a as SemanticChildObjectType, b as SemanticRelationshipData, c as SemanticConstraintType, d as SemanticFieldRole, 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, r as SemanticAiMetadata, s as SemanticConstraintScope, t as CreateSemanticObjectMeta, u as SemanticFieldData, v as SemanticObjectMeta, w as UpdateSemanticObjectMeta, x as SemanticRuleExpression, y as SemanticObjectType } from "../../types-B2vmg_UF.cjs";
-export { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelChildDeleteFailure, SemanticModelChildRef, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRuleExpression, SemanticRuleOperator, SemanticValidationQuery, UpdateSemanticObjectMeta };
+import { C as SemanticRuleExpression, D as UpdateSemanticObjectMeta, E as SemanticValidationQuery, S as SemanticRelationshipJoinType, T as SemanticUnreadableObjectRef, _ as SemanticModelData, a as SemanticChildObjectType, b as SemanticObjectType, c as SemanticConstraintSeverity, d as SemanticFieldData, f as SemanticFieldRole, g as SemanticModelChildRef, h as SemanticModelChildDeleteFailure, i as SemanticChildObjectDataMap, l as SemanticConstraintType, m as SemanticMetricData, n as MetastoreClient, o as SemanticConstraintData, p as SemanticGlossaryData, r as SemanticAiMetadata, s as SemanticConstraintScope, t as CreateSemanticObjectMeta, u as SemanticDatasetData, v as SemanticObject, w as SemanticRuleOperator, x as SemanticRelationshipData, y as SemanticObjectMeta } from "../../types-fX4gbxfV.cjs";
+export { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintSeverity, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelChildDeleteFailure, SemanticModelChildRef, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRelationshipJoinType, SemanticRuleExpression, SemanticRuleOperator, SemanticUnreadableObjectRef, SemanticValidationQuery, UpdateSemanticObjectMeta };

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

@@ -1,2 +1,2 @@
-import { C as SemanticValidationQuery, S as SemanticRuleOperator, _ as SemanticObject, a as SemanticChildObjectType, b as SemanticRelationshipData, c as SemanticConstraintType, d as SemanticFieldRole, 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, r as SemanticAiMetadata, s as SemanticConstraintScope, t as CreateSemanticObjectMeta, u as SemanticFieldData, v as SemanticObjectMeta, w as UpdateSemanticObjectMeta, x as SemanticRuleExpression, y as SemanticObjectType } from "../../types-RfaldD4P.js";
-export { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelChildDeleteFailure, SemanticModelChildRef, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRuleExpression, SemanticRuleOperator, SemanticValidationQuery, UpdateSemanticObjectMeta };
+import { C as SemanticRuleExpression, D as UpdateSemanticObjectMeta, E as SemanticValidationQuery, S as SemanticRelationshipJoinType, T as SemanticUnreadableObjectRef, _ as SemanticModelData, a as SemanticChildObjectType, b as SemanticObjectType, c as SemanticConstraintSeverity, d as SemanticFieldData, f as SemanticFieldRole, g as SemanticModelChildRef, h as SemanticModelChildDeleteFailure, i as SemanticChildObjectDataMap, l as SemanticConstraintType, m as SemanticMetricData, n as MetastoreClient, o as SemanticConstraintData, p as SemanticGlossaryData, r as SemanticAiMetadata, s as SemanticConstraintScope, t as CreateSemanticObjectMeta, u as SemanticDatasetData, v as SemanticObject, w as SemanticRuleOperator, x as SemanticRelationshipData, y as SemanticObjectMeta } from "../../types-C2vefB4D.js";
+export { CreateSemanticObjectMeta, MetastoreClient, SemanticAiMetadata, SemanticChildObjectDataMap, SemanticChildObjectType, SemanticConstraintData, SemanticConstraintScope, SemanticConstraintSeverity, SemanticConstraintType, SemanticDatasetData, SemanticFieldData, SemanticFieldRole, SemanticGlossaryData, SemanticMetricData, SemanticModelChildDeleteFailure, SemanticModelChildRef, SemanticModelData, SemanticObject, SemanticObjectMeta, SemanticObjectType, SemanticRelationshipData, SemanticRelationshipJoinType, SemanticRuleExpression, SemanticRuleOperator, SemanticUnreadableObjectRef, SemanticValidationQuery, UpdateSemanticObjectMeta };

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

@@ -1,2 +1,2 @@
-import { a as parseCurrentDevBranchIdFromUrl, c as removeBranchFromUrl, d as constructFQID, f as parseFQID, h as createStorageSdk, l as FQID_TYPES, m as tableIdParser, o as parseDevBranchId, p as parse, s as prefixTagsWithDevBranchId, u as ParsedFQID } from "../../index-Bjk-tCpG.cjs";
+import { a as parseCurrentDevBranchIdFromUrl, c as removeBranchFromUrl, d as constructFQID, f as parseFQID, h as createStorageSdk, l as FQID_TYPES, m as tableIdParser, o as parseDevBranchId, p as parse, s as prefixTagsWithDevBranchId, u as ParsedFQID } from "../../index-BLx14ZI4.cjs";
 export { FQID_TYPES, ParsedFQID, constructFQID, createStorageSdk, parse, parseCurrentDevBranchIdFromUrl, parseDevBranchId, parseFQID, prefixTagsWithDevBranchId, removeBranchFromUrl, tableIdParser };

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

@@ -1,2 +1,2 @@
-import { a as parseCurrentDevBranchIdFromUrl, c as removeBranchFromUrl, d as constructFQID, f as parseFQID, h as createStorageSdk, l as FQID_TYPES, m as tableIdParser, o as parseDevBranchId, p as parse, s as prefixTagsWithDevBranchId, u as ParsedFQID } from "../../index-FhKX7Cv1.js";
+import { a as parseCurrentDevBranchIdFromUrl, c as removeBranchFromUrl, d as constructFQID, f as parseFQID, h as createStorageSdk, l as FQID_TYPES, m as tableIdParser, o as parseDevBranchId, p as parse, s as prefixTagsWithDevBranchId, u as ParsedFQID } from "../../index-DFBFa3SS.js";
 export { FQID_TYPES, ParsedFQID, constructFQID, createStorageSdk, parse, parseCurrentDevBranchIdFromUrl, parseDevBranchId, parseFQID, prefixTagsWithDevBranchId, removeBranchFromUrl, tableIdParser };

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

@@ -1,6 +1,6 @@
-import { p as MetaObject } from "../../types-B4jdPHoL.cjs";
+import { p as MetaObject } from "../../types-Cz83RiVu.cjs";
 import { n as KeboolaObjectId } from "../../index-NC1dXRTD.cjs";
-import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, t as CreateMetaObjectMetaDataInput } from "../../types-MbcIiKDI.cjs";
+import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, t as CreateMetaObjectMetaDataInput } from "../../types-BOqD3Hqy.cjs";
 //#region src/sdks/tag/tagSdk.d.ts
 type Options = {
   metastoreClient: MetastoreClient;

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

@@ -1,6 +1,6 @@
-import { p as MetaObject } from "../../types-BlCoTm7n.js";
+import { p as MetaObject } from "../../types-BH5LLeJy.js";
 import { n as KeboolaObjectId } from "../../index-NC1dXRTD.js";
-import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, t as CreateMetaObjectMetaDataInput } from "../../types-sVYo0o9_.js";
+import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, t as CreateMetaObjectMetaDataInput } from "../../types-Dmu-8g4O.js";
 //#region src/sdks/tag/tagSdk.d.ts
 type Options = {
   metastoreClient: MetastoreClient;

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

@@ -1,2 +1,2 @@
-import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, r as TagBindingData, t as CreateMetaObjectMetaDataInput } from "../../types-MbcIiKDI.cjs";
+import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, r as TagBindingData, t as CreateMetaObjectMetaDataInput } from "../../types-BOqD3Hqy.cjs";
 export { CreateMetaObjectMetaDataInput, MetastoreClient, TagBindingData, TagData, TagWithBindings, UpdateMetaObjectMetaDataInput };

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

@@ -1,2 +1,2 @@
-import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, r as TagBindingData, t as CreateMetaObjectMetaDataInput } from "../../types-sVYo0o9_.js";
+import { a as TagWithBindings, i as TagData, n as MetastoreClient, o as UpdateMetaObjectMetaDataInput, r as TagBindingData, t as CreateMetaObjectMetaDataInput } from "../../types-Dmu-8g4O.js";
 export { CreateMetaObjectMetaDataInput, MetastoreClient, TagBindingData, TagData, TagWithBindings, UpdateMetaObjectMetaDataInput };

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

@@ -1,2 +1,2 @@
-import { a as vaultRef, i as partitionByOauth, n as isVariableEncryptionRequired, o as createVaultSdk, r as isVariableOauth, s as EncryptionCtx, t as isSameVariable } from "../../index-DiHHyMEo.cjs";
+import { a as vaultRef, i as partitionByOauth, n as isVariableEncryptionRequired, o as createVaultSdk, r as isVariableOauth, s as EncryptionCtx, t as isSameVariable } from "../../index-BgLnWTZU.cjs";
 export { type EncryptionCtx, createVaultSdk, isSameVariable, isVariableEncryptionRequired, isVariableOauth, partitionByOauth, vaultRef };

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

@@ -1,2 +1,2 @@
-import { a as vaultRef, i as partitionByOauth, n as isVariableEncryptionRequired, o as createVaultSdk, r as isVariableOauth, s as EncryptionCtx, t as isSameVariable } from "../../index-Bg1P6Bb2.js";
+import { a as vaultRef, i as partitionByOauth, n as isVariableEncryptionRequired, o as createVaultSdk, r as isVariableOauth, s as EncryptionCtx, t as isSameVariable } from "../../index-CqgtL2NU.js";
 export { type EncryptionCtx, createVaultSdk, isSameVariable, isVariableEncryptionRequired, isVariableOauth, partitionByOauth, vaultRef };