@collective-intelligence/extensions-sdk 0.2.1 → 0.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (35) hide show
  1. package/README.md +332 -368
  2. package/dist/access/application-gate.d.ts +36 -0
  3. package/dist/access/audience.d.ts +43 -0
  4. package/dist/access/capabilities.d.ts +105 -0
  5. package/dist/access/conditions.d.ts +136 -0
  6. package/dist/access/core-catalog.d.ts +221 -0
  7. package/dist/access/declarations.d.ts +169 -0
  8. package/dist/access/document-policy.d.ts +31 -0
  9. package/dist/access/index.d.ts +62 -0
  10. package/dist/access/knowledge-policy.d.ts +87 -0
  11. package/dist/access/manifest.d.ts +161 -0
  12. package/dist/access/readers.d.ts +114 -0
  13. package/dist/access/requirement.d.ts +61 -0
  14. package/dist/components/agents.d.ts +12 -30
  15. package/dist/components/authoring-core.d.ts +3 -1
  16. package/dist/components/base.d.ts +1 -1
  17. package/dist/components/connector-instances.d.ts +0 -3
  18. package/dist/components/declaration.d.ts +3 -2
  19. package/dist/components/document-collections.d.ts +3 -32
  20. package/dist/components/external-application.d.ts +18 -90
  21. package/dist/components/knowledge.d.ts +1 -164
  22. package/dist/components/metadata-authoring.d.ts +24 -21
  23. package/dist/components/organization-settings.d.ts +7 -2
  24. package/dist/components/service-principal.d.ts +9 -4
  25. package/dist/components/studio.d.ts +22 -44
  26. package/dist/components/tools.d.ts +15 -8
  27. package/dist/components/workflows.d.ts +7 -0
  28. package/dist/index.d.ts +13 -11
  29. package/dist/index.js +2 -2
  30. package/dist/package/primitive-readers.d.ts +111 -24
  31. package/dist/package/readers.d.ts +2 -0
  32. package/dist/package/variables.d.ts +1 -2
  33. package/docs/effect.md +2 -2
  34. package/package.json +2 -2
  35. package/dist/package/policy-readers.d.ts +0 -23
@@ -0,0 +1,36 @@
1
+ /**
2
+ * The app gate (ARC-001): the root Switch of an external application's
3
+ * capability tree, whose code is the application FQN. A member, a guest or
4
+ * a tenant user enters the app only when one of its grants holds the gate
5
+ * or a node below it (AC-113).
6
+ */
7
+ import type { DeclarationReference, DeclaredComponent } from "../components/authoring-core.js";
8
+ import type { ExternalApplicationDeclaration } from "../components/external-application.js";
9
+ import type { AccessCapabilityHandle, AccessCapabilityNodeDeclaration, AccessCapabilityNodeInput, AccessCapabilityTree } from "./capabilities.js";
10
+ /** Keys the typed capability tree of a declared external application. */
11
+ export declare const accessGateTree: unique symbol;
12
+ /** The authored capabilities below an app gate. */
13
+ export type AccessApplicationCapabilities = Readonly<Record<string, AccessCapabilityNodeInput>>;
14
+ /** The handle of an app gate and the handles of the capabilities below it. */
15
+ export type AccessGate<Capabilities extends AccessApplicationCapabilities = Readonly<Record<never, never>>> = AccessCapabilityTree<Readonly<{
16
+ children: Capabilities;
17
+ kind: "switch";
18
+ }>, "switch">;
19
+ /** A declared external application and the typed handles of its capability tree. */
20
+ export type ExternalApplicationHandle<Capabilities extends AccessApplicationCapabilities = Readonly<Record<never, never>>> = DeclaredComponent<ExternalApplicationDeclaration> & Readonly<{
21
+ [accessGateTree]: AccessGate<Capabilities>;
22
+ }>;
23
+ /** The handle tree of an application's gate and of its declared capabilities. */
24
+ export declare const applicationGate: (fqn: string, capabilities?: Readonly<Record<string, AccessCapabilityNodeDeclaration>>) => AccessCapabilityHandle;
25
+ type GateOf<Application> = Application extends Readonly<{
26
+ [accessGateTree]: infer Gate;
27
+ }> ? Gate : AccessCapabilityHandle<"switch">;
28
+ /**
29
+ * The app gate of an external application, a Switch: `allow(accessGate(app))`
30
+ * lets the holders of a profile enter the app, and `accessGate(app).charts`
31
+ * names a capability that the app declares. An FQN names the gate of an app
32
+ * that another package declares; a handle of a stored manifest names the
33
+ * tree that the manifest declares.
34
+ */
35
+ export declare const accessGate: <const Application extends DeclarationReference<"externalApplication">>(application: Application) => GateOf<Application>;
36
+ export {};
@@ -0,0 +1,43 @@
1
+ import type { DeclarationReference } from "../components/authoring-core.js";
2
+ import type { ReadValue } from "../package/readers.js";
3
+ import type { AccessGroupCoverage, AccessGroupReference } from "./conditions.js";
4
+ import type { AccessProfileReference } from "./declarations.js";
5
+ /** A Group of an audience: a reference, or a reference with its coverage. */
6
+ export type AccessAudienceGroup = AccessGroupReference | Readonly<{
7
+ coverage?: AccessGroupCoverage;
8
+ group: AccessGroupReference;
9
+ }>;
10
+ /**
11
+ * To whom a package offers a named thing: its Resource Audience (ARC-008).
12
+ * Entries only allow; an absent or empty audience offers the thing to nobody.
13
+ * Packages never name users; admins add user entries in the Dashboard.
14
+ */
15
+ export type AccessAudience = Readonly<{
16
+ /** Every member of the Organization. */
17
+ organization?: boolean;
18
+ /** A Group without coverage reaches its subgroups (`inherited`). */
19
+ groups?: readonly AccessAudienceGroup[];
20
+ /** The holders of these Access Profiles. */
21
+ profiles?: readonly AccessProfileReference[];
22
+ /** The users of these apps. */
23
+ applications?: readonly DeclarationReference<"externalApplication">[];
24
+ /** The anonymous visitors of these apps. */
25
+ anonymous?: readonly DeclarationReference<"externalApplication">[];
26
+ }>;
27
+ /** An `AccessAudience` in a manifest: every reference is an FQN. */
28
+ export type AccessAudienceDeclaration = Readonly<{
29
+ organization?: true;
30
+ groups?: readonly Readonly<{
31
+ coverage: AccessGroupCoverage;
32
+ fqn: string;
33
+ }>[];
34
+ profiles?: readonly string[];
35
+ applications?: readonly string[];
36
+ anonymous?: readonly string[];
37
+ }>;
38
+ /** The rule a manifest audience breaks, if any: each list names an FQN once. */
39
+ export declare const accessAudienceViolation: (audience: AccessAudienceDeclaration) => string | undefined;
40
+ /** The manifest form of an audience (AC-143); refuses keys it does not have. */
41
+ export declare const accessAudienceDeclaration: (audience: AccessAudience, location: string) => AccessAudienceDeclaration;
42
+ /** Reads a manifest audience: the five keys only, each entry once. */
43
+ export declare const readAccessAudience: ReadValue<AccessAudienceDeclaration>;
@@ -0,0 +1,105 @@
1
+ /**
2
+ * The Capability Catalog vocabulary: node kinds, typed handles, `allow` and the
3
+ * flat node list that hosts turn into catalog rows (ARC-001).
4
+ */
5
+ /** Switch: off or on. Read/Manage: off, read or manage; manage includes read. */
6
+ export type AccessCapabilityKind = "readManage" | "switch";
7
+ /** The mode of a granted or required capability: `on` for a Switch. */
8
+ export type AccessCapabilityMode = "manage" | "on" | "read";
9
+ /** The mode argument of a Read/Manage node. */
10
+ export type AccessReadManageMode = "manage" | "read";
11
+ export type AccessCapabilityArea = "admin" | "app" | "dashboard" | "data" | "mcp" | "package" | "platform" | "studio" | "tenant";
12
+ /**
13
+ * The identity of one catalog node. `code` is unique per Organization;
14
+ * authorization uses catalog ids and slots and never parses it.
15
+ */
16
+ export type AccessCapabilityIdentity = Readonly<{
17
+ /** The FQN of the declaring external application, for area `app`. */
18
+ application?: string;
19
+ area: AccessCapabilityArea;
20
+ code: string;
21
+ /** False for code-only nodes that are never stored or granted (`tenant`). */
22
+ grantable: boolean;
23
+ kind: AccessCapabilityKind;
24
+ /** The FQN of the declaring `declareAccessCapabilities`, for area `package`. */
25
+ package?: string;
26
+ path: readonly string[];
27
+ }>;
28
+ /** Keys the identity of a handle; a symbol never collides with a child key. */
29
+ export declare const accessCapabilityNode: unique symbol;
30
+ /** A typed reference to one declared catalog node; the kind decides whether a mode is required. */
31
+ export type AccessCapabilityHandle<Kind extends AccessCapabilityKind = AccessCapabilityKind> = Readonly<{
32
+ [accessCapabilityNode]: AccessCapabilityIdentity & Readonly<{
33
+ kind: Kind;
34
+ }>;
35
+ }>;
36
+ /**
37
+ * A capability by handle, or by the code of a node that another package
38
+ * declares; the installer resolves a code and refuses one that does not resolve.
39
+ */
40
+ export type AccessCapabilityReference = AccessCapabilityHandle | string;
41
+ /** One capability entry of a profile or of Max Privileges: a reference, never an inline node. */
42
+ export type AccessCapabilityGrant = Readonly<{
43
+ code: string;
44
+ mode: AccessCapabilityMode;
45
+ }>;
46
+ /** An authored catalog node: a child without `kind` takes the kind of its parent. */
47
+ export type AccessCapabilityNodeInput = Readonly<{
48
+ children?: Readonly<Record<string, AccessCapabilityNodeInput>>;
49
+ kind?: AccessCapabilityKind;
50
+ }>;
51
+ type NodeKind<Input, Inherited extends AccessCapabilityKind> = Input extends Readonly<{
52
+ kind: infer Kind extends AccessCapabilityKind;
53
+ }> ? Kind : Inherited;
54
+ type ChildHandles<Input, Kind extends AccessCapabilityKind> = Input extends Readonly<{
55
+ children: infer Children;
56
+ }> ? {
57
+ readonly [Key in keyof Children]: AccessCapabilityTree<Children[Key], Kind>;
58
+ } : unknown;
59
+ /** The handle of a node and the handles of its children, typed from the authored tree. */
60
+ export type AccessCapabilityTree<Input, Inherited extends AccessCapabilityKind> = AccessCapabilityHandle<NodeKind<Input, Inherited>> & ChildHandles<Input, NodeKind<Input, Inherited>>;
61
+ /** A node as one catalog row: parents come before their children. */
62
+ export type AccessCapabilityCatalogNode = Readonly<{
63
+ application?: string;
64
+ area: AccessCapabilityArea;
65
+ code: string;
66
+ grantable: boolean;
67
+ key: string;
68
+ kind: AccessCapabilityKind;
69
+ package?: string;
70
+ /** The code of the parent node; absent on a root. */
71
+ parent?: string;
72
+ }>;
73
+ /** A built handle tree: its string keys are the child handles. */
74
+ interface CapabilityTreeValue extends AccessCapabilityHandle {
75
+ readonly [key: string]: CapabilityTreeValue;
76
+ }
77
+ /** The serialized child nodes; every node carries its resolved kind. */
78
+ export type AccessCapabilityNodeDeclaration = Readonly<{
79
+ children?: Readonly<Record<string, AccessCapabilityNodeDeclaration>>;
80
+ kind: AccessCapabilityKind;
81
+ }>;
82
+ /**
83
+ * Normalizes an authored node tree: checks each key and kind and writes the
84
+ * inherited kind on every node. `reserved` keys would hide handle members.
85
+ */
86
+ export declare const capabilityNodeDeclarations: (nodes: Readonly<Record<string, AccessCapabilityNodeInput>>, parentKind: AccessCapabilityKind, location: string, reserved?: ReadonlySet<string>) => Readonly<Record<string, AccessCapabilityNodeDeclaration>>;
87
+ /** Builds the frozen handle tree of one node and its declared children. */
88
+ export declare const capabilityTree: (identity: AccessCapabilityIdentity, children?: Readonly<Record<string, AccessCapabilityNodeDeclaration>>) => CapabilityTreeValue;
89
+ /** The code and mode of a reference; the kind decides whether a mode is given. */
90
+ export declare const capabilityLevel: (capability: AccessCapabilityReference, mode: AccessReadManageMode | undefined, location: string) => AccessCapabilityGrant;
91
+ /** The rest parameter of `allow` and `requires`: the kind decides the mode. */
92
+ export type AccessModeArguments<Reference> = Reference extends AccessCapabilityHandle<"switch"> ? [] : Reference extends AccessCapabilityHandle<"readManage"> ? [mode: AccessReadManageMode] : [mode?: AccessReadManageMode];
93
+ /**
94
+ * Grants a capability in a profile or in Max Privileges: `allow(core.studio)`,
95
+ * `allow(core.admin.users, "manage")` or a code that another package declares.
96
+ */
97
+ export declare const allow: <const Reference extends AccessCapabilityReference>(capability: Reference, ...[mode]: AccessModeArguments<Reference>) => AccessCapabilityGrant;
98
+ /** The code of a reference, as manifests store it. */
99
+ export declare const capabilityCode: (capability: AccessCapabilityReference) => string;
100
+ /**
101
+ * Every node of a catalog or of a declared package tree as one catalog row,
102
+ * parents first. Hosts turn `coreCapabilities` into rows with it.
103
+ */
104
+ export declare const capabilityCatalogNodes: (source: AccessCapabilityHandle | Readonly<Record<string, AccessCapabilityHandle>>) => readonly AccessCapabilityCatalogNode[];
105
+ export {};
@@ -0,0 +1,136 @@
1
+ import type { DeclarationHandle, DeclarationReference, DeclaredComponent } from "../components/authoring-core.js";
2
+ import type { JsonPrimitive, JsonValue } from "../foundation/json.js";
3
+ import type { AccessKnowledgeDataConditionDeclaration } from "./manifest.js";
4
+ export type AccessGroupCoverage = "direct" | "inherited";
5
+ /** A field of the record under evaluation. */
6
+ export type AccessResourceOperand = Readonly<{
7
+ resource: string;
8
+ }>;
9
+ /** A dotted path into the caller: `subject("userId")`. */
10
+ export type AccessSubjectOperand = Readonly<{
11
+ subject: string;
12
+ }>;
13
+ /** The Axis Value of the Tuple under evaluation, with its subtree. */
14
+ export type AccessGrantAxisOperand = Readonly<{
15
+ grantAxis: string;
16
+ }>;
17
+ export type AccessConditionLiteral = Readonly<{
18
+ value: JsonValue;
19
+ }>;
20
+ export type AccessConditionOperand = AccessConditionLiteral | AccessGrantAxisOperand | AccessResourceOperand | AccessSubjectOperand;
21
+ /** An authored operand: a reference or a JSON literal. */
22
+ export type AccessConditionOperandInput = AccessGrantAxisOperand | AccessResourceOperand | AccessSubjectOperand | JsonPrimitive | readonly JsonPrimitive[];
23
+ export type AccessConditionComparison = readonly [
24
+ AccessConditionOperand,
25
+ AccessConditionOperand
26
+ ];
27
+ /** A serializable row predicate. */
28
+ export type AccessCondition = Readonly<{
29
+ and: readonly AccessCondition[];
30
+ }> | Readonly<{
31
+ condition: string;
32
+ }> | Readonly<{
33
+ contains: AccessConditionComparison;
34
+ }> | Readonly<{
35
+ eq: AccessConditionComparison;
36
+ }> | Readonly<{
37
+ exists: AccessConditionOperand;
38
+ }> | Readonly<{
39
+ gt: AccessConditionComparison;
40
+ }> | Readonly<{
41
+ gte: AccessConditionComparison;
42
+ }> | Readonly<{
43
+ inGroup: Readonly<{
44
+ coverage: AccessGroupCoverage;
45
+ field: string;
46
+ group: string;
47
+ }>;
48
+ }> | Readonly<{
49
+ inMyGroups: Readonly<{
50
+ coverage: AccessGroupCoverage;
51
+ field: string;
52
+ }>;
53
+ }> | Readonly<{
54
+ includesMe: string;
55
+ }> | Readonly<{
56
+ isIn: AccessConditionComparison;
57
+ }> | Readonly<{
58
+ isMe: string;
59
+ }> | Readonly<{
60
+ isNull: AccessConditionOperand;
61
+ }> | Readonly<{
62
+ lt: AccessConditionComparison;
63
+ }> | Readonly<{
64
+ lte: AccessConditionComparison;
65
+ }> | Readonly<{
66
+ neq: AccessConditionComparison;
67
+ }> | Readonly<{
68
+ not: AccessCondition;
69
+ }> | Readonly<{
70
+ or: readonly AccessCondition[];
71
+ }> | Readonly<{
72
+ overlaps: AccessConditionComparison;
73
+ }> | Readonly<{
74
+ startsWith: AccessConditionComparison;
75
+ }> | Readonly<{
76
+ via: Readonly<{
77
+ condition: AccessCondition;
78
+ resource: string;
79
+ }>;
80
+ }>;
81
+ /** The handle of a declared Knowledge Data Condition; usable wherever a condition is. */
82
+ export type AccessKnowledgeDataConditionHandle = DeclaredComponent<AccessKnowledgeDataConditionDeclaration>;
83
+ /** An authored condition: an expression or a declared condition. */
84
+ export type AccessConditionInput = AccessCondition | AccessKnowledgeDataConditionHandle;
85
+ /** A Grant Axis by handle or by FQN. */
86
+ export type AccessGrantAxisReference = DeclarationReference<"accessGrantAxis">;
87
+ /** A Group by handle or by `{ fqn }`, such as `builtinGroups.organization`. */
88
+ export type AccessGroupReference = DeclarationHandle<"organizationGroup"> | Readonly<{
89
+ fqn: string;
90
+ }>;
91
+ /** The expression form of an authored condition: a declared condition becomes its FQN. */
92
+ export declare const conditionExpression: (input: AccessConditionInput) => AccessCondition;
93
+ /** The FQN of a Group reference. */
94
+ export declare const groupFqn: (group: AccessGroupReference) => string;
95
+ /** A field of the record under evaluation. */
96
+ export declare const resource: (key: string) => AccessResourceOperand;
97
+ /** A dotted path into the caller, such as `subject("userId")`. */
98
+ export declare const subject: (path: string) => AccessSubjectOperand;
99
+ /** The Axis Value of the Tuple under evaluation; refused under `not`. */
100
+ export declare const grantAxis: (axis: AccessGrantAxisReference) => AccessGrantAxisOperand;
101
+ export declare const and: (...inputs: readonly AccessConditionInput[]) => AccessCondition;
102
+ export declare const or: (...inputs: readonly AccessConditionInput[]) => AccessCondition;
103
+ /**
104
+ * Whether a condition, or a declared condition handle it is, reads a Tuple's
105
+ * Axis Value. A condition named only by FQN is checked when the host resolves it.
106
+ */
107
+ export declare const readsGrantAxis: (input: AccessConditionInput) => boolean;
108
+ /** Negates a condition; a condition that reads `grantAxis` fails the build under `not` (AC-067). */
109
+ export declare const not: (input: AccessConditionInput) => AccessCondition;
110
+ export declare const eq: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
111
+ export declare const neq: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
112
+ export declare const lt: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
113
+ export declare const lte: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
114
+ export declare const gt: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
115
+ export declare const gte: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
116
+ /** The value, or any value of a multi-valued field, is in the list (`in` is reserved). */
117
+ export declare const isIn: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
118
+ export declare const overlaps: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
119
+ export declare const contains: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
120
+ export declare const startsWith: (left: AccessConditionOperandInput, right: AccessConditionOperandInput) => AccessCondition;
121
+ export declare const exists: (reference: AccessResourceOperand | AccessSubjectOperand) => AccessCondition;
122
+ export declare const isNull: (reference: AccessResourceOperand | AccessSubjectOperand) => AccessCondition;
123
+ /** The related record that the field points at satisfies the condition. */
124
+ export declare const via: (pointer: AccessResourceOperand, condition: AccessConditionInput) => AccessCondition;
125
+ /** The user field holds the caller. */
126
+ export declare const isMe: (field: string) => AccessCondition;
127
+ /** The multiple user field includes the caller. */
128
+ export declare const includesMe: (field: string) => AccessCondition;
129
+ /** A user of the user field is a member of the Group. */
130
+ export declare const inGroup: (field: string, group: AccessGroupReference, options: Readonly<{
131
+ coverage: AccessGroupCoverage;
132
+ }>) => AccessCondition;
133
+ /** A user of the user field shares a Group of the caller. */
134
+ export declare const inMyGroups: (field: string, options: Readonly<{
135
+ coverage: AccessGroupCoverage;
136
+ }>) => AccessCondition;
@@ -0,0 +1,221 @@
1
+ import type { AccessCapabilityKind, AccessCapabilityNodeInput, AccessCapabilityTree } from "./capabilities.js";
2
+ import type { AccessCapabilityRequirement } from "./requirement.js";
3
+ type CoreRootInput = AccessCapabilityNodeInput & Readonly<{
4
+ grantable?: false;
5
+ kind: AccessCapabilityKind;
6
+ }>;
7
+ type CoreCatalog<Input extends Readonly<Record<string, CoreRootInput>>> = {
8
+ readonly [Area in keyof Input]: AccessCapabilityTree<Input[Area], Input[Area]["kind"]>;
9
+ };
10
+ /**
11
+ * The core Capability Catalog: the source of the core rows of every
12
+ * Organization, imported by the backend, the Dashboard and Studio (ARC-001).
13
+ */
14
+ export declare const coreCapabilities: CoreCatalog<{
15
+ readonly dashboard: {
16
+ readonly kind: "switch";
17
+ readonly children: {
18
+ home: {};
19
+ ai: {
20
+ children: {
21
+ skills: {};
22
+ reports: {};
23
+ tools: {};
24
+ agents: {};
25
+ approvals: {};
26
+ automations: {};
27
+ settings: {};
28
+ };
29
+ };
30
+ knowledge: {
31
+ children: {
32
+ schemas: {};
33
+ connectors: {};
34
+ data: {};
35
+ setup: {};
36
+ settings: {};
37
+ };
38
+ };
39
+ documents: {
40
+ children: {
41
+ collections: {};
42
+ setup: {};
43
+ };
44
+ };
45
+ datasets: {
46
+ children: {
47
+ explore: {};
48
+ catalog: {};
49
+ setup: {};
50
+ };
51
+ };
52
+ apps: {
53
+ children: {
54
+ studio: {};
55
+ external: {};
56
+ mcp: {};
57
+ setup: {};
58
+ };
59
+ };
60
+ monitoring: {
61
+ children: {
62
+ activities: {};
63
+ runHistory: {};
64
+ feedbacks: {};
65
+ mappings: {};
66
+ notifications: {};
67
+ events: {};
68
+ usage: {};
69
+ budgets: {};
70
+ };
71
+ };
72
+ organization: {
73
+ children: {
74
+ accounts: {};
75
+ identity: {};
76
+ general: {};
77
+ developers: {};
78
+ notifications: {};
79
+ extensions: {};
80
+ transfer: {};
81
+ onboarding: {};
82
+ };
83
+ };
84
+ };
85
+ };
86
+ readonly studio: {
87
+ readonly kind: "switch";
88
+ readonly children: {
89
+ notifications: {};
90
+ settings: {
91
+ children: {
92
+ memories: {};
93
+ notifications: {};
94
+ transcription: {};
95
+ permissions: {};
96
+ };
97
+ };
98
+ };
99
+ };
100
+ readonly mcp: {
101
+ readonly kind: "switch";
102
+ };
103
+ readonly admin: {
104
+ readonly kind: "readManage";
105
+ readonly children: {
106
+ readonly organization: {};
107
+ readonly users: {};
108
+ readonly groups: {};
109
+ readonly servicePrincipals: {};
110
+ readonly guests: {};
111
+ readonly profiles: {};
112
+ readonly grants: {};
113
+ readonly apiKeys: {};
114
+ readonly connections: {};
115
+ readonly packages: {};
116
+ readonly externalApps: {};
117
+ readonly studioApps: {};
118
+ readonly mcp: {};
119
+ readonly ai: {
120
+ readonly children: {
121
+ readonly unrestrictedBindings: {
122
+ readonly kind: "switch";
123
+ };
124
+ };
125
+ };
126
+ readonly unrestrictedRuns: {
127
+ readonly kind: "switch";
128
+ };
129
+ readonly aiFeedback: {};
130
+ readonly aiMemories: {};
131
+ readonly aiUsage: {};
132
+ readonly knowledge: {};
133
+ readonly datasets: {};
134
+ readonly documents: {};
135
+ readonly workflows: {};
136
+ readonly reports: {};
137
+ readonly notifications: {
138
+ children: {
139
+ channels: {};
140
+ profiles: {};
141
+ };
142
+ };
143
+ readonly eventsHub: {};
144
+ readonly organizationTransfer: {
145
+ readonly children: {
146
+ readonly export: {
147
+ readonly kind: "switch";
148
+ };
149
+ readonly import: {
150
+ readonly kind: "switch";
151
+ };
152
+ readonly inspect: {
153
+ readonly kind: "switch";
154
+ };
155
+ };
156
+ };
157
+ };
158
+ };
159
+ readonly platform: {
160
+ readonly kind: "switch";
161
+ readonly children: {
162
+ conversations: {};
163
+ agents: {};
164
+ knowledge: {};
165
+ workflows: {};
166
+ datasets: {};
167
+ notifications: {};
168
+ attachments: {};
169
+ benchmarks: {};
170
+ messaging: {};
171
+ };
172
+ };
173
+ readonly data: {
174
+ readonly kind: "readManage";
175
+ readonly children: {
176
+ knowledge: {};
177
+ documents: {};
178
+ datasets: {};
179
+ };
180
+ };
181
+ readonly tenant: {
182
+ readonly kind: "readManage";
183
+ readonly grantable: false;
184
+ readonly children: {
185
+ readonly organizations: {};
186
+ readonly users: {};
187
+ readonly infrastructure: {};
188
+ readonly secrets: {};
189
+ readonly aiModels: {};
190
+ readonly studioReleases: {};
191
+ readonly maintenance: {};
192
+ readonly settings: {};
193
+ readonly monitoring: {};
194
+ readonly eventsHubPii: {
195
+ readonly kind: "switch";
196
+ };
197
+ readonly workflowsPii: {
198
+ readonly kind: "switch";
199
+ };
200
+ readonly data: {};
201
+ };
202
+ };
203
+ }>;
204
+ /** The built-in Groups, outside the Capability Catalog. */
205
+ export declare const builtinGroups: {
206
+ /** Every member of the Organization; guests are not members. */
207
+ readonly organization: {
208
+ readonly fqn: "core.groups.organization";
209
+ };
210
+ };
211
+ /** A Dashboard section and the authority it shows: the editor and the SDK warn when a profile holds the section without it. */
212
+ export type AccessSectionRequirement = Readonly<{
213
+ requirement: AccessCapabilityRequirement;
214
+ section: string;
215
+ }>;
216
+ /** The authority each core Dashboard section shows (Brief §2.12). */
217
+ export declare const coreSectionRequirements: readonly Readonly<{
218
+ requirement: AccessCapabilityRequirement;
219
+ section: string;
220
+ }>[];
221
+ export {};