@tai42/api-client 15.0.0 → 16.0.1

package/dist/schemas/capabilities.d.ts

@@ -0,0 +1,99 @@
+/** Caller capability projection and auth-capabilities schemas. */
+import { z } from 'zod';
+/** A concrete route the caller can reach, with the methods that pass its jq fence. */
+export declare const routeEntry: z.ZodObject<{
+    path: z.ZodString;
+    methods: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RouteEntry = z.infer<typeof routeEntry>;
+/**
+ * A dynamic route pattern the caller can reach — a mount/pattern surface not
+ * enumerable into concrete paths, projected only when its scope AND jq admit it.
+ */
+export declare const patternEntry: z.ZodObject<{
+    pattern: z.ZodString;
+    scope_id: z.ZodString;
+}, z.core.$strip>;
+export type PatternEntry = z.infer<typeof patternEntry>;
+/**
+ * A sub-MCP mount the caller can reach, with the tools it exposes and its
+ * transport. Shares the {@link subMcpMount} shape with the registry list, adding
+ * the `slug` the projection carries inline (the list keys mounts by slug instead).
+ */
+export declare const subMcpEntry: z.ZodObject<{
+    tools: z.ZodArray<z.ZodString>;
+    transport: z.ZodString;
+    slug: z.ZodString;
+}, z.core.$strip>;
+export type SubMcpEntry = z.infer<typeof subMcpEntry>;
+/**
+ * `GET /api/auth/me` — the caller's derived capability projection: the concrete
+ * (path, method) surface, dynamic patterns, sub-MCP mounts, tools, and agents it
+ * can reach RIGHT NOW (derived server-side, never stored). `admin` is the
+ * condition-free ownerless `"*"` discriminator (a TOTAL projection); a scoped
+ * session carries `admin: false` and a jq-exact `routes` list. `owner_user_id` is
+ * the key's owner claim, `null` for an ownerless key. The invariant is
+ * projection ⊆ gate: every projected surface is one the server would admit, so
+ * the UI can filter on it without ever advertising a door the gate denies.
+ */
+export declare const meProjection: z.ZodObject<{
+    user_id: z.ZodString;
+    owner_user_id: z.ZodNullable<z.ZodString>;
+    admin: z.ZodBoolean;
+    scopes: z.ZodArray<z.ZodString>;
+    routes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        methods: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    route_patterns: z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        scope_id: z.ZodString;
+    }, z.core.$strip>>;
+    sub_mcp: z.ZodArray<z.ZodObject<{
+        tools: z.ZodArray<z.ZodString>;
+        transport: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodString>;
+    agents: z.ZodArray<z.ZodString>;
+    mintable: z.ZodBoolean;
+}, z.core.$strip>;
+export type MeProjection = z.infer<typeof meProjection>;
+/**
+ * `POST /api/auth/claim-links` — a one-time claim link minted in the key-create
+ * flow. `claim_path` is a fragment-carrier path (`/login#claim=<token>`, never an
+ * absolute URL — the Studio composes the origin); `token` is the raw claim token
+ * returned exactly ONCE; `expires_at` is an ISO-8601 instant.
+ */
+export declare const claimLinkCreated: z.ZodObject<{
+    claim_path: z.ZodString;
+    token: z.ZodString;
+    expires_at: z.ZodString;
+}, z.core.$strip>;
+export type ClaimLinkCreated = z.infer<typeof claimLinkCreated>;
+/**
+ * `POST /api/auth/logout` — the single authed logout dispatcher's result.
+ * `revoked` is `true` when a live accounts session was revoked; a plain `sk-` key
+ * has nothing to revoke and answers `404` (a loud absent-session signal), never a
+ * `revoked: false` body. Non-strict, so a SUCCESSFUL logout never throws
+ * `ApiSchemaError` on an additive field.
+ */
+export declare const logoutResult: z.ZodObject<{
+    revoked: z.ZodBoolean;
+}, z.core.$strip>;
+export type LogoutResult = z.infer<typeof logoutResult>;
+/**
+ * `GET /api/auth/capabilities` — whether this deployment can MINT API keys
+ * locally. `mintable: false` means every configured identity provider is
+ * validator-only (keys are issued at an external issuer), so the key-creation
+ * UI disables up front instead of surfacing a raw mint failure. Non-strict.
+ */
+export declare const authCapabilities: z.ZodObject<{
+    mintable: z.ZodBoolean;
+    providers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        mintable: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AuthCapabilities = z.infer<typeof authCapabilities>;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/schemas/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/schemas/capabilities.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,sFAAsF;AACtF,eAAO,MAAM,UAAU;;;iBAGrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,YAAY;;;iBAGvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;iBAA2C,CAAC;AACpE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;iBAWvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;iBAI3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;iBAAqC,CAAC;AAC/D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;iBAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/capabilities.js

@@ -0,0 +1,74 @@
+/** Caller capability projection and auth-capabilities schemas. */
+import { z } from 'zod';
+import { subMcpMount } from './sub-mcp';
+/** A concrete route the caller can reach, with the methods that pass its jq fence. */
+export const routeEntry = z.object({
+    path: z.string(),
+    methods: z.array(z.string()),
+});
+/**
+ * A dynamic route pattern the caller can reach — a mount/pattern surface not
+ * enumerable into concrete paths, projected only when its scope AND jq admit it.
+ */
+export const patternEntry = z.object({
+    pattern: z.string(),
+    scope_id: z.string(),
+});
+/**
+ * A sub-MCP mount the caller can reach, with the tools it exposes and its
+ * transport. Shares the {@link subMcpMount} shape with the registry list, adding
+ * the `slug` the projection carries inline (the list keys mounts by slug instead).
+ */
+export const subMcpEntry = subMcpMount.extend({ slug: z.string() });
+/**
+ * `GET /api/auth/me` — the caller's derived capability projection: the concrete
+ * (path, method) surface, dynamic patterns, sub-MCP mounts, tools, and agents it
+ * can reach RIGHT NOW (derived server-side, never stored). `admin` is the
+ * condition-free ownerless `"*"` discriminator (a TOTAL projection); a scoped
+ * session carries `admin: false` and a jq-exact `routes` list. `owner_user_id` is
+ * the key's owner claim, `null` for an ownerless key. The invariant is
+ * projection ⊆ gate: every projected surface is one the server would admit, so
+ * the UI can filter on it without ever advertising a door the gate denies.
+ */
+export const meProjection = z.object({
+    user_id: z.string(),
+    owner_user_id: z.string().nullable(),
+    admin: z.boolean(),
+    scopes: z.array(z.string()),
+    routes: z.array(routeEntry),
+    route_patterns: z.array(patternEntry),
+    sub_mcp: z.array(subMcpEntry),
+    tools: z.array(z.string()),
+    agents: z.array(z.string()),
+    mintable: z.boolean(),
+});
+/**
+ * `POST /api/auth/claim-links` — a one-time claim link minted in the key-create
+ * flow. `claim_path` is a fragment-carrier path (`/login#claim=<token>`, never an
+ * absolute URL — the Studio composes the origin); `token` is the raw claim token
+ * returned exactly ONCE; `expires_at` is an ISO-8601 instant.
+ */
+export const claimLinkCreated = z.object({
+    claim_path: z.string(),
+    token: z.string(),
+    expires_at: z.string(),
+});
+/**
+ * `POST /api/auth/logout` — the single authed logout dispatcher's result.
+ * `revoked` is `true` when a live accounts session was revoked; a plain `sk-` key
+ * has nothing to revoke and answers `404` (a loud absent-session signal), never a
+ * `revoked: false` body. Non-strict, so a SUCCESSFUL logout never throws
+ * `ApiSchemaError` on an additive field.
+ */
+export const logoutResult = z.object({ revoked: z.boolean() });
+/**
+ * `GET /api/auth/capabilities` — whether this deployment can MINT API keys
+ * locally. `mintable: false` means every configured identity provider is
+ * validator-only (keys are issued at an external issuer), so the key-creation
+ * UI disables up front instead of surfacing a raw mint failure. Non-strict.
+ */
+export const authCapabilities = z.object({
+    mintable: z.boolean(),
+    providers: z.array(z.object({ name: z.string(), mintable: z.boolean() })),
+});
+//# sourceMappingURL=capabilities.js.map

package/dist/schemas/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../src/schemas/capabilities.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,sFAAsF;AACtF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;CACrB,CAAC,CAAC;AAGH;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAGpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACpC,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAClB,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC;IAC3B,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC;IACrC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1B,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3B,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;CACtB,CAAC,CAAC;AAGH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;CACvB,CAAC,CAAC;AAGH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AAG/D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;IACrB,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;CAC1E,CAAC,CAAC"}

package/dist/schemas/channels.d.ts

@@ -0,0 +1,7 @@
+/** Installed channel-plugin catalog response schema. */
+import { z } from 'zod';
+export declare const channels: z.ZodObject<{
+    channels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Channels = z.infer<typeof channels>;
+//# sourceMappingURL=channels.d.ts.map

package/dist/schemas/channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../src/schemas/channels.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,QAAQ;;iBAEnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/dist/schemas/channels.js

@@ -0,0 +1,9 @@
+/** Installed channel-plugin catalog response schema. */
+import { z } from 'zod';
+// The installed channel-plugin catalog: names registered via the manifest's
+// channel modules. A deployment with none bound answers questions only in this
+// inbox (the Studio default).
+export const channels = z.object({
+    channels: z.array(z.string()),
+});
+//# sourceMappingURL=channels.js.map

package/dist/schemas/channels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channels.js","sourceRoot":"","sources":["../../src/schemas/channels.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,4EAA4E;AAC5E,+EAA+E;AAC/E,8BAA8B;AAE9B,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CAC9B,CAAC,CAAC"}

package/dist/schemas/config.d.ts

@@ -0,0 +1,17 @@
+/** Environment-config and config-mode response schemas. */
+import { z } from 'zod';
+export declare const envConfig: z.ZodObject<{
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+    secret_keys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * `GET /api/config/mode` — the active config backend mode (`file` / `k8s`). The
+ * skeleton emits only `config_mode`; `read_only` is a UI-side gate, tolerated-absent
+ * and defaulting to `false` (writable) so a normal response never drifts, while a
+ * genuinely read-only deployment can opt in by emitting `read_only: true`.
+ */
+export declare const configMode: z.ZodObject<{
+    config_mode: z.ZodString;
+    read_only: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+//# sourceMappingURL=config.d.ts.map

package/dist/schemas/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/schemas/config.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;iBAGpB,CAAC;AACH;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;iBAGrB,CAAC"}

package/dist/schemas/config.js

@@ -0,0 +1,17 @@
+/** Environment-config and config-mode response schemas. */
+import { z } from 'zod';
+export const envConfig = z.object({
+    env: z.record(z.string(), z.string()),
+    secret_keys: z.array(z.string()),
+});
+/**
+ * `GET /api/config/mode` — the active config backend mode (`file` / `k8s`). The
+ * skeleton emits only `config_mode`; `read_only` is a UI-side gate, tolerated-absent
+ * and defaulting to `false` (writable) so a normal response never drifts, while a
+ * genuinely read-only deployment can opt in by emitting `read_only: true`.
+ */
+export const configMode = z.object({
+    config_mode: z.string(),
+    read_only: z.boolean().default(false),
+});
+//# sourceMappingURL=config.js.map

package/dist/schemas/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/schemas/config.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IACrC,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CACjC,CAAC,CAAC;AACH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;CACtC,CAAC,CAAC"}

package/dist/schemas/connectors.d.ts

@@ -0,0 +1,383 @@
+/** Connector provider catalog and connection lifecycle schemas. */
+import { z } from 'zod';
+export declare const subServiceView: z.ZodObject<{
+    id: z.ZodString;
+    display_name: z.ZodString;
+    description: z.ZodString;
+    scopes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const configFieldView: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    target: z.ZodEnum<{
+        env: "env";
+        header: "header";
+    }>;
+    required: z.ZodBoolean;
+    secret: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const providerView: z.ZodObject<{
+    id: z.ZodString;
+    display_name: z.ZodString;
+    description: z.ZodString;
+    icon_url: z.ZodURL;
+    kind: z.ZodEnum<{
+        none: "none";
+        oauth: "oauth";
+    }>;
+    origin: z.ZodEnum<{
+        system: "system";
+        community: "community";
+    }>;
+    category: z.ZodString;
+    sub_services: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        display_name: z.ZodString;
+        description: z.ZodString;
+        scopes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    config_fields: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        target: z.ZodEnum<{
+            env: "env";
+            header: "header";
+        }>;
+        required: z.ZodBoolean;
+        secret: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProviderView = z.infer<typeof providerView>;
+/**
+ * One `connector_category` grouping row served alongside the catalog: the UI's
+ * label and sort key for the providers it groups, so the list can group, order,
+ * and label providers by category without a second read.
+ */
+export declare const connectorCategoryView: z.ZodObject<{
+    id: z.ZodString;
+    display_name: z.ZodString;
+    sort_order: z.ZodNumber;
+}, z.core.$strip>;
+export type ConnectorCategoryView = z.infer<typeof connectorCategoryView>;
+/**
+ * `GET /api/connectors/providers` — the provider catalog: the providers plus the
+ * category groupings the UI arranges them under. Reshaped from a bare provider
+ * array so the category label/order surface rides the same read.
+ */
+export declare const providers: z.ZodObject<{
+    providers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        display_name: z.ZodString;
+        description: z.ZodString;
+        icon_url: z.ZodURL;
+        kind: z.ZodEnum<{
+            none: "none";
+            oauth: "oauth";
+        }>;
+        origin: z.ZodEnum<{
+            system: "system";
+            community: "community";
+        }>;
+        category: z.ZodString;
+        sub_services: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            display_name: z.ZodString;
+            description: z.ZodString;
+            scopes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        config_fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            target: z.ZodEnum<{
+                env: "env";
+                header: "header";
+            }>;
+            required: z.ZodBoolean;
+            secret: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        display_name: z.ZodString;
+        sort_order: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProviderCatalogResponse = z.infer<typeof providers>;
+export declare const connectionView: z.ZodObject<{
+    connection_id: z.ZodString;
+    provider_id: z.ZodString;
+    alias: z.ZodString;
+    kind: z.ZodEnum<{
+        none: "none";
+        oauth: "oauth";
+    }>;
+    account_identity: z.ZodNullable<z.ZodString>;
+    enabled_sub_services: z.ZodArray<z.ZodString>;
+    granted_scopes: z.ZodArray<z.ZodString>;
+    unreachable_sub_services: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    auth_health_state: z.ZodEnum<{
+        healthy: "healthy";
+        reconnect_required: "reconnect_required";
+        refresh_failing: "refresh_failing";
+    }>;
+    created_at: z.ZodString;
+}, z.core.$strip>;
+export type ConnectionView = z.infer<typeof connectionView>;
+export declare const connectionsList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        connection_id: z.ZodString;
+        provider_id: z.ZodString;
+        alias: z.ZodString;
+        kind: z.ZodEnum<{
+            none: "none";
+            oauth: "oauth";
+        }>;
+        account_identity: z.ZodNullable<z.ZodString>;
+        enabled_sub_services: z.ZodArray<z.ZodString>;
+        granted_scopes: z.ZodArray<z.ZodString>;
+        unreachable_sub_services: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        auth_health_state: z.ZodEnum<{
+            healthy: "healthy";
+            reconnect_required: "reconnect_required";
+            refresh_failing: "refresh_failing";
+        }>;
+        created_at: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    unhealthy: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const startConnectResult: z.ZodUnion<readonly [z.ZodObject<{
+    flow_id: z.ZodString;
+    authorize_url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    connection_id: z.ZodString;
+    added_manifest_entries: z.ZodArray<z.ZodString>;
+    fanout: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"local-only">;
+        note: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"fleet">;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"unreachable">;
+    }, z.core.$strip>], "mode">>;
+}, z.core.$strip>]>;
+export declare const reconnectResult: z.ZodObject<{
+    flow_id: z.ZodString;
+    authorize_url: z.ZodString;
+}, z.core.$strip>;
+export declare const disconnectResult: z.ZodObject<{
+    connection_id: z.ZodString;
+    upstream_revoke_outcome: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        skipped: "skipped";
+    }>;
+    upstream_revoke_status: z.ZodNullable<z.ZodNumber>;
+    removed_manifest_entries: z.ZodArray<z.ZodString>;
+    fanout: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"local-only">;
+        note: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"fleet">;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"unreachable">;
+    }, z.core.$strip>], "mode">>;
+}, z.core.$strip>;
+export declare const patchSubServicesResult: z.ZodObject<{
+    connection_id: z.ZodString;
+    enabled_sub_services: z.ZodArray<z.ZodString>;
+    consent_required: z.ZodBoolean;
+    flow_id: z.ZodNullable<z.ZodString>;
+    authorize_url: z.ZodNullable<z.ZodString>;
+    added_manifest_entries: z.ZodArray<z.ZodString>;
+    removed_manifest_entries: z.ZodArray<z.ZodString>;
+    fanout: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"local-only">;
+        note: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"fleet">;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"unreachable">;
+    }, z.core.$strip>], "mode">>;
+}, z.core.$strip>;
+export declare const oauthCompleteResult: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"success">;
+    connection_id: z.ZodString;
+    return_url: z.ZodString;
+    fanout: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"local-only">;
+        note: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"fleet">;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodString;
+        reachable: z.ZodBoolean;
+        local_only: z.ZodBoolean;
+        results: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                resyncing: "resyncing";
+                recycling: "recycling";
+                stale: "stale";
+                applied: "applied";
+                missing: "missing";
+                departed: "departed";
+                timed_out: "timed_out";
+            }>;
+            payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            error: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        mode: z.ZodLiteral<"unreachable">;
+    }, z.core.$strip>], "mode">>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"cancelled">;
+    message: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type OAuthCompleteResult = z.infer<typeof oauthCompleteResult>;
+//# sourceMappingURL=connectors.d.ts.map

package/dist/schemas/connectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectors.d.ts","sourceRoot":"","sources":["../../src/schemas/connectors.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;iBAM1B,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAavB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGpB,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;iBAiBzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;iBAO1B,CAAC;AAOH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAO7B,CAAC;AAIH,eAAO,MAAM,eAAe;;;iBAA+D,CAAC;AAE5F,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM3B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUjC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAW9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}