@agentforge-io/sdk-console 0.0.0-stage → 0.1.0

package/dist/resources/connectors.js

@@ -0,0 +1,47 @@
+"use strict";
+// connectors for one workspace (`forTenant(id).connectors`): the directory
+// with per-workspace `connected` flags, and the OAuth / API-key connect flow.
+//
+// The directory resolves the workspace from the `X-Tenant-Id` header (the JWT
+// carries no tenant), so these calls send it. A browser therefore needs CORS
+// to allow that header.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorsResource = void 0;
+const http_1 = require("../http");
+class ConnectorsResource {
+    constructor(http, tenantId) {
+        this.http = http;
+        this.tenantId = tenantId;
+    }
+    get tenantHeader() {
+        return { 'X-Tenant-Id': this.tenantId };
+    }
+    /** `GET /connectors/oauth/directory` */
+    async directory(input = {}) {
+        return this.http.request('GET', '/connectors/oauth/directory', {
+            query: { ...input },
+            headers: this.tenantHeader,
+        });
+    }
+    /** `GET /connectors/oauth/directory/facets` */
+    async facets() {
+        return this.http.request('GET', '/connectors/oauth/directory/facets', { headers: this.tenantHeader });
+    }
+    /** `POST /connectors/oauth/:id/authorize?tenantId=&postAuthRedirect=`:
+     *  returns the provider consent URL to open in a browser; the grant is
+     *  stored for this workspace. Owner/admin only. */
+    async authorize(connectorId, input) {
+        return this.http.request('POST', `/connectors/oauth/${(0, http_1.seg)(connectorId)}/authorize`, {
+            query: { postAuthRedirect: input.postAuthRedirect, tenantId: this.tenantId, shop: input.shop },
+        });
+    }
+    /** `POST /connectors/oauth/:id/api-key?tenantId=` for `authKind: 'api_key'`
+     *  connectors. The server pings the provider first (401 on a bad key). */
+    async saveApiKey(connectorId, apiKey) {
+        return this.http.request('POST', `/connectors/oauth/${(0, http_1.seg)(connectorId)}/api-key`, {
+            query: { tenantId: this.tenantId },
+            body: { apiKey },
+        });
+    }
+}
+exports.ConnectorsResource = ConnectorsResource;

package/dist/resources/marketplace.d.ts

@@ -0,0 +1,10 @@
+import type { HttpCore } from '../http';
+import type { MarketplaceCategory } from '../types';
+export declare class MarketplaceResource {
+    private readonly http;
+    constructor(http: HttpCore);
+    /** `GET /marketplace/categories` */
+    categories(): Promise<{
+        items: MarketplaceCategory[];
+    }>;
+}

package/dist/resources/marketplace.js

@@ -0,0 +1,14 @@
+"use strict";
+// marketplace: listing taxonomy. `client.marketplace`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketplaceResource = void 0;
+class MarketplaceResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** `GET /marketplace/categories` */
+    async categories() {
+        return this.http.request('GET', '/marketplace/categories');
+    }
+}
+exports.MarketplaceResource = MarketplaceResource;

package/dist/resources/members.d.ts

@@ -0,0 +1,62 @@
+import type { HttpCore } from '../http';
+import type { AcceptInviteInput, AuthResult, CreateInviteInput, InvitePreview, TenantInvite, TenantMember } from '../types';
+export declare class MembersResource {
+    private readonly http;
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    private get base();
+    /** `GET /admin/tenants/:tenantId/members` (the owner comes with `id: null`). */
+    list(): Promise<{
+        items: TenantMember[];
+    }>;
+    /** `POST .../members`. The email must already belong to a registered user
+     *  (404 otherwise): use `invites.create` for an unregistered one. Owner/admin only. */
+    add(input: {
+        email: string;
+        role?: 'member' | 'admin';
+    }): Promise<TenantMember>;
+    /** `PATCH .../members/:membershipId` (membershipId = `TenantMember.id`). Owner/admin only. */
+    updateRole(membershipId: string, role: 'member' | 'admin'): Promise<{
+        ok: true;
+    }>;
+    /** `DELETE .../members/:membershipId`. Owner/admin only. */
+    remove(membershipId: string): Promise<void>;
+    /** `POST .../members/transfer-ownership`. Owner only; the target must be a
+     *  member. The former owner becomes admin. */
+    transferOwnership(input: {
+        toUserId?: string;
+        toEmail?: string;
+    }): Promise<void>;
+}
+/** Public side of invites: no session needed. `client.invites`. */
+export declare class PublicInvitesResource {
+    protected readonly http: HttpCore;
+    constructor(http: HttpCore);
+    /** `GET /invite/:token` (public). */
+    getByToken(token: string): Promise<InvitePreview>;
+    /** `POST /invite/:token/accept` (public). Creates the account, joins the
+     *  workspace and stores the new session. */
+    accept(token: string, input: AcceptInviteInput): Promise<AuthResult>;
+}
+/** `forTenant(id).invites`: the admin side plus the public lookups. */
+export declare class InvitesResource extends PublicInvitesResource {
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    private get base();
+    /** `GET /admin/tenants/:tenantId/invites` (pending). */
+    list(): Promise<{
+        items: TenantInvite[];
+    }>;
+    /** `POST .../invites` */
+    create(input: CreateInviteInput): Promise<{
+        status: 'invited';
+        invite: TenantInvite;
+    }>;
+    /** `POST .../invites/:inviteId/resend` */
+    resend(inviteId: string): Promise<{
+        status: 'resent';
+        invite: TenantInvite;
+    }>;
+    /** `DELETE .../invites/:inviteId` */
+    revoke(inviteId: string): Promise<void>;
+}

package/dist/resources/members.js

@@ -0,0 +1,85 @@
+"use strict";
+// members + invites of one workspace (`forTenant(id).members` / `.invites`).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvitesResource = exports.PublicInvitesResource = exports.MembersResource = void 0;
+const http_1 = require("../http");
+class MembersResource {
+    constructor(http, tenantId) {
+        this.http = http;
+        this.tenantId = tenantId;
+    }
+    get base() {
+        return `/admin/tenants/${(0, http_1.seg)(this.tenantId)}/members`;
+    }
+    /** `GET /admin/tenants/:tenantId/members` (the owner comes with `id: null`). */
+    async list() {
+        return this.http.request('GET', this.base);
+    }
+    /** `POST .../members`. The email must already belong to a registered user
+     *  (404 otherwise): use `invites.create` for an unregistered one. Owner/admin only. */
+    async add(input) {
+        return this.http.request('POST', this.base, { body: input });
+    }
+    /** `PATCH .../members/:membershipId` (membershipId = `TenantMember.id`). Owner/admin only. */
+    async updateRole(membershipId, role) {
+        return this.http.request('PATCH', `${this.base}/${(0, http_1.seg)(membershipId)}`, { body: { role } });
+    }
+    /** `DELETE .../members/:membershipId`. Owner/admin only. */
+    async remove(membershipId) {
+        await this.http.request('DELETE', `${this.base}/${(0, http_1.seg)(membershipId)}`);
+    }
+    /** `POST .../members/transfer-ownership`. Owner only; the target must be a
+     *  member. The former owner becomes admin. */
+    async transferOwnership(input) {
+        await this.http.request('POST', `${this.base}/transfer-ownership`, { body: input });
+    }
+}
+exports.MembersResource = MembersResource;
+/** Public side of invites: no session needed. `client.invites`. */
+class PublicInvitesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** `GET /invite/:token` (public). */
+    async getByToken(token) {
+        return this.http.request('GET', `/invite/${(0, http_1.seg)(token)}`, { auth: false });
+    }
+    /** `POST /invite/:token/accept` (public). Creates the account, joins the
+     *  workspace and stores the new session. */
+    async accept(token, input) {
+        const res = await this.http.request('POST', `/invite/${(0, http_1.seg)(token)}/accept`, {
+            body: input,
+            auth: false,
+        });
+        await this.http.setSession(res);
+        return res;
+    }
+}
+exports.PublicInvitesResource = PublicInvitesResource;
+/** `forTenant(id).invites`: the admin side plus the public lookups. */
+class InvitesResource extends PublicInvitesResource {
+    constructor(http, tenantId) {
+        super(http);
+        this.tenantId = tenantId;
+    }
+    get base() {
+        return `/admin/tenants/${(0, http_1.seg)(this.tenantId)}/invites`;
+    }
+    /** `GET /admin/tenants/:tenantId/invites` (pending). */
+    async list() {
+        return this.http.request('GET', this.base);
+    }
+    /** `POST .../invites` */
+    async create(input) {
+        return this.http.request('POST', this.base, { body: input });
+    }
+    /** `POST .../invites/:inviteId/resend` */
+    async resend(inviteId) {
+        return this.http.request('POST', `${this.base}/${(0, http_1.seg)(inviteId)}/resend`);
+    }
+    /** `DELETE .../invites/:inviteId` */
+    async revoke(inviteId) {
+        await this.http.request('DELETE', `${this.base}/${(0, http_1.seg)(inviteId)}`);
+    }
+}
+exports.InvitesResource = InvitesResource;

package/dist/resources/playground.d.ts

@@ -0,0 +1,22 @@
+import type { HttpCore } from '../http';
+import type { PlaygroundRun, StartPlaygroundRunInput } from '../types';
+export declare class PlaygroundResource {
+    private readonly http;
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    /** `GET /playgrounds/runs?tenantId=&teamId=&limit=` */
+    list(input?: {
+        teamId?: string;
+        limit?: number;
+    }): Promise<{
+        items: PlaygroundRun[];
+    }>;
+    /** `GET /playgrounds/runs/:id` */
+    get(runId: string): Promise<PlaygroundRun>;
+    /** `POST /playgrounds/runs`: creates a channel, joins the team and posts the scenario prompt. */
+    create(input: StartPlaygroundRunInput): Promise<PlaygroundRun>;
+    /** `POST /playgrounds/runs/:id/finalize` */
+    finalize(runId: string): Promise<PlaygroundRun>;
+    /** `POST /playgrounds/runs/:id/abort` */
+    abort(runId: string): Promise<PlaygroundRun>;
+}

package/dist/resources/playground.js

@@ -0,0 +1,32 @@
+"use strict";
+// playground: scripted test runs of a team (`forTenant(id).playground`).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaygroundResource = void 0;
+const http_1 = require("../http");
+class PlaygroundResource {
+    constructor(http, tenantId) {
+        this.http = http;
+        this.tenantId = tenantId;
+    }
+    /** `GET /playgrounds/runs?tenantId=&teamId=&limit=` */
+    async list(input = {}) {
+        return this.http.request('GET', '/playgrounds/runs', { query: { tenantId: this.tenantId, ...input } });
+    }
+    /** `GET /playgrounds/runs/:id` */
+    async get(runId) {
+        return this.http.request('GET', `/playgrounds/runs/${(0, http_1.seg)(runId)}`);
+    }
+    /** `POST /playgrounds/runs`: creates a channel, joins the team and posts the scenario prompt. */
+    async create(input) {
+        return this.http.request('POST', '/playgrounds/runs', { body: { tenantId: this.tenantId, ...input } });
+    }
+    /** `POST /playgrounds/runs/:id/finalize` */
+    async finalize(runId) {
+        return this.http.request('POST', `/playgrounds/runs/${(0, http_1.seg)(runId)}/finalize`);
+    }
+    /** `POST /playgrounds/runs/:id/abort` */
+    async abort(runId) {
+        return this.http.request('POST', `/playgrounds/runs/${(0, http_1.seg)(runId)}/abort`);
+    }
+}
+exports.PlaygroundResource = PlaygroundResource;

package/dist/resources/teams.d.ts

@@ -0,0 +1,49 @@
+import type { HttpCore } from '../http';
+import type { CreateTeamInput, Team, TeamHumanMember, TeamHumanMemberInput, TeamList, TeamPublication, TeamPublicationSummary, TeamWithMembers, UpdateTeamInput } from '../types';
+export declare class TeamsResource {
+    private readonly http;
+    private readonly tenantId;
+    /** Workspace users attached to a team (human-in-the-loop roster). */
+    readonly humanMembers: TeamHumanMembersResource;
+    constructor(http: HttpCore, tenantId: string);
+    private get base();
+    /** `GET /admin/tenants/:tenantId/teams`. Each team carries `templateSourceOf`;
+     *  `excludeTemplateSources: true` leaves out the template source copies. */
+    list(input?: {
+        appId?: string;
+        excludeTemplateSources?: boolean;
+    }): Promise<TeamList>;
+    /** `POST .../teams`. The server creates the orchestrator agent. */
+    create(input: CreateTeamInput): Promise<Team>;
+    /** `GET .../teams/:teamId` */
+    get(teamId: string): Promise<TeamWithMembers>;
+    /** `PATCH .../teams/:teamId`. `members` replaces the full ordered list. */
+    update(teamId: string, patch: UpdateTeamInput): Promise<Team>;
+    /** `DELETE .../teams/:teamId` */
+    delete(teamId: string): Promise<void>;
+    /** `GET .../teams/:teamId/publication`: status + validation issues. */
+    publication(teamId: string, input?: {
+        publisherAppId?: string;
+    }): Promise<TeamPublication>;
+    /** `GET .../teams/publication`: status of every team (no issues). */
+    listPublication(): Promise<{
+        items: TeamPublicationSummary[];
+    }>;
+    /** `POST .../teams/:teamId/publish`. 409 `team_not_publishable`
+     *  (`ApiError.details.issues`) when the validation has errors. */
+    publish(teamId: string): Promise<TeamPublication>;
+}
+export declare class TeamHumanMembersResource {
+    private readonly http;
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    private base;
+    /** `GET .../teams/:teamId/human-members` */
+    list(teamId: string): Promise<TeamHumanMember[]>;
+    /** `POST .../teams/:teamId/human-members` */
+    add(teamId: string, input: TeamHumanMemberInput): Promise<TeamHumanMember>;
+    /** `PATCH .../human-members/:userId` */
+    update(teamId: string, userId: string, patch: Partial<Omit<TeamHumanMemberInput, 'userId'>>): Promise<TeamHumanMember>;
+    /** `DELETE .../human-members/:userId` */
+    remove(teamId: string, userId: string): Promise<void>;
+}

package/dist/resources/teams.js

@@ -0,0 +1,78 @@
+"use strict";
+// teams of one workspace (`forTenant(id).teams`).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamHumanMembersResource = exports.TeamsResource = void 0;
+const http_1 = require("../http");
+class TeamsResource {
+    constructor(http, tenantId) {
+        this.http = http;
+        this.tenantId = tenantId;
+        this.humanMembers = new TeamHumanMembersResource(http, tenantId);
+    }
+    get base() {
+        return `/admin/tenants/${(0, http_1.seg)(this.tenantId)}/teams`;
+    }
+    /** `GET /admin/tenants/:tenantId/teams`. Each team carries `templateSourceOf`;
+     *  `excludeTemplateSources: true` leaves out the template source copies. */
+    async list(input = {}) {
+        return this.http.request('GET', this.base, { query: { ...input } });
+    }
+    /** `POST .../teams`. The server creates the orchestrator agent. */
+    async create(input) {
+        return this.http.request('POST', this.base, { body: input });
+    }
+    /** `GET .../teams/:teamId` */
+    async get(teamId) {
+        return this.http.request('GET', `${this.base}/${(0, http_1.seg)(teamId)}`);
+    }
+    /** `PATCH .../teams/:teamId`. `members` replaces the full ordered list. */
+    async update(teamId, patch) {
+        return this.http.request('PATCH', `${this.base}/${(0, http_1.seg)(teamId)}`, { body: patch });
+    }
+    /** `DELETE .../teams/:teamId` */
+    async delete(teamId) {
+        await this.http.request('DELETE', `${this.base}/${(0, http_1.seg)(teamId)}`);
+    }
+    /** `GET .../teams/:teamId/publication`: status + validation issues. */
+    async publication(teamId, input = {}) {
+        return this.http.request('GET', `${this.base}/${(0, http_1.seg)(teamId)}/publication`, {
+            query: { publisherAppId: input.publisherAppId },
+        });
+    }
+    /** `GET .../teams/publication`: status of every team (no issues). */
+    async listPublication() {
+        return this.http.request('GET', `${this.base}/publication`);
+    }
+    /** `POST .../teams/:teamId/publish`. 409 `team_not_publishable`
+     *  (`ApiError.details.issues`) when the validation has errors. */
+    async publish(teamId) {
+        return this.http.request('POST', `${this.base}/${(0, http_1.seg)(teamId)}/publish`);
+    }
+}
+exports.TeamsResource = TeamsResource;
+class TeamHumanMembersResource {
+    constructor(http, tenantId) {
+        this.http = http;
+        this.tenantId = tenantId;
+    }
+    base(teamId) {
+        return `/admin/tenants/${(0, http_1.seg)(this.tenantId)}/teams/${(0, http_1.seg)(teamId)}/human-members`;
+    }
+    /** `GET .../teams/:teamId/human-members` */
+    async list(teamId) {
+        return this.http.request('GET', this.base(teamId));
+    }
+    /** `POST .../teams/:teamId/human-members` */
+    async add(teamId, input) {
+        return this.http.request('POST', this.base(teamId), { body: input });
+    }
+    /** `PATCH .../human-members/:userId` */
+    async update(teamId, userId, patch) {
+        return this.http.request('PATCH', `${this.base(teamId)}/${(0, http_1.seg)(userId)}`, { body: patch });
+    }
+    /** `DELETE .../human-members/:userId` */
+    async remove(teamId, userId) {
+        await this.http.request('DELETE', `${this.base(teamId)}/${(0, http_1.seg)(userId)}`);
+    }
+}
+exports.TeamHumanMembersResource = TeamHumanMembersResource;

package/dist/resources/templates.d.ts

@@ -0,0 +1,115 @@
+import type { HttpCore } from '../http';
+import type { InstallTemplateInput, ListTemplatesInput, SaveTemplateInput, SignListingAssetInput, SignedUpload, Template, TemplateConfigField, TemplateConfigFields, TemplateInstallResult, TemplateListingPatch, TemplatePolicyCheck, TemplateReadiness, TemplateSourceStatus, TemplateVersionRow, TemplateVersionView, UpdateFromTemplateResult, UpdatesAvailable, VersionDiff, VersionHistory } from '../types';
+export declare class TemplatesResource {
+    protected readonly http: HttpCore;
+    constructor(http: HttpCore);
+    /** `GET /public/templates`: system + public, listed rows only. */
+    listPublic(input?: Omit<ListTemplatesInput, 'publisherAppId'>): Promise<{
+        items: Template[];
+    }>;
+    /** `GET /public/templates/:id` (404 for tenant-private or unlisted rows). */
+    getPublic(templateId: string): Promise<Template>;
+    /** `GET /templates/:id` (with payload). */
+    get(templateId: string): Promise<Template>;
+    /** `PATCH /templates/:id`: metadata + listing (name, logo, cover, categories, guide, locale). */
+    updateListing(templateId: string, patch: TemplateListingPatch): Promise<Template>;
+    /** `GET /templates/:id/policy-check`: dry run of an App's template policy against a version
+     *  (default: open draft, else published). `publisherAppId` defaults to the template's own publisher. */
+    policyCheck(templateId: string, input?: {
+        publisherAppId?: string;
+        version?: number;
+    }): Promise<TemplatePolicyCheck>;
+    /** `POST /templates/:id/listing-assets/sign`: PUT the bytes to `uploadUrl`, then `updateListing({ logoUrl | coverUrl: publicUrl })`. */
+    signListingAsset(templateId: string, input: SignListingAssetInput): Promise<SignedUpload>;
+    /** `GET /templates/:id/versions` (published snapshots). */
+    listVersions(templateId: string): Promise<{
+        items: TemplateVersionRow[];
+    }>;
+    /** `GET /templates/:id/version-history` */
+    versionHistory(templateId: string): Promise<VersionHistory>;
+    /** `GET /templates/:id/diff?from=&to=`; `to: 'source'` compares with the live source team. */
+    diff(templateId: string, from: number, to: number | 'source'): Promise<VersionDiff>;
+    /** `POST /templates/:id/drafts`: snapshot the source team as a new draft version. */
+    snapshotDraft(templateId: string): Promise<TemplateVersionView>;
+    /** `POST /templates/:id/versions/:v/submit`: draft -> in review. */
+    submitVersion(templateId: string, version: number, changelog: string): Promise<TemplateVersionView>;
+    /** `POST /templates/:id/versions/:v/review` */
+    reviewVersion(templateId: string, version: number, decision: 'approved' | 'changes_requested', comment?: string): Promise<TemplateVersionView>;
+    /** `POST /templates/:id/versions/:v/publish` */
+    publishVersion(templateId: string, version: number, changelog?: string): Promise<TemplateVersionView>;
+    /** `DELETE /templates/:id/versions/:v`: discard a draft. */
+    discardVersion(templateId: string, version: number): Promise<{
+        ok: true;
+    }>;
+    /** `POST /templates/:id/versions/:v/restore`: new draft from an old version. */
+    restoreVersion(templateId: string, version: number): Promise<TemplateVersionView>;
+    /** `PUT /templates/:id/source`: make a team of the template's workspace its source. */
+    linkSource(templateId: string, teamId: string): Promise<{
+        ok: true;
+    }>;
+    /** `DELETE /templates/:id/source` */
+    unlinkSource(templateId: string): Promise<{
+        ok: true;
+    }>;
+    /** `POST /templates/:id/source/copy`: create the editable copy from the published version and link it. */
+    createSourceCopy(templateId: string): Promise<{
+        teamId: string;
+    }>;
+    /** `PATCH /templates/:id/review-policy` */
+    setReviewPolicy(templateId: string, policy: {
+        requiredApprovals: number | null;
+        approverUserIds: string[] | null;
+    }): Promise<{
+        ok: true;
+    }>;
+    /** `GET /templates/:id/config-fields` (open draft, else published). */
+    configFields(templateId: string): Promise<TemplateConfigFields>;
+    /** `PUT /templates/:id/config-fields` (saved on the open draft). 400 `invalid_config_schema` if malformed. */
+    setConfigFields(templateId: string, configSchema: TemplateConfigField[]): Promise<{
+        draftVersion: number | null;
+    }>;
+}
+/** `forTenant(id).templates`: everything of `client.templates` plus the workspace-bound calls. */
+export declare class TenantTemplatesResource extends TemplatesResource {
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    private get tenantBase();
+    /** `GET /templates?tenantId=`: system + public + this workspace's own. */
+    list(input?: ListTemplatesInput): Promise<{
+        items: Template[];
+    }>;
+    /** `POST /templates/:id/install` into this workspace. */
+    install(templateId: string, input?: InstallTemplateInput): Promise<TemplateInstallResult>;
+    /** `GET /templates/:id/install-readiness?destinationTenantId=`: what is ready / needs setup before installing here. */
+    installReadiness(templateId: string): Promise<TemplateReadiness>;
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/save-as-template` */
+    saveAgentAsTemplate(agentId: string, input?: SaveTemplateInput): Promise<Template>;
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/save-as-template` */
+    saveTeamAsTemplate(teamId: string, input?: SaveTemplateInput): Promise<Template>;
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/publish-template-version` */
+    publishAgentTemplateVersion(agentId: string, input: {
+        templateId: string;
+        changelog?: string;
+        publisherAppId?: string | null;
+    }): Promise<Template>;
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/publish-template-version` */
+    publishTeamTemplateVersion(teamId: string, input: {
+        templateId: string;
+        changelog?: string;
+        publisherAppId?: string | null;
+    }): Promise<Template>;
+    /** `GET /admin/tenants/:tenantId/teams/:teamId/template-source`: the template this team is the source of, with its version state. */
+    templateSource(teamId: string): Promise<{
+        source: TemplateSourceStatus | null;
+    }>;
+    /** `GET /me/template-updates-available?tenantId=`: installed agents/teams behind their template. */
+    updatesAvailable(): Promise<UpdatesAvailable>;
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/update-from-template` */
+    updateTeamFromTemplate(teamId: string, input?: {
+        targetVersion?: number;
+    }): Promise<UpdateFromTemplateResult>;
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/update-from-template` */
+    updateAgentFromTemplate(agentId: string, input?: {
+        targetVersion?: number;
+    }): Promise<UpdateFromTemplateResult>;
+}