@keboola/api-client 25.0.0 → 27.0.0

package/dist/syncActions/types.d.ts

@@ -1,4 +1,4 @@
-import { O as OpenapiBodyType } from '../types-gcShAmmi.js';
+import { O as OpenapiBodyType } from '../types-f8dUjMX4.js';
 import * as zod from 'zod';
 
 /**
@@ -268,22 +268,338 @@ declare const apifyObjectsSchema: zod.ZodArray<zod.ZodObject<{
 type ApifyObjectsInput = zod.infer<typeof apifyObjectsInputSchema>;
 type ApifyObject = zod.infer<typeof apifyObjectsSchema>[number];
 
-type GetPublicGitRepositoryInput = {
-    repositoryUrl: string;
-} & Pick<SyncActionBody, 'tag' | 'branchId' | 'mode' | 'componentId'>;
-type GetGitPrivateRepositoryInput = {
-    username: string;
-    password: string;
-} & GetPublicGitRepositoryInput;
-type GetDataAppPublicGitRepositoryInput = Omit<GetPublicGitRepositoryInput, 'componentId'>;
-type GetDataAppPasswordPrivateGitRepositoryInput = GetDataAppPublicGitRepositoryInput & {
-    username: string;
-    password: string;
-};
-type GetDataAppSSHKeyPrivateGitRepositoryInput = GetDataAppPublicGitRepositoryInput & {
-    username: string;
-    sshKey: string;
-};
+/**
+ * `componentId` is a plain string here, unlike the git actions' closed enum. Every dbt transformation
+ * answers `dbtCompile` and `dbtRunResults` under the same action name and the same payload, so the id
+ * selects nothing — it only names the component to run, and rejecting an unlisted one would cost the
+ * caller a cast for no guarantee. The component itself refuses an action it does not serve.
+ */
+declare const dbtActionInputSchema: zod.ZodObject<{
+    branchId: zod.ZodString;
+    tag: zod.ZodOptional<zod.ZodString>;
+    mode: zod.ZodOptional<zod.ZodEnum<{
+        run: "run";
+        debug: "debug";
+    }>>;
+    componentId: zod.ZodString;
+    configId: zod.ZodString;
+    artifacts: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+}, zod.core.$strip>;
+/**
+ * `compiled` maps a model's file name (`orders.sql`) to its compiled SQL. Key order is the
+ * component's own and is preserved, so the caller can render the models in it.
+ *
+ * A configuration that has never run does **not** answer with an empty payload — the component
+ * raises a user exception telling you to run it first, which arrives as a `SyncActionError` carrying
+ * that sentence. The empty default here is only for a payload that omits the key anyway: rendering
+ * "nothing to show" beats failing on a validation error no caller can act on. A key that is
+ * *present* with the wrong shape still fails — that is a contract change, and reading it as "no
+ * models" would hide it.
+ */
+declare const dbtCompiledSchema: zod.ZodPipe<zod.ZodObject<{
+    compiled: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
+}, zod.core.$strip>, zod.ZodTransform<Record<string, string>, {
+    compiled: Record<string, string>;
+}>>;
+/** Each entry also carries `status` and `dependsOn`, dropped here until a consumer needs them. */
+declare const dbtModelTimingSchema: zod.ZodObject<{
+    id: zod.ZodString;
+    name: zod.ZodString;
+    thread: zod.ZodCatch<zod.ZodPipe<zod.ZodPipe<zod.ZodString, zod.ZodTransform<number, string>>, zod.ZodNumber>>;
+    timeStarted: zod.ZodString;
+    timeCompleted: zod.ZodString;
+}, zod.core.$strip>;
+/** Defaults to empty for the same reason as `compiled` above — and with the same caveat. */
+declare const dbtRunResultsSchema: zod.ZodPipe<zod.ZodObject<{
+    modelTiming: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        name: zod.ZodString;
+        thread: zod.ZodCatch<zod.ZodPipe<zod.ZodPipe<zod.ZodString, zod.ZodTransform<number, string>>, zod.ZodNumber>>;
+        timeStarted: zod.ZodString;
+        timeCompleted: zod.ZodString;
+    }, zod.core.$strip>>>;
+}, zod.core.$strip>, zod.ZodTransform<{
+    id: string;
+    name: string;
+    thread: number;
+    timeStarted: string;
+    timeCompleted: string;
+}[], {
+    modelTiming: {
+        id: string;
+        name: string;
+        thread: number;
+        timeStarted: string;
+        timeCompleted: string;
+    }[];
+}>>;
+type DbtActionInput = zod.infer<typeof dbtActionInputSchema>;
+type DbtCompiled = zod.infer<typeof dbtCompiledSchema>;
+type DbtModelTiming = zod.infer<typeof dbtModelTimingSchema>;
+
+/**
+ * Components whose git repository lives under `parameters.dataApp.git.repository` and that answer to
+ * the `git-repository` action. They are the only ones serving `data-app-entrypoints`, and the only
+ * ones accepting an SSH key.
+ */
+declare const DATA_APP_FAMILY: readonly ["keboola.data-apps", "keboola.sandboxes"];
+declare const GIT_FAMILY: readonly ["keboola.data-apps", "keboola.sandboxes", "keboola-test.dbt-core-key-pair", "keboola-test.dbt-remote-snowflake", "keboola.dbt-transformation", "keboola.dbt-transformation-local-bigquery", "keboola.dbt-transformation-remote-bigquery", "keboola.dbt-transformation-remote-mssql", "keboola.dbt-transformation-remote-postgresql", "keboola.dbt-transformation-remote-redshift", "keboola.dbt-transformation-remote-snowflake"];
+/** The ids the git actions accept — anything else has no action name or payload path to resolve. */
+type GitComponentId = (typeof GIT_FAMILY)[number];
+type DataAppComponentId = (typeof DATA_APP_FAMILY)[number];
+declare const isDataAppFamily: (componentId: string) => componentId is DataAppComponentId;
+
+declare const gitAuthSchema: zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+    type: zod.ZodLiteral<"public">;
+}, zod.core.$strip>, zod.ZodObject<{
+    type: zod.ZodLiteral<"password">;
+    username: zod.ZodString;
+    '#password': zod.ZodString;
+}, zod.core.$strip>, zod.ZodObject<{
+    type: zod.ZodLiteral<"sshKey">;
+    username: zod.ZodString;
+    '#sshKey': zod.ZodString;
+}, zod.core.$strip>], "type">;
+/**
+ * Accepts only the components that serve a git repository action — the action name and the
+ * `configData` path are resolved from the id, so one from neither family has nowhere to go. The
+ * enum rejects an unsupported id when parsing, before any request is sent.
+ *
+ * **Takes no `branch`, deliberately — do not add one.** It is a run-config field the component
+ * feeds to `git clone -b <branch>`, so a stale or renamed value fails the clone and breaks the very
+ * call you make to find out which branches exist. Accepting it optionally would let a caller
+ * reintroduce that by spreading in an existing config; zod strips it instead.
+ */
+declare const getBranchesInputSchema: zod.ZodObject<{
+    branchId: zod.ZodString;
+    tag: zod.ZodOptional<zod.ZodString>;
+    mode: zod.ZodOptional<zod.ZodEnum<{
+        run: "run";
+        debug: "debug";
+    }>>;
+    repositoryUrl: zod.ZodString;
+    auth: zod.ZodDefault<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+        type: zod.ZodLiteral<"public">;
+    }, zod.core.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"password">;
+        username: zod.ZodString;
+        '#password': zod.ZodString;
+    }, zod.core.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"sshKey">;
+        username: zod.ZodString;
+        '#sshKey': zod.ZodString;
+    }, zod.core.$strip>], "type">>;
+    componentId: zod.ZodEnum<{
+        "keboola.data-apps": "keboola.data-apps";
+        "keboola.sandboxes": "keboola.sandboxes";
+        "keboola-test.dbt-core-key-pair": "keboola-test.dbt-core-key-pair";
+        "keboola-test.dbt-remote-snowflake": "keboola-test.dbt-remote-snowflake";
+        "keboola.dbt-transformation": "keboola.dbt-transformation";
+        "keboola.dbt-transformation-local-bigquery": "keboola.dbt-transformation-local-bigquery";
+        "keboola.dbt-transformation-remote-bigquery": "keboola.dbt-transformation-remote-bigquery";
+        "keboola.dbt-transformation-remote-mssql": "keboola.dbt-transformation-remote-mssql";
+        "keboola.dbt-transformation-remote-postgresql": "keboola.dbt-transformation-remote-postgresql";
+        "keboola.dbt-transformation-remote-redshift": "keboola.dbt-transformation-remote-redshift";
+        "keboola.dbt-transformation-remote-snowflake": "keboola.dbt-transformation-remote-snowflake";
+    }>;
+}, zod.core.$strip>;
+/** Only the data-app family serves `data-app-entrypoints`; the enum rejects anything else. */
+declare const getEntrypointsInputSchema: zod.ZodObject<{
+    branchId: zod.ZodString;
+    tag: zod.ZodOptional<zod.ZodString>;
+    mode: zod.ZodOptional<zod.ZodEnum<{
+        run: "run";
+        debug: "debug";
+    }>>;
+    repositoryUrl: zod.ZodString;
+    auth: zod.ZodDefault<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+        type: zod.ZodLiteral<"public">;
+    }, zod.core.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"password">;
+        username: zod.ZodString;
+        '#password': zod.ZodString;
+    }, zod.core.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"sshKey">;
+        username: zod.ZodString;
+        '#sshKey': zod.ZodString;
+    }, zod.core.$strip>], "type">>;
+    componentId: zod.ZodEnum<{
+        "keboola.data-apps": "keboola.data-apps";
+        "keboola.sandboxes": "keboola.sandboxes";
+    }>;
+    branch: zod.ZodPipe<zod.ZodOptional<zod.ZodString>, zod.ZodTransform<string | undefined, string | undefined>>;
+}, zod.core.$strip>;
+/**
+ * Only `branch` is load-bearing — it is the value the caller selects and stores. The rest is
+ * decoration the UI renders beside it, so each field falls back to an empty string rather than
+ * failing: one commit with no message must not cost the caller the whole branch list. They stay
+ * `string` rather than becoming optional, so a consumer needs no new undefined handling.
+ */
+declare const gitBranchSchema: zod.ZodObject<{
+    branch: zod.ZodString;
+    sha: zod.ZodCatch<zod.ZodString>;
+    date: zod.ZodCatch<zod.ZodString>;
+    comment: zod.ZodCatch<zod.ZodString>;
+    author: zod.ZodCatch<zod.ZodObject<{
+        name: zod.ZodCatch<zod.ZodString>;
+        email: zod.ZodCatch<zod.ZodString>;
+    }, zod.core.$strip>>;
+}, zod.core.$strip>;
+declare const gitBranchesSchema: zod.ZodPipe<zod.ZodObject<{
+    repository: zod.ZodOptional<zod.ZodObject<{
+        branches: zod.ZodOptional<zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{
+            branch: zod.ZodString;
+            sha: zod.ZodCatch<zod.ZodString>;
+            date: zod.ZodCatch<zod.ZodString>;
+            comment: zod.ZodCatch<zod.ZodString>;
+            author: zod.ZodCatch<zod.ZodObject<{
+                name: zod.ZodCatch<zod.ZodString>;
+                email: zod.ZodCatch<zod.ZodString>;
+            }, zod.core.$strip>>;
+        }, zod.core.$strip>>, zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            branch: zod.ZodString;
+            sha: zod.ZodCatch<zod.ZodString>;
+            date: zod.ZodCatch<zod.ZodString>;
+            comment: zod.ZodCatch<zod.ZodString>;
+            author: zod.ZodCatch<zod.ZodObject<{
+                name: zod.ZodCatch<zod.ZodString>;
+                email: zod.ZodCatch<zod.ZodString>;
+            }, zod.core.$strip>>;
+        }, zod.core.$strip>>]>, zod.ZodTransform<{
+            branch: string;
+            sha: string;
+            date: string;
+            comment: string;
+            author: {
+                name: string;
+                email: string;
+            };
+        }[], Record<string, {
+            branch: string;
+            sha: string;
+            date: string;
+            comment: string;
+            author: {
+                name: string;
+                email: string;
+            };
+        }> | {
+            branch: string;
+            sha: string;
+            date: string;
+            comment: string;
+            author: {
+                name: string;
+                email: string;
+            };
+        }[]>>>;
+    }, zod.core.$strip>>;
+    branches: zod.ZodOptional<zod.ZodPipe<zod.ZodUnion<readonly [zod.ZodArray<zod.ZodObject<{
+        branch: zod.ZodString;
+        sha: zod.ZodCatch<zod.ZodString>;
+        date: zod.ZodCatch<zod.ZodString>;
+        comment: zod.ZodCatch<zod.ZodString>;
+        author: zod.ZodCatch<zod.ZodObject<{
+            name: zod.ZodCatch<zod.ZodString>;
+            email: zod.ZodCatch<zod.ZodString>;
+        }, zod.core.$strip>>;
+    }, zod.core.$strip>>, zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+        branch: zod.ZodString;
+        sha: zod.ZodCatch<zod.ZodString>;
+        date: zod.ZodCatch<zod.ZodString>;
+        comment: zod.ZodCatch<zod.ZodString>;
+        author: zod.ZodCatch<zod.ZodObject<{
+            name: zod.ZodCatch<zod.ZodString>;
+            email: zod.ZodCatch<zod.ZodString>;
+        }, zod.core.$strip>>;
+    }, zod.core.$strip>>]>, zod.ZodTransform<{
+        branch: string;
+        sha: string;
+        date: string;
+        comment: string;
+        author: {
+            name: string;
+            email: string;
+        };
+    }[], Record<string, {
+        branch: string;
+        sha: string;
+        date: string;
+        comment: string;
+        author: {
+            name: string;
+            email: string;
+        };
+    }> | {
+        branch: string;
+        sha: string;
+        date: string;
+        comment: string;
+        author: {
+            name: string;
+            email: string;
+        };
+    }[]>>>;
+}, zod.core.$strip>, zod.ZodTransform<{
+    branch: string;
+    sha: string;
+    date: string;
+    comment: string;
+    author: {
+        name: string;
+        email: string;
+    };
+}[], {
+    repository?: {
+        branches?: {
+            branch: string;
+            sha: string;
+            date: string;
+            comment: string;
+            author: {
+                name: string;
+                email: string;
+            };
+        }[] | undefined;
+    } | undefined;
+    branches?: {
+        branch: string;
+        sha: string;
+        date: string;
+        comment: string;
+        author: {
+            name: string;
+            email: string;
+        };
+    }[] | undefined;
+}>>;
+declare const gitEntrypointsSchema: zod.ZodObject<{
+    entrypoints: zod.ZodArray<zod.ZodString>;
+}, zod.core.$strip>;
+type GitAuth = zod.infer<typeof gitAuthSchema>;
+type GetBranchesInput = zod.input<typeof getBranchesInputSchema>;
+type GetEntrypointsInput = zod.input<typeof getEntrypointsInputSchema>;
+type GitBranch = zod.infer<typeof gitBranchSchema>;
+type GitEntrypoints = zod.infer<typeof gitEntrypointsSchema>;
+
+declare const testLookerCredentialsInputSchema: zod.ZodObject<{
+    branchId: zod.ZodString;
+    tag: zod.ZodOptional<zod.ZodString>;
+    mode: zod.ZodOptional<zod.ZodEnum<{
+        run: "run";
+        debug: "debug";
+    }>>;
+    credentialsId: zod.ZodString;
+    '#token': zod.ZodString;
+    host: zod.ZodString;
+}, zod.core.$strip>;
+/** The component answers with a status envelope only — there is no payload to model. */
+declare const lookerCredentialsResultSchema: zod.ZodObject<{
+    status: zod.ZodOptional<zod.ZodString>;
+    message: zod.ZodOptional<zod.ZodString>;
+}, zod.core.$strip>;
+type TestLookerCredentialsInput = zod.infer<typeof testLookerCredentialsInputSchema>;
+type LookerCredentialsResult = zod.infer<typeof lookerCredentialsResultSchema>;
 
 /**
  * The generated request body, kept only so `sendSyncAction` can cast to what `openapi-fetch`
@@ -295,4 +611,4 @@ type EnrollMFAInput = Omit<SyncActionBody, 'action' | 'configData'> & {
     email: string;
 };
 
-export { type ApifyObject, type ApifyObjectsInput, type EnrollMFAInput, type GetDataAppPasswordPrivateGitRepositoryInput, type GetDataAppPublicGitRepositoryInput, type GetDataAppSSHKeyPrivateGitRepositoryInput, type GetGitPrivateRepositoryInput, type GetPublicGitRepositoryInput, type PostActionsBodyRaw, type SyncActionBody, type SyncActionContext, apifyObjectsInputSchema, apifyObjectsSchema, syncActionBodySchema, syncActionContextSchema };
+export { type ApifyObject, type ApifyObjectsInput, DATA_APP_FAMILY, type DataAppComponentId, type DbtActionInput, type DbtCompiled, type DbtModelTiming, type EnrollMFAInput, GIT_FAMILY, type GetBranchesInput, type GetEntrypointsInput, type GitAuth, type GitBranch, type GitComponentId, type GitEntrypoints, type LookerCredentialsResult, type PostActionsBodyRaw, type SyncActionBody, type SyncActionContext, type TestLookerCredentialsInput, apifyObjectsInputSchema, apifyObjectsSchema, dbtActionInputSchema, dbtCompiledSchema, dbtModelTimingSchema, dbtRunResultsSchema, getBranchesInputSchema, getEntrypointsInputSchema, gitAuthSchema, gitBranchesSchema, gitEntrypointsSchema, isDataAppFamily, lookerCredentialsResultSchema, syncActionBodySchema, syncActionContextSchema, testLookerCredentialsInputSchema };

package/dist/telemetry/index.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
-var chunkNVQ6LGDO_cjs = require('../chunk-NVQ6LGDO.cjs');
-require('../chunk-7RO6PKZ4.cjs');
-require('../chunk-MMOAH3EH.cjs');
+var chunk2JKTV7UG_cjs = require('../chunk-2JKTV7UG.cjs');
+require('../chunk-K3BLXPLA.cjs');
+require('../chunk-HUQ5ATIL.cjs');
 
 
 
 Object.defineProperty(exports, "createTelemetryClient", {
   enumerable: true,
-  get: function () { return chunkNVQ6LGDO_cjs.createTelemetryClient; }
+  get: function () { return chunk2JKTV7UG_cjs.createTelemetryClient; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/telemetry/index.js

@@ -1,5 +1,5 @@
-export { createTelemetryClient } from '../chunk-5XWVWFTC.js';
-import '../chunk-EDX5D6UY.js';
-import '../chunk-XHDYLUM4.js';
+export { createTelemetryClient } from '../chunk-WQ7NNIJ3.js';
+import '../chunk-5A3AQIXR.js';
+import '../chunk-2BQBKU6E.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{types-DbAO-Tgk.d.ts → types-BALUbGA5.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { c as OpenapiQueryType, d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-gcShAmmi.js';
+import { c as OpenapiQueryType, d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-f8dUjMX4.js';
 
 /**
  * This file was auto-generated by openapi-typescript.
@@ -1256,7 +1256,15 @@ type components = {
       visibility: 'public' | 'private';
       /** @description Keboola branch ID that the chat operates in */
       branchId?: number | null;
-      /** @description Latest context-window fill for this conversation (persisted at turn-end), for rehydrating the usage indicator on load. Null until the first turn. */
+      /**
+       * HAND-MAINTAINED — `pnpm gen:types` deletes this; re-add it after every regeneration.
+       * kbc-ui types its chat against this client but talks to kai-agent at runtime, and kai-agent
+       * does return the field. It is absent here only because this file is generated from
+       * kai-assistant's prod spec, which never declared it. Delete this block once the chat client
+       * is retyped against kai-agent's schema (which has the field) rather than kai-assistant's.
+       *
+       * @description Latest context-window fill for this conversation (persisted at turn-end), for rehydrating the usage indicator on load. Null until the first turn.
+       */
       contextWindow?: {
         usedTokens: number;
         maxTokens: number;

package/dist/{types-B30y9Lhc.d.ts → types-BCBF_5cU.d.cts}

@@ -1,4 +1,4 @@
-import { d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-gcShAmmi.js';
+import { d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-f8dUjMX4.cjs';
 
 /**
  * This file was auto-generated by openapi-typescript.
@@ -638,7 +638,9 @@ type paths = {
     head?: never;
     /**
      * Update meta object
-     * @description Update a meta object by creating a new revision
+     * @description Update a meta object by creating a new revision. Sending {"scope": "organization"}
+     *     (without name/data) steps a project-scoped object up to the organization scope;
+     *     this requires the organization-admin role and works across all projects of the organization.
      */
     patch: {
       parameters: {
@@ -690,6 +692,17 @@ type paths = {
             };
           };
         };
+        /** @description Insufficient permissions */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
         /** @description Not found */
         404: {
           headers: {
@@ -701,6 +714,28 @@ type paths = {
             };
           };
         };
+        /** @description Conflict */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
+        /** @description Missing reference */
+        422: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
         /** @description Internal server error */
         500: {
           headers: {
@@ -878,6 +913,110 @@ type paths = {
     patch?: never;
     trace?: never;
   };
+  '/api/v1/repository/{objectType}/{UUID}/target-projects': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    /**
+     * Replace target projects
+     * @description Replace the full set of projects granted GET/consumption access to this object.
+     *     Only the owning project or an organization admin may call this; an empty
+     *     targetProjectIds array clears all grants, reverting the object to owner-only visibility.
+     */
+    put: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          /** @description Object type identifier */
+          objectType: string;
+          /** @description Meta object UUID */
+          UUID: string;
+        };
+        cookie?: never;
+      };
+      /** @description Target projects */
+      requestBody: {
+        content: {
+          'application/vnd.api+json': components['schemas']['models.ReplaceTargetProjectsRequest'];
+        };
+      };
+      responses: {
+        /** @description No content */
+        204: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content?: never;
+        };
+        /** @description Bad request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
+        /** @description Forbidden */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
+        /** @description Not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
+        /** @description Internal server error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/vnd.api+json': {
+              [key: string]: unknown;
+            };
+          };
+        };
+      };
+    };
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   '/api/v1/schema': {
     parameters: {
       query?: never;
@@ -1220,17 +1359,32 @@ type components = {
       schemaVersion?: string;
       /** @example organization */
       scope?: string;
+      /**
+       * @example [
+       *       123,
+       *       456
+       *     ]
+       */
+      targetProjectIds?: number[];
     };
     /** @description JSON data that can contain any valid JSON structure. */
     'models.JSONData': Record<string, never>;
     'models.MetaObjectUpdatePatchRequest': {
       data?: components['schemas']['models.JSONData'];
       name?: string;
+      /**
+       * @description Scope steps a project-scoped object up to the organization scope ("organization").
+       *     It cannot be combined with name/data changes and requires the organization-admin role.
+       */
+      scope?: string;
     };
     'models.MetaObjectUpdatePutRequest': {
       data: components['schemas']['models.JSONData'];
       name: string;
     };
+    'models.ReplaceTargetProjectsRequest': {
+      targetProjectIds?: number[];
+    };
     /** @description Schema metadata without the JSON schema definition. */
     'models.SchemaInfo': {
       /** @description Timestamp when schema was created */
@@ -1299,9 +1453,37 @@ type GetMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/
 type DeleteMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}']['delete']>;
 type UpdateMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}']['patch']>;
 type UpdateMetaObjectBody = OpenapiBodyType<paths['/api/v1/repository/{objectType}/{UUID}']['patch']>;
-type UpdateMetaObjectInput<TData extends Record<string, unknown> = Record<string, unknown>> = UpdateMetaObjectPath & Omit<UpdateMetaObjectBody, 'data'> & {
+/**
+ * At least one of `data`/`name`, in either combination — the API accepts a rename-only PATCH, so
+ * requiring `data` here would make `{ name }` untypeable while the wire supports it. The empty
+ * patch stays unrepresentable because each branch requires its lead field.
+ */
+type UpdateMetaObjectContentPatch<TData extends Record<string, unknown>> = {
     data: Partial<TData>;
+    name?: UpdateMetaObjectBody['name'];
+    scope?: never;
+} | {
+    name: NonNullable<UpdateMetaObjectBody['name']>;
+    data?: Partial<TData>;
+    scope?: never;
+};
+type UpdateMetaObjectScopeStepUp = {
+    scope: NonNullable<UpdateMetaObjectBody['scope']>;
+    data?: never;
+    name?: never;
 };
+/**
+ * A PATCH is exactly one of two operations, and the metastore enforces the split server-side: a
+ * scope step-up sends `{scope}` alone (`models.MetaObjectUpdatePatchRequest.Data` is a pointer, so
+ * even `{}` or `null` decodes non-nil and trips the guard with a 400), while a content patch may
+ * carry `data`/`name` but never `scope`. The union makes the invalid combinations — scope+data,
+ * scope+name, and the empty patch — unrepresentable rather than a runtime 400: passing `scope`
+ * through a content-update path compiled before this and failed on every live call.
+ */
+type UpdateMetaObjectInput<TData extends Record<string, unknown> = Record<string, unknown>> = UpdateMetaObjectPath & (UpdateMetaObjectContentPatch<TData> | UpdateMetaObjectScopeStepUp);
+type ReplaceTargetProjectsPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}/target-projects']['put']>;
+type ReplaceTargetProjectsBody = OpenapiBodyType<paths['/api/v1/repository/{objectType}/{UUID}/target-projects']['put']>;
+type ReplaceTargetProjectsInput = ReplaceTargetProjectsPath & ReplaceTargetProjectsBody;
 type ReplaceMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}']['put']>;
 type ReplaceMetaObjectBody = OpenapiBodyType<paths['/api/v1/repository/{objectType}/{UUID}']['put']>;
 type ReplaceMetaObjectInput<TData extends Record<string, unknown> = Record<string, unknown>> = ReplaceMetaObjectPath & Omit<ReplaceMetaObjectBody, 'data'> & {
@@ -1323,4 +1505,4 @@ type MetaStoreListResponse<TData extends Record<string, unknown>> = {
     data: RawMetaObject<TData>[];
 };
 
-export type { CreateMetaObjectInput as C, DeleteMetaObjectPath as D, GetMetaObjectsPath as G, MetaObject as M, ReplaceMetaObjectInput as R, UpdateMetaObjectInput as U, MetaStoreListResponse as a, GetMetaObjectRevisionsPath as b, GetMetaObjectPath as c, MetaStoreObjectResponse as d, GetMetaObjectRevisionPath as e, DeleteMetaObjectRevisionPath as f, GetSchemaPath as g, components as h, GetVersionedSchemaPath as i, CreateMetaObjectBody as j, CreateMetaObjectPath as k, CreateMetaObjectReturn as l, MetaObjectMeta as m, RawMetaObject as n, ReplaceMetaObjectBody as o, ReplaceMetaObjectPath as p, UpdateMetaObjectBody as q, UpdateMetaObjectPath as r };
+export type { CreateMetaObjectInput as C, DeleteMetaObjectPath as D, GetMetaObjectsPath as G, MetaObject as M, ReplaceMetaObjectInput as R, UpdateMetaObjectInput as U, MetaStoreListResponse as a, GetMetaObjectRevisionsPath as b, GetMetaObjectPath as c, MetaStoreObjectResponse as d, ReplaceTargetProjectsInput as e, GetMetaObjectRevisionPath as f, DeleteMetaObjectRevisionPath as g, GetSchemaPath as h, components as i, GetVersionedSchemaPath as j, CreateMetaObjectBody as k, CreateMetaObjectPath as l, CreateMetaObjectReturn as m, MetaObjectMeta as n, RawMetaObject as o, ReplaceMetaObjectBody as p, ReplaceMetaObjectPath as q, ReplaceTargetProjectsBody as r, ReplaceTargetProjectsPath as s, UpdateMetaObjectBody as t, UpdateMetaObjectPath as u };