@arbium/enterprise-agent-connect-client 0.2.0 → 0.2.1-dev.fd7a648

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 import { type AppLive } from "./steps.js";
-import type { Agent, CheckOutcome, Connection, Connector, EventSubscriptionInput, EventTriggerInput, Limits, SiteAccess, TeamsTriggerInput } from "./types.js";
+import type { Agent, Body, CheckOutcome, Connection, Connector, EventSubscriptionInput, EventTriggerInput, Limits, SiteAccess, TeamsTriggerInput } from "./types.js";
 export * from "./steps.js";
 export type * from "./types.js";
 /** A refusal the admin should read (4xx with an `error`): bad input, a failed connection
@@ -626,6 +626,597 @@ export declare function createClient(options: ClientOptions): {
             };
         };
     }[]>;
+    /** The deployment's apps and the organization's own internal apps. */
+    orgConnectors: (o: string) => Promise<{
+        id: string;
+        name: string;
+        description: string;
+        logo: string;
+        identity: string;
+        signsInAs?: "agentBot";
+        provider?: string;
+        order?: number;
+        connectionKind: "guided";
+        accountKey: string;
+        scopes?: string[];
+        setup: {
+            title: string;
+            body: string;
+            link?: {
+                label: string;
+                href: string;
+            };
+            copy?: string[];
+            shell?: "bash" | "powershell";
+            permissions?: boolean;
+            certificate?: boolean;
+            click?: string[];
+            clickUnavailable?: true;
+            siteRole?: "read" | "write";
+            agentCheck?: boolean;
+            confirm?: string;
+            live?: string;
+            settings?: {
+                id: string;
+                label: string;
+                help?: string;
+                placeholder?: string;
+                pattern: string;
+            }[];
+            option?: {
+                field: string;
+                value: string;
+            };
+            capabilities?: string[];
+        }[];
+        afterConnect: {
+            title: string;
+            body: string;
+            link?: {
+                label: string;
+                href: string;
+            };
+            copy?: string[];
+            shell?: "bash" | "powershell";
+            permissions?: boolean;
+            certificate?: boolean;
+            click?: string[];
+            clickUnavailable?: true;
+            siteRole?: "read" | "write";
+            agentCheck?: boolean;
+            confirm?: string;
+            live?: string;
+            settings?: {
+                id: string;
+                label: string;
+                help?: string;
+                placeholder?: string;
+                pattern: string;
+            }[];
+            option?: {
+                field: string;
+                value: string;
+            };
+            capabilities?: string[];
+        }[];
+        fields: {
+            id: string;
+            label: string;
+            help?: string;
+            placeholder?: string;
+            secret: boolean;
+            options?: {
+                value: string;
+                label: string;
+                description: string;
+                scopes?: string[];
+            }[];
+            requires?: {
+                field: string;
+                value: string;
+            };
+            optional: boolean;
+        }[];
+        capabilities: {
+            id: string;
+            label: string;
+            description: string;
+            required: boolean;
+            destructive: boolean;
+            costs?: boolean;
+            scopes: string[];
+            roles?: string[];
+            permissions: string[];
+            fill?: {
+                [key: string]: string;
+            };
+            note?: string;
+            forbidden?: string;
+            claudeKey?: boolean;
+            tools: string[];
+        }[];
+        limits: {
+            id: string;
+            label: string;
+            help: string;
+            kind: "list" | "text" | "map";
+            required: boolean;
+            pattern?: string;
+            keys?: string;
+        }[];
+        siteAccess?: {
+            grant: {
+                title: string;
+                body: string;
+                link?: {
+                    label: string;
+                    href: string;
+                };
+                copy?: string[];
+                shell?: "bash" | "powershell";
+                permissions?: boolean;
+                certificate?: boolean;
+                click?: string[];
+                clickUnavailable?: true;
+                siteRole?: "read" | "write";
+                agentCheck?: boolean;
+                confirm?: string;
+                live?: string;
+                settings?: {
+                    id: string;
+                    label: string;
+                    help?: string;
+                    placeholder?: string;
+                    pattern: string;
+                }[];
+                option?: {
+                    field: string;
+                    value: string;
+                };
+            }[];
+            request: string;
+            write: string[];
+        };
+        agentAccess?: {
+            limit: string;
+            label: string;
+            path: string & (unknown & unknown);
+            granted: string;
+            notGranted: string;
+            notFound: string;
+            probes: {
+                [key: string]: {
+                    method: "GET" | "POST" | "PATCH";
+                    path: string & (unknown & unknown);
+                    body?: unknown;
+                    allowed: number[];
+                };
+            };
+            missing?: string;
+        };
+        verify: {
+            method: "GET" | "POST";
+            path: string;
+            label: string;
+            show: string;
+            name?: string;
+            match?: {
+                [key: string]: string | number | boolean;
+            };
+            body?: {
+                [key: string]: unknown;
+            };
+            ifEmpty?: string;
+        } | {
+            label: string;
+            check: string;
+            ifEmpty?: string;
+        };
+        discover?: {
+            method: "GET" | "POST";
+            path: string;
+            label: string;
+            show: string;
+            name?: string;
+            match?: {
+                [key: string]: string | number | boolean;
+            };
+            body?: {
+                [key: string]: unknown;
+            };
+            ifEmpty?: string;
+        } | {
+            label: string;
+            check: string;
+            ifEmpty?: string;
+        };
+        revoke: string;
+        http?: {
+            baseUrl: string;
+            auth: {
+                type: "header";
+                header: string;
+                value: string;
+                prefix?: string;
+            } | {
+                type: "bearer";
+                token: string;
+            } | {
+                type: "basic";
+                username: string;
+                password: string;
+            } | {
+                type: "oauth2";
+                tokenUrl: string;
+                clientId: string;
+                clientSecret: string;
+                scope?: string;
+            } | {
+                type: "query";
+                param: string;
+                value: string;
+            };
+            headers: {
+                [key: string]: string;
+            };
+            tools: {
+                name: string;
+                description: string;
+                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+                path: string;
+                params: {
+                    [key: string]: {
+                        type: "string" | "number" | "integer" | "boolean" | "array";
+                        description: string;
+                        in: "path" | "query" | "body";
+                        name?: string;
+                        required: boolean;
+                        default?: (string | number | boolean) | (string | number | boolean)[];
+                        enum?: (string | number | boolean)[];
+                        items?: "string" | "number" | "integer" | "boolean";
+                        join?: string;
+                        limit?: string;
+                    };
+                };
+                destructive: boolean;
+                answerLimits: {
+                    field: string;
+                    limit: string;
+                }[];
+                result?: {
+                    items?: string;
+                    fields?: string[];
+                };
+                paging?: {
+                    param: string;
+                    body: string;
+                } | {
+                    param: string;
+                    header: string;
+                } | {
+                    param: string;
+                    link: true;
+                };
+            }[];
+            allowInsecureHttp: boolean;
+        };
+        soap?: {
+            endpoint: string;
+            version: "1.1" | "1.2";
+            namespaces: {
+                [key: string]: string;
+            };
+            auth?: {
+                type: "header";
+                header: string;
+                value: string;
+                prefix?: string;
+            } | {
+                type: "bearer";
+                token: string;
+            } | {
+                type: "basic";
+                username: string;
+                password: string;
+            };
+            wsSecurity?: {
+                username: string;
+                password: string;
+                digest: boolean;
+            };
+            verify?: {
+                tool: string;
+                args: {
+                    [key: string]: string | number | boolean;
+                };
+                show: string;
+            };
+            tools: {
+                name: string;
+                description: string;
+                operation: string;
+                soapAction?: string;
+                body: string;
+                params: {
+                    [key: string]: {
+                        type: "string" | "number" | "integer" | "boolean";
+                        description: string;
+                        required: boolean;
+                        limit?: string;
+                    };
+                };
+                result?: string;
+                fields?: string[];
+                readOnly: boolean;
+                destructive: boolean;
+                answerLimits: {
+                    field: string;
+                    limit: string;
+                }[];
+            }[];
+            allowInsecureHttp: boolean;
+        };
+        odata?: {
+            serviceRoot: string;
+            version: "2" | "4";
+            auth: {
+                type: "header";
+                header: string;
+                value: string;
+                prefix?: string;
+            } | {
+                type: "bearer";
+                token: string;
+            } | {
+                type: "basic";
+                username: string;
+                password: string;
+            } | {
+                type: "oauth2";
+                tokenUrl: string;
+                clientId: string;
+                clientSecret: string;
+                scope?: string;
+            } | {
+                type: "query";
+                param: string;
+                value: string;
+            };
+            headers: {
+                [key: string]: string;
+            };
+            csrf: boolean;
+            paging: "skip" | "server";
+            tools: {
+                name: string;
+                description: string;
+                kind: "list" | "get" | "create" | "update" | "function" | "action";
+                entitySet?: string;
+                function?: string;
+                key: {
+                    [key: string]: {
+                        type: "string" | "integer" | "number" | "decimal" | "boolean" | "guid" | "datetime" | "datetimeoffset";
+                        description: string;
+                        property?: string;
+                        required?: boolean;
+                        limit?: string;
+                    };
+                };
+                filters: {
+                    [key: string]: {
+                        type: "string" | "integer" | "number" | "decimal" | "boolean" | "guid" | "datetime" | "datetimeoffset";
+                        description: string;
+                        property?: string;
+                        required?: boolean;
+                        limit?: string;
+                        op: "eq" | "ne" | "gt" | "ge" | "lt" | "le" | "contains" | "startswith";
+                    };
+                };
+                fields: {
+                    [key: string]: {
+                        type: "string" | "integer" | "number" | "decimal" | "boolean" | "guid" | "datetime" | "datetimeoffset";
+                        description: string;
+                        property?: string;
+                        required?: boolean;
+                        limit?: string;
+                    };
+                };
+                params: {
+                    [key: string]: {
+                        type: "string" | "integer" | "number" | "decimal" | "boolean" | "guid" | "datetime" | "datetimeoffset";
+                        description: string;
+                        property?: string;
+                        required?: boolean;
+                        limit?: string;
+                    };
+                };
+                select: string[];
+                orderBy?: string;
+                top: number;
+                destructive: boolean;
+                answerLimits: {
+                    field: string;
+                    limit: string;
+                }[];
+            }[];
+            allowInsecureHttp: boolean;
+        };
+        sql?: {
+            engine: "postgres" | "sqlserver" | "mysql" | "oracle";
+            host: string;
+            port?: number;
+            database: string;
+            auth: {
+                user: string;
+                password: string;
+            };
+            tls: "verify" | "insecure" | "off";
+            timeoutSeconds: number;
+            maxRows: number;
+            tools: {
+                name: string;
+                description: string;
+                sql: string;
+                params: {
+                    [key: string]: {
+                        type: "string" | "number" | "integer" | "boolean";
+                        description: string;
+                        required: boolean;
+                        limit?: string;
+                    };
+                };
+                write: boolean;
+                destructive: boolean;
+                answerLimits: {
+                    column: string;
+                    limit: string;
+                }[];
+            }[];
+        };
+        events?: {
+            types: {
+                id: string;
+                label: string;
+            }[];
+            fields: {
+                [key: string]: string;
+            };
+            limits: {
+                [key: string]: string;
+            };
+            webhook?: {
+                verify: {
+                    type: "hmac-sha256";
+                    header: string;
+                    prefix: string;
+                } | {
+                    type: "token";
+                    header: string;
+                } | {
+                    type: "none";
+                };
+                allowInsecure: boolean;
+                type: {
+                    field: string;
+                } | {
+                    header: string;
+                };
+                deliveryId?: {
+                    field: string;
+                } | {
+                    header: string;
+                };
+                timestamp?: {
+                    at: {
+                        field: string;
+                    } | {
+                        header: string;
+                    };
+                    unit: "s" | "ms" | "iso";
+                    toleranceSeconds: number;
+                };
+                setup: {
+                    title: string;
+                    body: string;
+                    link?: {
+                        label: string;
+                        href: string;
+                    };
+                    copy?: string[];
+                    shell?: "bash" | "powershell";
+                    permissions?: boolean;
+                    certificate?: boolean;
+                    click?: string[];
+                    clickUnavailable?: true;
+                    siteRole?: "read" | "write";
+                    agentCheck?: boolean;
+                    confirm?: string;
+                    live?: string;
+                    settings?: {
+                        id: string;
+                        label: string;
+                        help?: string;
+                        placeholder?: string;
+                        pattern: string;
+                    }[];
+                    option?: {
+                        field: string;
+                        value: string;
+                    };
+                }[];
+                register?: {
+                    method: "GET" | "POST" | "PUT";
+                    path: string;
+                    body?: unknown;
+                    location: string;
+                };
+            };
+            self?: {
+                request: {
+                    method: "GET" | "POST" | "PUT";
+                    path: string;
+                    body?: unknown;
+                };
+                id: string;
+                fields: string[];
+            };
+            poll?: {
+                request: {
+                    method: "GET" | "POST" | "PUT";
+                    path: string;
+                    body?: unknown;
+                };
+                filter?: string;
+                items: string;
+                wrap?: string;
+                cursor: string;
+                deliveryId: string[];
+                types: {
+                    type: string;
+                    since?: string;
+                }[];
+            };
+        };
+    }[]>;
+    internalApps: (o: string) => Promise<{
+        id: string;
+        organizationId: string;
+        definition: {
+            [key: string]: unknown;
+        };
+        problem: string | null;
+        createdBy: string;
+        createdAt: string;
+        updatedBy: string;
+        updatedAt: string;
+    }[]>;
+    internalApp: (o: string, a: string) => Promise<{
+        id: string;
+        organizationId: string;
+        definition: {
+            [key: string]: unknown;
+        };
+        problem: string | null;
+        createdBy: string;
+        createdAt: string;
+        updatedBy: string;
+        updatedAt: string;
+    } | null>;
+    saveInternalApp: (o: string, a: string, definition: Record<string, unknown>, by: string) => Promise<{
+        app: import("./schema.js").components["schemas"]["InternalApp"];
+        connector: import("./schema.js").components["schemas"]["Connector"];
+        created: boolean;
+        disconnected: boolean;
+        grantsRemoved: string[];
+    }>;
+    deleteInternalApp: (o: string, a: string, by: string) => Promise<void>;
+    draftInternalApp: (body: Body<"draftInternalApp">) => Promise<{
+        definition: {
+            [key: string]: unknown;
+        };
+        notes: string[];
+        problem: string | null;
+    }>;
     providers: () => Promise<{
         id: string;
         name: string;

package/lib/index.js

@@ -64,6 +64,16 @@ export function createClient(options) {
         },
         branding: () => call("GET", "/branding"),
         connectors: () => call("GET", "/connectors"),
+        /** The deployment's apps and the organization's own internal apps. */
+        orgConnectors: (o) => call("GET", `${org(o)}/connectors`),
+        internalApps: (o) => call("GET", `${org(o)}/internal-apps`),
+        internalApp: (o, a) => maybe(`${org(o)}/internal-apps/${seg(a)}`),
+        saveInternalApp: (o, a, definition, by) => call("PUT", `${org(o)}/internal-apps/${seg(a)}`, {
+            definition,
+            by,
+        }),
+        deleteInternalApp: (o, a, by) => call("DELETE", `${org(o)}/internal-apps/${seg(a)}`, { by }),
+        draftInternalApp: (body) => call("POST", "/internal-apps/draft", body),
         providers: () => call("GET", "/providers"),
         providerConnections: (o) => call("GET", `${org(o)}/providers`),
         connectProvider: (o, p, body) => call("PUT", provider(o, p), body),

package/lib/schema.d.ts

@@ -73,6 +73,76 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/orgs/{org}/connectors": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The apps the organization can use: the deployment's and its own internal apps */
+        get: operations["orgConnectors"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/orgs/{org}/internal-apps": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The organization's own apps, as saved */
+        get: operations["internalApps"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/orgs/{org}/internal-apps/{app}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One of the organization's own apps, as saved */
+        get: operations["internalApp"];
+        /** Adds or replaces one of the organization's own apps; a replace may cut or remove its connection and agents' access */
+        put: operations["saveInternalApp"];
+        post?: never;
+        /** Removes one of the organization's own apps, its connection and every agent's access to it */
+        delete: operations["deleteInternalApp"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal-apps/draft": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Drafts an internal app's definition from an OpenAPI 3.x spec (JSON) */
+        post: operations["draftInternalApp"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/providers": {
         parameters: {
             query?: never;
@@ -1828,6 +1898,36 @@ export interface components {
             name: string;
             detail: string | null;
         };
+        InternalApp: {
+            id: string;
+            organizationId: string;
+            /** @description A connector.json with an http, soap, odata or sql block, as written (docs/http-connector.md) */
+            definition: {
+                [key: string]: unknown;
+            };
+            problem: string | null;
+            createdBy: string;
+            /** @description ISO 8601, UTC */
+            createdAt: string;
+            updatedBy: string;
+            /** @description ISO 8601, UTC */
+            updatedAt: string;
+        };
+        InternalAppDraft: {
+            /** @description A connector.json with an http, soap, odata or sql block, as written (docs/http-connector.md) */
+            definition: {
+                [key: string]: unknown;
+            };
+            notes: string[];
+            problem: string | null;
+        };
+        InternalAppSaved: {
+            app: components["schemas"]["InternalApp"];
+            connector: components["schemas"]["Connector"];
+            created: boolean;
+            disconnected: boolean;
+            grantsRemoved: string[];
+        };
         Limits: {
             [key: string]: string[] | string | {
                 [key: string]: string;
@@ -2456,6 +2556,380 @@ export interface operations {
             };
         };
     };
+    orgConnectors: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                org: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Connector"][];
+                };
+            };
+            /** @description Refused */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    internalApps: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                org: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalApp"][];
+                };
+            };
+            /** @description Refused */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    internalApp: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                org: string;
+                app: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalApp"];
+                };
+            };
+            /** @description Refused */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    saveInternalApp: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                org: string;
+                app: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description A connector.json with an http, soap, odata or sql block, as written (docs/http-connector.md) */
+                    definition: {
+                        [key: string]: unknown;
+                    };
+                    by: string;
+                };
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalAppSaved"];
+                };
+            };
+            /** @description Refused */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    deleteInternalApp: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                org: string;
+                app: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    by: string;
+                };
+            };
+        };
+        responses: {
+            /** @description OK */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Refused */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    draftInternalApp: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    spec: {
+                        [key: string]: unknown;
+                    };
+                    id: string;
+                    operations?: string[];
+                    tags?: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalAppDraft"];
+                };
+            };
+            /** @description Refused */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Refused */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     providers: {
         parameters: {
             query?: never;

package/lib/steps.d.ts

@@ -358,11 +358,7 @@ export declare function newKeySetup(ticked: Connector[], providers: Provider[]):
             body?: {
                 [key: string]: unknown;
             };
-            ifEmpty
-            /** A step whose text fills in a value saved at another step waits until it is saved: its
-             *  words would show the raw {name} and its commands would not run. */
-            ? /** A step whose text fills in a value saved at another step waits until it is saved: its
-             *  words would show the raw {name} and its commands would not run. */: string;
+            ifEmpty?: string;
         } | {
             label: string;
             check: string;
@@ -946,11 +942,7 @@ export declare function newKeySetup(ticked: Connector[], providers: Provider[]):
             body?: {
                 [key: string]: unknown;
             };
-            ifEmpty
-            /** A step whose text fills in a value saved at another step waits until it is saved: its
-             *  words would show the raw {name} and its commands would not run. */
-            ? /** A step whose text fills in a value saved at another step waits until it is saved: its
-             *  words would show the raw {name} and its commands would not run. */: string;
+            ifEmpty?: string;
         } | {
             label: string;
             check: string;

package/lib/types.d.ts

@@ -47,6 +47,9 @@ export type EventTriggerInput = Body<"setEventTrigger">;
 export type EventRun = S["EventRun"];
 export type ClaudeKey = S["ClaudeKey"];
 export type ClaudeAgent = S["ClaudeAgent"];
+export type InternalApp = S["InternalApp"];
+export type InternalAppSaved = S["InternalAppSaved"];
+export type InternalAppDraft = S["InternalAppDraft"];
 export type Step = Connector["setup"][number];
 export type AgentStep = Provider["addAgent"][number];
 export type Setting = NonNullable<Step["settings"]>[number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbium/enterprise-agent-connect-client",
-  "version": "0.2.0",
+  "version": "0.2.1-dev.fd7a648",
   "description": "Typed client for the Agent Connect admin API (v1), and the pure logic admin pages share",
   "type": "module",
   "exports": {