@astrale-os/kernel-core 0.9.0-beta.9 → 0.9.0

package/dist/schema/domain/domain.js

@@ -9,8 +9,11 @@ export const Domain = nodeClass({
             type: 'string',
             pattern: '[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+',
         },
-        dependencyContext: property({ type: 'array', items: { type: 'object' } }, { visibility: 'private', required: false }),
-        schema: property({ type: 'object' }, { visibility: 'private' }),
-        schemaRevision: property({ type: 'string', pattern: 'sha256:[0-9a-f]{64}' }, { visibility: 'private' }),
+        // The authored display name; a revision that predates it projects its origin instead, which
+        // is why the bound admits a complete origin rather than only an authored name.
+        name: { type: 'string', minLength: 1, maxLength: 253 },
+        dependencyContext: property({ type: 'array', items: { type: 'object' } }, { required: false }),
+        schema: property({ type: 'object' }, {}),
+        schemaRevision: property({ type: 'string', pattern: 'sha256:[0-9a-f]{64}' }, {}),
     },
 });

package/dist/schema/domain/of-domain.d.ts

@@ -1,208 +1,34 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const OfDomain: builder.DirectedEdgeClass<{
+    readonly depth: 1;
     readonly abstract: false;
-    readonly source: {
-        readonly as: "member";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: true;
-            readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-        }>];
-        readonly outgoing: "0..1";
-    };
-    readonly target: {
-        readonly as: "domain";
-        readonly accepts: readonly [builder.NodeClass<{
-            readonly abstract: false;
-            readonly description: "A stable Domain principal and the active projection of one canonical DomainSchema revision.";
-            readonly extends: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
-                readonly extends: readonly [builder.NodeClass<{
-                    readonly abstract: true;
-                    readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-                }>];
-                readonly properties: {
-                    readonly frozen: builder.Property<{
-                        readonly type: "boolean";
-                    }, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly iss: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"contains">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"eq">;
-                        value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                        claim: import("zod").ZodString;
-                        op: import("zod").ZodLiteral<"exists">;
-                    }, import("zod/v4/core").$strict>], "op">>, {
-                        readonly required: false;
-                        readonly visibility: "private";
-                    }>;
-                    readonly sub: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                };
-                readonly methods: Readonly<{
-                    delegate: builder.Method<{
-                        readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodString;
-                            ttlSeconds: import("zod").ZodNumber;
-                            attenuation: import("zod").ZodUnknown;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly inheritance: "default";
-                    }>;
-                    can: builder.Method<{
-                        readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{
-                            policy: import("zod").ZodString;
-                            object: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            allowed: import("zod").ZodBoolean;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whoami: builder.Method<{
-                        readonly description: "Return the Identity authenticated for this invocation.";
-                        readonly auth: "authenticated";
-                        readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    whois: builder.Method<{
-                        readonly description: "Resolve one issuer-and-subject Identity.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                            id: import("zod").ZodString;
-                            issuer: import("zod").ZodString;
-                            subject: import("zod").ZodString;
-                            frozen: import("zod").ZodBoolean;
-                            requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"contains">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"eq">;
-                                value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                                claim: import("zod").ZodString;
-                                op: import("zod").ZodLiteral<"exists">;
-                            }, import("zod/v4/core").$strict>], "op">>;
-                        }, import("zod/v4/core").$strict>>;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                    mint: builder.Method<{
-                        readonly description: "Resolve and sign one authorized Grant credential.";
-                        readonly auth: "authorized";
-                        readonly input: import("zod").ZodObject<{
-                            audience: import("zod").ZodOptional<import("zod").ZodString>;
-                            ttlSeconds: import("zod").ZodNumber;
-                            grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-                        }, import("zod/v4/core").$strict>;
-                        readonly output: import("zod").ZodString;
-                        readonly static: true;
-                        readonly inheritance: "default";
-                    }>;
-                }>;
-            }>];
-            readonly properties: {
-                readonly origin: {
-                    readonly type: "string";
-                    readonly pattern: "[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+";
-                };
-                readonly dependencyContext: builder.Property<{
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                    };
-                }, {
-                    readonly visibility: "private";
-                    readonly required: false;
-                }>;
-                readonly schema: builder.Property<{
-                    readonly type: "object";
-                }, {
-                    readonly visibility: "private";
-                }>;
-                readonly schemaRevision: builder.Property<{
-                    readonly type: "string";
-                    readonly pattern: "sha256:[0-9a-f]{64}";
-                }, {
-                    readonly visibility: "private";
-                }>;
-            };
-        }>];
-        readonly incoming: "0..*";
-    };
-    readonly description: "A schema declaration or Core node belongs to one Domain member namespace.";
-    readonly extends: readonly [builder.DirectedEdgeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"edge", {
         readonly abstract: true;
+        readonly depth: 0;
+        readonly properties: never;
         readonly source: {
             readonly as: "source";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
             readonly outgoing: "0..*";
         };
         readonly target: {
             readonly as: "target";
-            readonly accepts: readonly [builder.NodeClass<{
-                readonly abstract: true;
-                readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-            }>];
             readonly incoming: "0..*";
         };
-        readonly description: "Explicit kernel marker for Edge definitions; it carries no structural fields.";
-    }>];
+        readonly constraints: Record<never, never>;
+    }, never, never, never>];
+    readonly properties: {
+        readonly member: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "member", "self", never>;
+    };
+    readonly source: {
+        readonly as: "member";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "domain";
+        readonly incoming: "0..*";
+    };
     readonly constraints: {
         readonly noSelf: true;
     };
-    readonly properties: {
-        member: builder.Property<{
-            readonly type: "string";
-            readonly minLength: 3;
-        }, {
-            readonly visibility: "private";
-        }>;
-    };
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "member", "self", never>;
 }>;

package/dist/schema/domain/of-domain.js

@@ -9,6 +9,6 @@ export const OfDomain = edgeClass.directed({
     extends: [Edge],
     constraints: { noSelf: true },
     properties: {
-        member: property({ type: 'string', minLength: 3 }, { visibility: 'private' }),
+        member: property({ type: 'string', minLength: 3 }, {}),
     },
 });

package/dist/schema/identity/composition.d.ts

@@ -1,2 +1,7 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
+/**
+ * One Identity-composition Edge Class. Each is `noSelf` and `acyclic` on its own; no constraint spans
+ * the three Classes, so stored data may hold a cycle that crosses them. Core authority decides every
+ * binder whose closure reaches such a cycle false, and no other (AUTH-AUTHORITY-DENOTATION).
+ */
 export declare function identityComposition(role: 'constraint' | 'excluded' | 'extension', description: string): builder.EdgeClass;

package/dist/schema/identity/composition.js

@@ -1,6 +1,11 @@
 import { edgeClass } from '@astrale-os/kernel-dsl/v1';
 import { Edge } from '../meta/index.js';
 import { Identity } from './identity.js';
+/**
+ * One Identity-composition Edge Class. Each is `noSelf` and `acyclic` on its own; no constraint spans
+ * the three Classes, so stored data may hold a cycle that crosses them. Core authority decides every
+ * binder whose closure reaches such a cycle false, and no other (AUTH-AUTHORITY-DENOTATION).
+ */
 export function identityComposition(role, description) {
     return edgeClass.directed({
         abstract: false,

package/dist/schema/identity/identity.d.ts

@@ -1,131 +1,234 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Identity: builder.NodeClass<{
+    readonly depth: 1;
     readonly abstract: true;
-    readonly description: "A principal that can be authenticated and can originate persistent authority facts.";
-    readonly extends: readonly [builder.NodeClass<{
+    readonly extends: readonly [builder.ClassReferenceProjection<"node", {
         readonly abstract: true;
-        readonly description: "The abstract universal kernel Node Class extended by every Kernel Node Class.";
-    }>];
+        readonly depth: 0;
+        readonly properties: never;
+        readonly methods: Readonly<Record<never, never>>;
+    }, never, never, never>];
     readonly properties: {
-        readonly frozen: builder.Property<{
-            readonly type: "boolean";
-        }, {
-            readonly required: false;
-            readonly visibility: "private";
-        }>;
-        readonly iss: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly requiredClaims: builder.Property<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            op: import("zod").ZodLiteral<"contains">;
-            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            op: import("zod").ZodLiteral<"eq">;
-            value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            op: import("zod").ZodLiteral<"exists">;
-        }, import("zod/v4/core").$strict>], "op">>, {
-            readonly required: false;
-            readonly visibility: "private";
-        }>;
-        readonly sub: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
+        readonly iss: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never>;
+        readonly sub: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+        readonly frozen: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never>;
+        readonly requiredClaims: builder.AuthoredPropertyProjection<({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[], ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[], false, "requiredClaims", "self", never>;
     };
     readonly methods: Readonly<{
-        delegate: builder.Method<{
-            readonly description: "Issue one strictly attenuated credential from this authenticated Identity.";
-            readonly auth: "authenticated";
-            readonly input: import("zod").ZodObject<{
-                audience: import("zod").ZodString;
-                ttlSeconds: import("zod").ZodNumber;
-                attenuation: import("zod").ZodUnknown;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodString;
-            readonly inheritance: "default";
-        }>;
-        can: builder.Method<{
-            readonly description: "Determine whether the current authenticated Identity satisfies one installed Policy for one object.";
-            readonly auth: "authenticated";
-            readonly input: import("zod").ZodObject<{
-                policy: import("zod").ZodString;
-                object: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodObject<{
-                allowed: import("zod").ZodBoolean;
-            }, import("zod/v4/core").$strict>;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
-        whoami: builder.Method<{
-            readonly description: "Return the Identity authenticated for this invocation.";
-            readonly auth: "authenticated";
-            readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                issuer: import("zod").ZodString;
-                subject: import("zod").ZodString;
-                frozen: import("zod").ZodBoolean;
-                requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"contains">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"eq">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"exists">;
-                }, import("zod/v4/core").$strict>], "op">>;
-            }, import("zod/v4/core").$strict>;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
-        whois: builder.Method<{
-            readonly description: "Resolve one issuer-and-subject Identity.";
-            readonly auth: "authorized";
-            readonly input: import("zod").ZodObject<{
-                issuer: import("zod").ZodString;
-                subject: import("zod").ZodString;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodNullable<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                issuer: import("zod").ZodString;
-                subject: import("zod").ZodString;
-                frozen: import("zod").ZodBoolean;
-                requiredClaims: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"contains">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"eq">;
-                    value: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-                    claim: import("zod").ZodString;
-                    op: import("zod").ZodLiteral<"exists">;
-                }, import("zod/v4/core").$strict>], "op">>;
-            }, import("zod/v4/core").$strict>>;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
-        mint: builder.Method<{
-            readonly description: "Resolve and sign one authorized Grant credential.";
-            readonly auth: "authorized";
-            readonly input: import("zod").ZodObject<{
-                audience: import("zod").ZodOptional<import("zod").ZodString>;
-                ttlSeconds: import("zod").ZodNumber;
-                grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
-            }, import("zod/v4/core").$strict>;
-            readonly output: import("zod").ZodString;
-            readonly static: true;
-            readonly inheritance: "default";
-        }>;
+        delegate: builder.Method<builder.CallableProjection<{
+            principal: string;
+            audience: string;
+            ttlSeconds: number;
+        }, {
+            readonly mode: 'value';
+            readonly value: string;
+        }, "authenticated", true, false, undefined>>;
+        can: builder.Method<builder.CallableProjection<{
+            policy: string;
+            object: string;
+        } | {
+            checks: {
+                policy: string;
+                object: string;
+            }[];
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                allowed: boolean;
+            } | {
+                decisions: {
+                    allowed: boolean;
+                }[];
+            };
+        }, "authenticated", true, false, undefined>>;
+        whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                iss: string;
+                sub: string;
+                frozen: boolean;
+                requiredClaims: ({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[];
+            };
+        }, "authenticated", true, false, undefined>>;
+        whois: builder.Method<builder.CallableProjection<{
+            iss: string;
+            sub: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                iss: string;
+                sub: string;
+                frozen: boolean;
+                requiredClaims: ({
+                    claim: string;
+                    op: "contains";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "eq";
+                    value: unknown;
+                } | {
+                    claim: string;
+                    op: "exists";
+                })[];
+            } | null;
+        }, "authorized", true, false, undefined>>;
+        mint: builder.Method<builder.CallableProjection<{
+            audience?: string | undefined;
+            ttlSeconds: number;
+        }, {
+            readonly mode: 'value';
+            readonly value: string;
+        }, "authenticated", true, false, undefined>>;
+        impersonate: builder.Method<builder.CallableProjection<{
+            audience?: string | undefined;
+            ttlSeconds: number;
+            identity: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: string;
+        }, "authorized", true, false, undefined>>;
     }>;
+    readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never> | builder.AuthoredPropertyProjection<({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], ({
+        claim: string;
+        op: "contains";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "eq";
+        value: unknown;
+    } | {
+        claim: string;
+        op: "exists";
+    })[], false, "requiredClaims", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
+    readonly effectiveStaticMethods: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        };
+    }, "authenticated", true, false, undefined>>, "whoami", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false, undefined>>, "delegate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        iss: string;
+        sub: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            iss: string;
+            sub: string;
+            frozen: boolean;
+            requiredClaims: ({
+                claim: string;
+                op: "contains";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "eq";
+                value: unknown;
+            } | {
+                claim: string;
+                op: "exists";
+            })[];
+        } | null;
+    }, "authorized", true, false, undefined>>, "whois", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false, undefined>>, "mint", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        audience?: string | undefined;
+        ttlSeconds: number;
+        identity: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authorized", true, false, undefined>>, "impersonate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        policy: string;
+        object: string;
+    } | {
+        checks: {
+            policy: string;
+            object: string;
+        }[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            allowed: boolean;
+        } | {
+            decisions: {
+                allowed: boolean;
+            }[];
+        };
+    }, "authenticated", true, false, undefined>>, "can", "self">;
 }>;