@keboola/api-client 25.0.0 → 29.0.0

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

@@ -1,12 +1,6 @@
-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-CSZoV4lM.cjs';
-import '../../types-gcShAmmi.cjs';
-import '../../createOpenapiFetchClient-BFmiJ9C5.cjs';
-import '../../types-UwuKN9Kx.cjs';
-import 'qs';
-
+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-DBOEA7l0.cjs";
+import { z } from "zod";
+//#region src/sdks/semanticLayer/schemas.d.ts
 /**
  * Runtime validators for the semantic-layer payload shapes.
  *
@@ -25,87 +19,105 @@ import 'qs';
  * `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";
-    }>;
+  name: z.ZodString;
+  sql_dialect: z.ZodEnum<{
+    BigQuery: "BigQuery";
+    Snowflake: "Snowflake";
+  }>;
 }, 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<{
+    composition: "composition";
+    conditional: "conditional";
+    equality: "equality";
+    exclusion: "exclusion";
+    inequality: "inequality";
+    range: "range";
+    temporal: "temporal";
+  }>;
+  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>;
-declare const semanticMetricSchema: z.ZodObject<{
+  }, z.core.$loose>;
+  readonly 'semantic-metric': z.ZodObject<{
     name: z.ZodString;
     sql: z.ZodString;
-}, z.core.$loose>;
-declare const semanticRelationshipSchema: z.ZodObject<{
+  }, z.core.$loose>;
+  readonly 'semantic-relationship': z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
     on: z.ZodString;
-}, z.core.$loose>;
-declare const semanticGlossarySchema: z.ZodObject<{
+  }, z.core.$loose>;
+  readonly 'semantic-glossary': z.ZodObject<{
     term: z.ZodString;
     definition: z.ZodString;
-}, z.core.$loose>;
-declare const semanticConstraintSchema: z.ZodObject<{
+  }, 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";
+      composition: "composition";
+      conditional: "conditional";
+      equality: "equality";
+      exclusion: "exclusion";
+      inequality: "inequality";
+      range: "range";
+      temporal: "temporal";
     }>;
     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>;
+  }, z.core.$loose>;
 };
-
+//#endregion
+//#region src/sdks/semanticLayer/semanticLayerSdk.d.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.
+ */
+declare class SemanticLayerCascadeDeleteError extends AggregateError {
+  readonly modelUUID: string;
+  readonly deletedChildren: SemanticModelChildRef[];
+  readonly failedChildren: SemanticModelChildDeleteFailure[];
+  constructor({ modelUUID, deletedChildren, failedChildren }: {
+    modelUUID: string;
+    deletedChildren: SemanticModelChildRef[];
+    failedChildren: SemanticModelChildDeleteFailure[];
+  });
+}
 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 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` —
@@ -120,32 +132,31 @@ declare const MODEL_CHILD_OBJECT_TYPES: readonly SemanticChildObjectType[];
  * `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"];
+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;
+  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>;
+  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<SemanticModelChildRef[]>;
+  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<SemanticConstraintData | SemanticDatasetData | SemanticGlossaryData | SemanticMetricData | SemanticRelationshipData>[];
+  }>;
+  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>;
+  replaceTargetProjects: (objectType: SemanticObjectType, objectUUID: string, targetProjectIds: number[]) => Promise<void>;
+  promoteToOrganizationScope: (objectType: SemanticObjectType, objectUUID: string) => Promise<SemanticObject<Record<string, unknown>>>;
 };
-
-export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
+//#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.d.cts.map

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

@@ -1,12 +1,6 @@
-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-B30y9Lhc.js';
-import '../../types-gcShAmmi.js';
-import '../../createOpenapiFetchClient-6RX67Hws.js';
-import '../../types-UwuKN9Kx.js';
-import 'qs';
-
+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-DebL68-g.js";
+import { z } from "zod";
+//#region src/sdks/semanticLayer/schemas.d.ts
 /**
  * Runtime validators for the semantic-layer payload shapes.
  *
@@ -25,87 +19,105 @@ import 'qs';
  * `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";
-    }>;
+  name: z.ZodString;
+  sql_dialect: z.ZodEnum<{
+    BigQuery: "BigQuery";
+    Snowflake: "Snowflake";
+  }>;
 }, 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<{
+    composition: "composition";
+    conditional: "conditional";
+    equality: "equality";
+    exclusion: "exclusion";
+    inequality: "inequality";
+    range: "range";
+    temporal: "temporal";
+  }>;
+  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>;
-declare const semanticMetricSchema: z.ZodObject<{
+  }, z.core.$loose>;
+  readonly 'semantic-metric': z.ZodObject<{
     name: z.ZodString;
     sql: z.ZodString;
-}, z.core.$loose>;
-declare const semanticRelationshipSchema: z.ZodObject<{
+  }, z.core.$loose>;
+  readonly 'semantic-relationship': z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
     on: z.ZodString;
-}, z.core.$loose>;
-declare const semanticGlossarySchema: z.ZodObject<{
+  }, z.core.$loose>;
+  readonly 'semantic-glossary': z.ZodObject<{
     term: z.ZodString;
     definition: z.ZodString;
-}, z.core.$loose>;
-declare const semanticConstraintSchema: z.ZodObject<{
+  }, 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";
+      composition: "composition";
+      conditional: "conditional";
+      equality: "equality";
+      exclusion: "exclusion";
+      inequality: "inequality";
+      range: "range";
+      temporal: "temporal";
     }>;
     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>;
+  }, z.core.$loose>;
 };
-
+//#endregion
+//#region src/sdks/semanticLayer/semanticLayerSdk.d.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.
+ */
+declare class SemanticLayerCascadeDeleteError extends AggregateError {
+  readonly modelUUID: string;
+  readonly deletedChildren: SemanticModelChildRef[];
+  readonly failedChildren: SemanticModelChildDeleteFailure[];
+  constructor({ modelUUID, deletedChildren, failedChildren }: {
+    modelUUID: string;
+    deletedChildren: SemanticModelChildRef[];
+    failedChildren: SemanticModelChildDeleteFailure[];
+  });
+}
 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 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` —
@@ -120,32 +132,31 @@ declare const MODEL_CHILD_OBJECT_TYPES: readonly SemanticChildObjectType[];
  * `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"];
+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;
+  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>;
+  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<SemanticModelChildRef[]>;
+  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<SemanticConstraintData | SemanticDatasetData | SemanticGlossaryData | SemanticMetricData | SemanticRelationshipData>[];
+  }>;
+  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>;
+  replaceTargetProjects: (objectType: SemanticObjectType, objectUUID: string, targetProjectIds: number[]) => Promise<void>;
+  promoteToOrganizationScope: (objectType: SemanticObjectType, objectUUID: string) => Promise<SemanticObject<Record<string, unknown>>>;
 };
-
-export { CONSTRAINT_TYPES, MODEL_CHILD_OBJECT_TYPES, SEMANTIC_CHILD_OBJECT_SCHEMAS, SEMANTIC_OBJECT_TYPE, SQL_DIALECTS, createSemanticLayerSdk, semanticConstraintSchema, semanticDatasetSchema, semanticGlossarySchema, semanticMetricSchema, semanticModelSchema, semanticRelationshipSchema };
+//#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.d.ts.map