@atlanai/sdk 0.1.1 → 0.2.2

package/dist/raw/registry/apis/AppsApi.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Atlan Agent Gateway — registry
+ * The platform core: identity, tenancy, the artifact plane, discovery and the policy plane.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { type AppActionsPage } from '../models/AppActionsPage';
+import { type AppDto } from '../models/AppDto';
+import { type AppsPage } from '../models/AppsPage';
+import { type InstallAppBody } from '../models/InstallAppBody';
+import { type ReconcileAcceptedDto } from '../models/ReconcileAcceptedDto';
+import { type UpgradeAppBody } from '../models/UpgradeAppBody';
+export interface RegistryGetAppRequest {
+    app: string;
+}
+export interface RegistryInstallAppRequest {
+    app: string;
+    installAppBody: InstallAppBody;
+    contentEncoding?: RegistryInstallAppContentEncodingEnum;
+}
+export interface RegistryListAppActionsRequest {
+    app: string;
+}
+export interface RegistryReconcileAppRequest {
+    app: string;
+}
+export interface RegistryUninstallAppRequest {
+    app: string;
+}
+export interface RegistryUpgradeAppRequest {
+    app: string;
+    upgradeAppBody: UpgradeAppBody;
+    contentEncoding?: RegistryUpgradeAppContentEncodingEnum;
+}
+/**
+ *
+ */
+export declare class AppsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for registryGetApp without sending the request
+     */
+    registryGetAppRequestOpts(requestParameters: RegistryGetAppRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Includes the install-time `install_metadata`. A `failed` status is kept rather than cleared: a retry with nothing to explain it is worse than a record saying what happened.
+     * Get an app
+     */
+    registryGetAppRaw(requestParameters: RegistryGetAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppDto>>;
+    /**
+     * Includes the install-time `install_metadata`. A `failed` status is kept rather than cleared: a retry with nothing to explain it is worse than a record saying what happened.
+     * Get an app
+     */
+    registryGetApp(requestParameters: RegistryGetAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppDto>;
+    /**
+     * Creates request options for registryInstallApp without sending the request
+     */
+    registryInstallAppRequestOpts(requestParameters: RegistryInstallAppRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Turns the app on for this account and fires its install lifecycle: the `pre_install` gate, then the app\'s own artifact moving to `active`, then the seeding `post_install` hook under **your** bearer — which is how an app\'s per-account seeds (a bootstrap skill, a default provider) are attributed to the caller rather than to the platform.  **Idempotent, and a re-install is the retry.** Installing an already-installed app re-fires both hooks and re-merges their metadata, keeping the original `created_by` and `created_at`. Every documented seed is idempotent, so this is how an install whose seeds failed is recovered.  **Only `pre_install` can refuse.** Once the app is `active` the install stands: a failing seed hook leaves it installed with no per-account state rather than rolling back, because a rolled-back install leaves nothing to retry from. An app that cannot be reached at all installs with empty metadata for the same reason — a deployment window must not become an onboarding outage.  Requires the account to have been onboarded: an app is an artifact, and an artifact needs the org root workspace that onboarding creates.
+     * Install an app
+     */
+    registryInstallAppRaw(requestParameters: RegistryInstallAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppDto>>;
+    /**
+     * Turns the app on for this account and fires its install lifecycle: the `pre_install` gate, then the app\'s own artifact moving to `active`, then the seeding `post_install` hook under **your** bearer — which is how an app\'s per-account seeds (a bootstrap skill, a default provider) are attributed to the caller rather than to the platform.  **Idempotent, and a re-install is the retry.** Installing an already-installed app re-fires both hooks and re-merges their metadata, keeping the original `created_by` and `created_at`. Every documented seed is idempotent, so this is how an install whose seeds failed is recovered.  **Only `pre_install` can refuse.** Once the app is `active` the install stands: a failing seed hook leaves it installed with no per-account state rather than rolling back, because a rolled-back install leaves nothing to retry from. An app that cannot be reached at all installs with empty metadata for the same reason — a deployment window must not become an onboarding outage.  Requires the account to have been onboarded: an app is an artifact, and an artifact needs the org root workspace that onboarding creates.
+     * Install an app
+     */
+    registryInstallApp(requestParameters: RegistryInstallAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppDto>;
+    /**
+     * Creates request options for registryListAppActions without sending the request
+     */
+    registryListAppActionsRequestOpts(requestParameters: RegistryListAppActionsRequest): Promise<runtime.RequestOpts>;
+    /**
+     * The jobs this app declares it can run, each a Temporal queue and workflow named `<app>/<job>`.  **Not the same as `/actions`.** An app action is a *capability*; an `actions` row is a rule about when to invoke one. A client wiring up an action DAG reads both.
+     * List an app\'s actions
+     */
+    registryListAppActionsRaw(requestParameters: RegistryListAppActionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppActionsPage>>;
+    /**
+     * The jobs this app declares it can run, each a Temporal queue and workflow named `<app>/<job>`.  **Not the same as `/actions`.** An app action is a *capability*; an `actions` row is a rule about when to invoke one. A client wiring up an action DAG reads both.
+     * List an app\'s actions
+     */
+    registryListAppActions(requestParameters: RegistryListAppActionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppActionsPage>;
+    /**
+     * Creates request options for registryListApps without sending the request
+     */
+    registryListAppsRequestOpts(): Promise<runtime.RequestOpts>;
+    /**
+     * Every app this account holds, installed or not. An app is an extension as this account holds it: what it is, who publishes it, where its browser UI lives, and whether the account has turned it on.  **Browsing and the install list are the same read.** Filter `?filter[install_status][eq]=available` for what can be installed and `?filter[install_status][eq]=active` for what is. They were separate routes while the catalogue was deployment-global and the installs were account-scoped; an app is neither.  Supports the shared query grammar over the artifact envelope (`name`, `display_name`, `updated_at`, …) and over this kind\'s own columns: `install_status`, `author`, `license`.
+     * List apps
+     */
+    registryListAppsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppsPage>>;
+    /**
+     * Every app this account holds, installed or not. An app is an extension as this account holds it: what it is, who publishes it, where its browser UI lives, and whether the account has turned it on.  **Browsing and the install list are the same read.** Filter `?filter[install_status][eq]=available` for what can be installed and `?filter[install_status][eq]=active` for what is. They were separate routes while the catalogue was deployment-global and the installs were account-scoped; an app is neither.  Supports the shared query grammar over the artifact envelope (`name`, `display_name`, `updated_at`, …) and over this kind\'s own columns: `install_status`, `author`, `license`.
+     * List apps
+     */
+    registryListApps(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppsPage>;
+    /**
+     * Creates request options for registryReconcileApp without sending the request
+     */
+    registryReconcileAppRequestOpts(requestParameters: RegistryReconcileAppRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Hands the app every live artifact of its own kinds in this account, as `{id, metadata}`, so it can release backing resources for anything it is still holding that the registry no longer has a row for.  **The set is the contract, so it is never truncated.** A partial set reads to the app as \"everything else is an orphan\", which for a sweeping handler means deleting live data. If the account holds more artifacts of these kinds than one sweep can carry, this refuses rather than sending a prefix — which is why the size check is part of the `202`, not of the sweep.  **`202`, and the sweep runs after the response.** A reconcile walks an app\'s whole backing store for the account, so holding the request open for it would tie an operator\'s timeout to an object-store scan. What is decided before the `202` is everything a caller can act on: that the app is installed, and that its live set fits. The sweep\'s own outcome is the app\'s to log.  `live_count` is what distinguishes a sweep of four hundred artifacts from a sweep of an app the account owns nothing of — which is usually a mistake in which app was named.
+     * Trigger an app\'s reconcile sweep
+     */
+    registryReconcileAppRaw(requestParameters: RegistryReconcileAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReconcileAcceptedDto>>;
+    /**
+     * Hands the app every live artifact of its own kinds in this account, as `{id, metadata}`, so it can release backing resources for anything it is still holding that the registry no longer has a row for.  **The set is the contract, so it is never truncated.** A partial set reads to the app as \"everything else is an orphan\", which for a sweeping handler means deleting live data. If the account holds more artifacts of these kinds than one sweep can carry, this refuses rather than sending a prefix — which is why the size check is part of the `202`, not of the sweep.  **`202`, and the sweep runs after the response.** A reconcile walks an app\'s whole backing store for the account, so holding the request open for it would tie an operator\'s timeout to an object-store scan. What is decided before the `202` is everything a caller can act on: that the app is installed, and that its live set fits. The sweep\'s own outcome is the app\'s to log.  `live_count` is what distinguishes a sweep of four hundred artifacts from a sweep of an app the account owns nothing of — which is usually a mistake in which app was named.
+     * Trigger an app\'s reconcile sweep
+     */
+    registryReconcileApp(requestParameters: RegistryReconcileAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReconcileAcceptedDto>;
+    /**
+     * Creates request options for registryUninstallApp without sending the request
+     */
+    registryUninstallAppRequestOpts(requestParameters: RegistryUninstallAppRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Marks the install `uninstalling`, tells the app so it can release what it provisioned for this account, then archives the account\'s artifact for it.  **The account\'s artifacts are not touched.** Uninstalling `skill` does not archive the account\'s skills — the kind stays registered deployment-wide and the rows stay readable, so a re-install finds them. What the hook releases is the app\'s *own* per-account state (a bucket prefix, an external provider registration).  A failing hook does not fail the uninstall: an account that asked to remove an app must not stay installed because the app\'s cleanup failed. `204`, with nothing to say.
+     * Uninstall an app
+     */
+    registryUninstallAppRaw(requestParameters: RegistryUninstallAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Marks the install `uninstalling`, tells the app so it can release what it provisioned for this account, then archives the account\'s artifact for it.  **The account\'s artifacts are not touched.** Uninstalling `skill` does not archive the account\'s skills — the kind stays registered deployment-wide and the rows stay readable, so a re-install finds them. What the hook releases is the app\'s *own* per-account state (a bucket prefix, an external provider registration).  A failing hook does not fail the uninstall: an account that asked to remove an app must not stay installed because the app\'s cleanup failed. `204`, with nothing to say.
+     * Uninstall an app
+     */
+    registryUninstallApp(requestParameters: RegistryUninstallAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for registryUpgradeApp without sending the request
+     */
+    registryUpgradeAppRequestOpts(requestParameters: RegistryUpgradeAppRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Records the account against the deployment\'s current `release` and contract version. `{\"is_pinned\": true}` freezes it there, so a later release does not move this account; `{\"is_pinned\": false}` releases the freeze.  **No hooks fire.** An upgrade changes which contract version the account is recorded against, and nothing else — re-running the seeding hook on every upgrade would re-seed an account that already has its rows. An app with per-version work to do has `reconcile`, which is triggered deliberately.
+     * Move an install to the registration head
+     */
+    registryUpgradeAppRaw(requestParameters: RegistryUpgradeAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AppDto>>;
+    /**
+     * Records the account against the deployment\'s current `release` and contract version. `{\"is_pinned\": true}` freezes it there, so a later release does not move this account; `{\"is_pinned\": false}` releases the freeze.  **No hooks fire.** An upgrade changes which contract version the account is recorded against, and nothing else — re-running the seeding hook on every upgrade would re-seed an account that already has its rows. An app with per-version work to do has `reconcile`, which is triggered deliberately.
+     * Move an install to the registration head
+     */
+    registryUpgradeApp(requestParameters: RegistryUpgradeAppRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AppDto>;
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryInstallAppContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryUpgradeAppContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}

package/dist/raw/registry/apis/AppsApi.js

@@ -0,0 +1,385 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Atlan Agent Gateway — registry
+ * The platform core: identity, tenancy, the artifact plane, discovery and the policy plane.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryUpgradeAppContentEncodingEnum = exports.RegistryInstallAppContentEncodingEnum = exports.AppsApi = void 0;
+const runtime = __importStar(require("../runtime"));
+const AppActionsPage_1 = require("../models/AppActionsPage");
+const AppDto_1 = require("../models/AppDto");
+const AppsPage_1 = require("../models/AppsPage");
+const InstallAppBody_1 = require("../models/InstallAppBody");
+const ReconcileAcceptedDto_1 = require("../models/ReconcileAcceptedDto");
+const UpgradeAppBody_1 = require("../models/UpgradeAppBody");
+/**
+ *
+ */
+class AppsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for registryGetApp without sending the request
+     */
+    async registryGetAppRequestOpts(requestParameters) {
+        if (requestParameters['app'] == null) {
+            throw new runtime.RequiredError('app', 'Required parameter "app" was null or undefined when calling registryGetApp().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/apps/{app}`;
+        urlPath = urlPath.replace('{app}', encodeURIComponent(String(requestParameters['app'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Includes the install-time `install_metadata`. A `failed` status is kept rather than cleared: a retry with nothing to explain it is worse than a record saying what happened.
+     * Get an app
+     */
+    async registryGetAppRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryGetAppRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, AppDto_1.AppDtoFromJSON)(jsonValue));
+    }
+    /**
+     * Includes the install-time `install_metadata`. A `failed` status is kept rather than cleared: a retry with nothing to explain it is worse than a record saying what happened.
+     * Get an app
+     */
+    async registryGetApp(requestParameters, initOverrides) {
+        const response = await this.registryGetAppRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for registryInstallApp without sending the request
+     */
+    async registryInstallAppRequestOpts(requestParameters) {
+        if (requestParameters['app'] == null) {
+            throw new runtime.RequiredError('app', 'Required parameter "app" was null or undefined when calling registryInstallApp().');
+        }
+        if (requestParameters['installAppBody'] == null) {
+            throw new runtime.RequiredError('installAppBody', 'Required parameter "installAppBody" was null or undefined when calling registryInstallApp().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/apps/{app}/install`;
+        urlPath = urlPath.replace('{app}', encodeURIComponent(String(requestParameters['app'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, InstallAppBody_1.InstallAppBodyToJSON)(requestParameters['installAppBody']),
+        };
+    }
+    /**
+     * Turns the app on for this account and fires its install lifecycle: the `pre_install` gate, then the app\'s own artifact moving to `active`, then the seeding `post_install` hook under **your** bearer — which is how an app\'s per-account seeds (a bootstrap skill, a default provider) are attributed to the caller rather than to the platform.  **Idempotent, and a re-install is the retry.** Installing an already-installed app re-fires both hooks and re-merges their metadata, keeping the original `created_by` and `created_at`. Every documented seed is idempotent, so this is how an install whose seeds failed is recovered.  **Only `pre_install` can refuse.** Once the app is `active` the install stands: a failing seed hook leaves it installed with no per-account state rather than rolling back, because a rolled-back install leaves nothing to retry from. An app that cannot be reached at all installs with empty metadata for the same reason — a deployment window must not become an onboarding outage.  Requires the account to have been onboarded: an app is an artifact, and an artifact needs the org root workspace that onboarding creates.
+     * Install an app
+     */
+    async registryInstallAppRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryInstallAppRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, AppDto_1.AppDtoFromJSON)(jsonValue));
+    }
+    /**
+     * Turns the app on for this account and fires its install lifecycle: the `pre_install` gate, then the app\'s own artifact moving to `active`, then the seeding `post_install` hook under **your** bearer — which is how an app\'s per-account seeds (a bootstrap skill, a default provider) are attributed to the caller rather than to the platform.  **Idempotent, and a re-install is the retry.** Installing an already-installed app re-fires both hooks and re-merges their metadata, keeping the original `created_by` and `created_at`. Every documented seed is idempotent, so this is how an install whose seeds failed is recovered.  **Only `pre_install` can refuse.** Once the app is `active` the install stands: a failing seed hook leaves it installed with no per-account state rather than rolling back, because a rolled-back install leaves nothing to retry from. An app that cannot be reached at all installs with empty metadata for the same reason — a deployment window must not become an onboarding outage.  Requires the account to have been onboarded: an app is an artifact, and an artifact needs the org root workspace that onboarding creates.
+     * Install an app
+     */
+    async registryInstallApp(requestParameters, initOverrides) {
+        const response = await this.registryInstallAppRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for registryListAppActions without sending the request
+     */
+    async registryListAppActionsRequestOpts(requestParameters) {
+        if (requestParameters['app'] == null) {
+            throw new runtime.RequiredError('app', 'Required parameter "app" was null or undefined when calling registryListAppActions().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/apps/{app}/actions`;
+        urlPath = urlPath.replace('{app}', encodeURIComponent(String(requestParameters['app'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * The jobs this app declares it can run, each a Temporal queue and workflow named `<app>/<job>`.  **Not the same as `/actions`.** An app action is a *capability*; an `actions` row is a rule about when to invoke one. A client wiring up an action DAG reads both.
+     * List an app\'s actions
+     */
+    async registryListAppActionsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryListAppActionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, AppActionsPage_1.AppActionsPageFromJSON)(jsonValue));
+    }
+    /**
+     * The jobs this app declares it can run, each a Temporal queue and workflow named `<app>/<job>`.  **Not the same as `/actions`.** An app action is a *capability*; an `actions` row is a rule about when to invoke one. A client wiring up an action DAG reads both.
+     * List an app\'s actions
+     */
+    async registryListAppActions(requestParameters, initOverrides) {
+        const response = await this.registryListAppActionsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for registryListApps without sending the request
+     */
+    async registryListAppsRequestOpts() {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/apps`;
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Every app this account holds, installed or not. An app is an extension as this account holds it: what it is, who publishes it, where its browser UI lives, and whether the account has turned it on.  **Browsing and the install list are the same read.** Filter `?filter[install_status][eq]=available` for what can be installed and `?filter[install_status][eq]=active` for what is. They were separate routes while the catalogue was deployment-global and the installs were account-scoped; an app is neither.  Supports the shared query grammar over the artifact envelope (`name`, `display_name`, `updated_at`, …) and over this kind\'s own columns: `install_status`, `author`, `license`.
+     * List apps
+     */
+    async registryListAppsRaw(initOverrides) {
+        const requestOptions = await this.registryListAppsRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, AppsPage_1.AppsPageFromJSON)(jsonValue));
+    }
+    /**
+     * Every app this account holds, installed or not. An app is an extension as this account holds it: what it is, who publishes it, where its browser UI lives, and whether the account has turned it on.  **Browsing and the install list are the same read.** Filter `?filter[install_status][eq]=available` for what can be installed and `?filter[install_status][eq]=active` for what is. They were separate routes while the catalogue was deployment-global and the installs were account-scoped; an app is neither.  Supports the shared query grammar over the artifact envelope (`name`, `display_name`, `updated_at`, …) and over this kind\'s own columns: `install_status`, `author`, `license`.
+     * List apps
+     */
+    async registryListApps(initOverrides) {
+        const response = await this.registryListAppsRaw(initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for registryReconcileApp without sending the request
+     */
+    async registryReconcileAppRequestOpts(requestParameters) {
+        if (requestParameters['app'] == null) {
+            throw new runtime.RequiredError('app', 'Required parameter "app" was null or undefined when calling registryReconcileApp().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/apps/{app}/reconcile`;
+        urlPath = urlPath.replace('{app}', encodeURIComponent(String(requestParameters['app'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Hands the app every live artifact of its own kinds in this account, as `{id, metadata}`, so it can release backing resources for anything it is still holding that the registry no longer has a row for.  **The set is the contract, so it is never truncated.** A partial set reads to the app as \"everything else is an orphan\", which for a sweeping handler means deleting live data. If the account holds more artifacts of these kinds than one sweep can carry, this refuses rather than sending a prefix — which is why the size check is part of the `202`, not of the sweep.  **`202`, and the sweep runs after the response.** A reconcile walks an app\'s whole backing store for the account, so holding the request open for it would tie an operator\'s timeout to an object-store scan. What is decided before the `202` is everything a caller can act on: that the app is installed, and that its live set fits. The sweep\'s own outcome is the app\'s to log.  `live_count` is what distinguishes a sweep of four hundred artifacts from a sweep of an app the account owns nothing of — which is usually a mistake in which app was named.
+     * Trigger an app\'s reconcile sweep
+     */
+    async registryReconcileAppRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryReconcileAppRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, ReconcileAcceptedDto_1.ReconcileAcceptedDtoFromJSON)(jsonValue));
+    }
+    /**
+     * Hands the app every live artifact of its own kinds in this account, as `{id, metadata}`, so it can release backing resources for anything it is still holding that the registry no longer has a row for.  **The set is the contract, so it is never truncated.** A partial set reads to the app as \"everything else is an orphan\", which for a sweeping handler means deleting live data. If the account holds more artifacts of these kinds than one sweep can carry, this refuses rather than sending a prefix — which is why the size check is part of the `202`, not of the sweep.  **`202`, and the sweep runs after the response.** A reconcile walks an app\'s whole backing store for the account, so holding the request open for it would tie an operator\'s timeout to an object-store scan. What is decided before the `202` is everything a caller can act on: that the app is installed, and that its live set fits. The sweep\'s own outcome is the app\'s to log.  `live_count` is what distinguishes a sweep of four hundred artifacts from a sweep of an app the account owns nothing of — which is usually a mistake in which app was named.
+     * Trigger an app\'s reconcile sweep
+     */
+    async registryReconcileApp(requestParameters, initOverrides) {
+        const response = await this.registryReconcileAppRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for registryUninstallApp without sending the request
+     */
+    async registryUninstallAppRequestOpts(requestParameters) {
+        if (requestParameters['app'] == null) {
+            throw new runtime.RequiredError('app', 'Required parameter "app" was null or undefined when calling registryUninstallApp().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/apps/{app}/uninstall`;
+        urlPath = urlPath.replace('{app}', encodeURIComponent(String(requestParameters['app'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Marks the install `uninstalling`, tells the app so it can release what it provisioned for this account, then archives the account\'s artifact for it.  **The account\'s artifacts are not touched.** Uninstalling `skill` does not archive the account\'s skills — the kind stays registered deployment-wide and the rows stay readable, so a re-install finds them. What the hook releases is the app\'s *own* per-account state (a bucket prefix, an external provider registration).  A failing hook does not fail the uninstall: an account that asked to remove an app must not stay installed because the app\'s cleanup failed. `204`, with nothing to say.
+     * Uninstall an app
+     */
+    async registryUninstallAppRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryUninstallAppRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * Marks the install `uninstalling`, tells the app so it can release what it provisioned for this account, then archives the account\'s artifact for it.  **The account\'s artifacts are not touched.** Uninstalling `skill` does not archive the account\'s skills — the kind stays registered deployment-wide and the rows stay readable, so a re-install finds them. What the hook releases is the app\'s *own* per-account state (a bucket prefix, an external provider registration).  A failing hook does not fail the uninstall: an account that asked to remove an app must not stay installed because the app\'s cleanup failed. `204`, with nothing to say.
+     * Uninstall an app
+     */
+    async registryUninstallApp(requestParameters, initOverrides) {
+        await this.registryUninstallAppRaw(requestParameters, initOverrides);
+    }
+    /**
+     * Creates request options for registryUpgradeApp without sending the request
+     */
+    async registryUpgradeAppRequestOpts(requestParameters) {
+        if (requestParameters['app'] == null) {
+            throw new runtime.RequiredError('app', 'Required parameter "app" was null or undefined when calling registryUpgradeApp().');
+        }
+        if (requestParameters['upgradeAppBody'] == null) {
+            throw new runtime.RequiredError('upgradeAppBody', 'Required parameter "upgradeAppBody" was null or undefined when calling registryUpgradeApp().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/apps/{app}/upgrade`;
+        urlPath = urlPath.replace('{app}', encodeURIComponent(String(requestParameters['app'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, UpgradeAppBody_1.UpgradeAppBodyToJSON)(requestParameters['upgradeAppBody']),
+        };
+    }
+    /**
+     * Records the account against the deployment\'s current `release` and contract version. `{\"is_pinned\": true}` freezes it there, so a later release does not move this account; `{\"is_pinned\": false}` releases the freeze.  **No hooks fire.** An upgrade changes which contract version the account is recorded against, and nothing else — re-running the seeding hook on every upgrade would re-seed an account that already has its rows. An app with per-version work to do has `reconcile`, which is triggered deliberately.
+     * Move an install to the registration head
+     */
+    async registryUpgradeAppRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryUpgradeAppRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, AppDto_1.AppDtoFromJSON)(jsonValue));
+    }
+    /**
+     * Records the account against the deployment\'s current `release` and contract version. `{\"is_pinned\": true}` freezes it there, so a later release does not move this account; `{\"is_pinned\": false}` releases the freeze.  **No hooks fire.** An upgrade changes which contract version the account is recorded against, and nothing else — re-running the seeding hook on every upgrade would re-seed an account that already has its rows. An app with per-version work to do has `reconcile`, which is triggered deliberately.
+     * Move an install to the registration head
+     */
+    async registryUpgradeApp(requestParameters, initOverrides) {
+        const response = await this.registryUpgradeAppRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+}
+exports.AppsApi = AppsApi;
+/**
+  * @export
+  * @enum {string}
+  */
+var RegistryInstallAppContentEncodingEnum;
+(function (RegistryInstallAppContentEncodingEnum) {
+    RegistryInstallAppContentEncodingEnum["Base64"] = "base64";
+    RegistryInstallAppContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(RegistryInstallAppContentEncodingEnum || (exports.RegistryInstallAppContentEncodingEnum = RegistryInstallAppContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var RegistryUpgradeAppContentEncodingEnum;
+(function (RegistryUpgradeAppContentEncodingEnum) {
+    RegistryUpgradeAppContentEncodingEnum["Base64"] = "base64";
+    RegistryUpgradeAppContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(RegistryUpgradeAppContentEncodingEnum || (exports.RegistryUpgradeAppContentEncodingEnum = RegistryUpgradeAppContentEncodingEnum = {}));

package/dist/raw/registry/apis/AuthApi.d.ts

@@ -20,12 +20,12 @@ export declare class AuthApi extends runtime.BaseAPI {
      */
     registryWhoamiRequestOpts(): Promise<runtime.RequestOpts>;
     /**
-     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, roles, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**, which is why every field is served from the verified token rather than defaulted. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
+     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, the caller\'s account `role` and its advisory `permissions`, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**. The identity fields come from the verified token; `role` and `permissions` are the registry\'s own truth, read from `users.role_id` — an unassigned human reads as `member`, and a machine or delegated caller carries neither. `permissions` is **advisory**: a display projection of the role, never an authorization decision, which is always a SpiceDB receipt. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
      * Introspect the caller\'s identity
      */
     registryWhoamiRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WhoamiResponse>>;
     /**
-     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, roles, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**, which is why every field is served from the verified token rather than defaulted. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
+     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, the caller\'s account `role` and its advisory `permissions`, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**. The identity fields come from the verified token; `role` and `permissions` are the registry\'s own truth, read from `users.role_id` — an unassigned human reads as `member`, and a machine or delegated caller carries neither. `permissions` is **advisory**: a display projection of the role, never an authorization decision, which is always a SpiceDB receipt. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
      * Introspect the caller\'s identity
      */
     registryWhoami(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WhoamiResponse>;

package/dist/raw/registry/apis/AuthApi.js

@@ -75,7 +75,7 @@ class AuthApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, roles, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**, which is why every field is served from the verified token rather than defaulted. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
+     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, the caller\'s account `role` and its advisory `permissions`, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**. The identity fields come from the verified token; `role` and `permissions` are the registry\'s own truth, read from `users.role_id` — an unassigned human reads as `member`, and a machine or delegated caller carries neither. `permissions` is **advisory**: a display projection of the role, never an authorization decision, which is always a SpiceDB receipt. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
      * Introspect the caller\'s identity
      */
     async registryWhoamiRaw(initOverrides) {
@@ -84,7 +84,7 @@ class AuthApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, WhoamiResponse_1.WhoamiResponseFromJSON)(jsonValue));
     }
     /**
-     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, roles, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**, which is why every field is served from the verified token rather than defaulted. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
+     * Echo back the verified identity resolved from the bearer token: subject, account, workspace hint, scopes, the caller\'s account `role` and its advisory `permissions`, any delegated actor, the token\'s expiry, and whether this caller has been onboarded.  Standalone extensions call this to reconstruct the caller\'s identity **without verifying the token themselves**. The identity fields come from the verified token; `role` and `permissions` are the registry\'s own truth, read from `users.role_id` — an unassigned human reads as `member`, and a machine or delegated caller carries neither. `permissions` is **advisory**: a display projection of the role, never an authorization decision, which is always a SpiceDB receipt. The raw token is never returned.  `is_onboarded` is a database read, not a claim: a caller can hold a valid token and have no personal workspace, and a client needs to tell those apart to know whether to send them through provisioning.
      * Introspect the caller\'s identity
      */
     async registryWhoami(initOverrides) {

package/dist/raw/registry/apis/DiscoveryApi.d.ts

@@ -16,13 +16,16 @@ import { type SearchPage } from '../models/SearchPage';
 import { type SearchRequest } from '../models/SearchRequest';
 export interface RegistryAggregateRequest {
     aggregateRequest: AggregateRequest;
+    contentEncoding?: RegistryAggregateContentEncodingEnum;
 }
 export interface RegistryAggregateKindRequest {
     artifactKind: string;
     aggregateRequest: AggregateRequest;
+    contentEncoding?: RegistryAggregateKindContentEncodingEnum;
 }
 export interface RegistrySearchRequest {
     searchRequest: SearchRequest;
+    contentEncoding?: RegistrySearchContentEncodingEnum;
 }
 /**
  *
@@ -71,3 +74,27 @@ export declare class DiscoveryApi extends runtime.BaseAPI {
      */
     registrySearch(requestParameters: RegistrySearchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SearchPage>;
 }
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryAggregateContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryAggregateKindContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistrySearchContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}