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

package/dist/resources/auth.d.ts

@@ -0,0 +1,50 @@
+import { type HttpCore } from '../http';
+import type { AuthResult, AuthStrategies, AuthUser, LoginInput, RegisterInput } from '../types';
+export declare class AuthResource {
+    private readonly http;
+    constructor(http: HttpCore);
+    /** `POST /auth/register`. Stores the session. */
+    register(input: RegisterInput): Promise<AuthResult>;
+    /** `POST /auth/login`. Stores the session. 403 `captcha_failed` when the
+     *  server enforces Turnstile and no `captchaToken` was sent. */
+    login(input: LoginInput): Promise<AuthResult>;
+    /**
+     * Start a browser OAuth sign-in (PKCE). Builds `GET /auth/:provider?returnTo=&codeChallenge=`
+     * (no network call): open `url` in the browser, keep `codeVerifier` (in
+     * memory / sessionStorage), and when the browser lands on `returnTo#code=...`
+     * call `oauthComplete`. `returnTo` must be in the server allow-list, else
+     * opening `url` answers 400 `return_to_not_allowed`. Needs a global WebCrypto
+     * or the `crypto` client option; throws otherwise.
+     */
+    oauthStart(provider: 'google' | 'github' | (string & {}), input: {
+        returnTo: string;
+    }): Promise<{
+        url: string;
+        codeVerifier: string;
+    }>;
+    /** `POST /auth/oauth/exchange` (public): trade the one-time `code` from the
+     *  redirect + the `codeVerifier` from `oauthStart` for a session. Stores it
+     *  like `login`. 400 `invalid_grant` when expired, reused or mismatched. */
+    oauthComplete(input: {
+        code: string;
+        codeVerifier: string;
+    }): Promise<AuthResult>;
+    /** `POST /auth/refresh` with the stored refresh token (single-flight with
+     *  the automatic refresh). Rotates and stores the new pair. Not needed in
+     *  normal use: a 401 refreshes by itself. */
+    refresh(): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    /** `POST /auth/logout` (a stateless no-op server-side), then wipes the
+     *  stored tokens even if the call fails. Does not fire `onSignedOut`. */
+    logout(): Promise<void>;
+    /** `GET /auth/me` */
+    me(): Promise<AuthUser>;
+    /** `POST /auth/me/onboarding/complete` (idempotent). */
+    completeOnboarding(): Promise<void>;
+    /** `POST /auth/me/onboarding/reopen` (idempotent). */
+    reopenOnboarding(): Promise<void>;
+    /** `GET /auth/strategies` (public): which sign-in methods the server has configured. */
+    strategies(): Promise<AuthStrategies>;
+}

package/dist/resources/auth.js

@@ -0,0 +1,87 @@
+"use strict";
+// auth: dashboard-session auth. Tokens go through the TokenStore; callers never
+// touch them. Routes: apps/server identity AuthController / OAuthController.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthResource = void 0;
+const http_1 = require("../http");
+const oauth_1 = require("../oauth");
+class AuthResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** `POST /auth/register`. Stores the session. */
+    async register(input) {
+        const res = await this.http.request('POST', '/auth/register', { body: input, auth: false });
+        await this.http.setSession(res);
+        return res;
+    }
+    /** `POST /auth/login`. Stores the session. 403 `captcha_failed` when the
+     *  server enforces Turnstile and no `captchaToken` was sent. */
+    async login(input) {
+        const res = await this.http.request('POST', '/auth/login', { body: input, auth: false });
+        await this.http.setSession(res);
+        return res;
+    }
+    /**
+     * Start a browser OAuth sign-in (PKCE). Builds `GET /auth/:provider?returnTo=&codeChallenge=`
+     * (no network call): open `url` in the browser, keep `codeVerifier` (in
+     * memory / sessionStorage), and when the browser lands on `returnTo#code=...`
+     * call `oauthComplete`. `returnTo` must be in the server allow-list, else
+     * opening `url` answers 400 `return_to_not_allowed`. Needs a global WebCrypto
+     * or the `crypto` client option; throws otherwise.
+     */
+    async oauthStart(provider, input) {
+        if (!input?.returnTo)
+            throw new Error('returnTo is required');
+        const crypto = (0, oauth_1.resolveCrypto)(this.http.crypto);
+        const codeVerifier = (0, oauth_1.generateCodeVerifier)(crypto);
+        const codeChallenge = await (0, oauth_1.codeChallengeS256)(crypto, codeVerifier);
+        const query = (0, http_1.buildQuery)({ returnTo: input.returnTo, codeChallenge });
+        return { url: `${this.http.baseURL}/auth/${(0, http_1.seg)(provider)}${query}`, codeVerifier };
+    }
+    /** `POST /auth/oauth/exchange` (public): trade the one-time `code` from the
+     *  redirect + the `codeVerifier` from `oauthStart` for a session. Stores it
+     *  like `login`. 400 `invalid_grant` when expired, reused or mismatched. */
+    async oauthComplete(input) {
+        const res = await this.http.request('POST', '/auth/oauth/exchange', {
+            body: { code: input.code, codeVerifier: input.codeVerifier },
+            auth: false,
+        });
+        await this.http.setSession(res);
+        return res;
+    }
+    /** `POST /auth/refresh` with the stored refresh token (single-flight with
+     *  the automatic refresh). Rotates and stores the new pair. Not needed in
+     *  normal use: a 401 refreshes by itself. */
+    async refresh() {
+        return this.http.refreshNow();
+    }
+    /** `POST /auth/logout` (a stateless no-op server-side), then wipes the
+     *  stored tokens even if the call fails. Does not fire `onSignedOut`. */
+    async logout() {
+        this.http.beginSessionChange();
+        try {
+            await this.http.request('POST', '/auth/logout');
+        }
+        finally {
+            await this.http.clearSession();
+        }
+    }
+    /** `GET /auth/me` */
+    async me() {
+        return this.http.request('GET', '/auth/me');
+    }
+    /** `POST /auth/me/onboarding/complete` (idempotent). */
+    async completeOnboarding() {
+        await this.http.request('POST', '/auth/me/onboarding/complete');
+    }
+    /** `POST /auth/me/onboarding/reopen` (idempotent). */
+    async reopenOnboarding() {
+        await this.http.request('POST', '/auth/me/onboarding/reopen');
+    }
+    /** `GET /auth/strategies` (public): which sign-in methods the server has configured. */
+    async strategies() {
+        return this.http.request('GET', '/auth/strategies', { auth: false });
+    }
+}
+exports.AuthResource = AuthResource;

package/dist/resources/connectors.d.ts

@@ -0,0 +1,25 @@
+import type { HttpCore } from '../http';
+import type { AuthorizeConnectorInput, ConnectorFacets, ConnectorStatus, ListConnectorsInput } from '../types';
+export declare class ConnectorsResource {
+    private readonly http;
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    private get tenantHeader();
+    /** `GET /connectors/oauth/directory` */
+    directory(input?: ListConnectorsInput): Promise<{
+        items: ConnectorStatus[];
+    }>;
+    /** `GET /connectors/oauth/directory/facets` */
+    facets(): Promise<ConnectorFacets>;
+    /** `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. */
+    authorize(connectorId: string, input: AuthorizeConnectorInput): Promise<{
+        url: string;
+    }>;
+    /** `POST /connectors/oauth/:id/api-key?tenantId=` for `authKind: 'api_key'`
+     *  connectors. The server pings the provider first (401 on a bad key). */
+    saveApiKey(connectorId: string, apiKey: string): Promise<{
+        connectorId: string;
+    }>;
+}

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;