@atlanai/sdk 0.1.1 → 0.2.2

package/dist/raw/registry/apis/UsersApi.d.ts

@@ -10,14 +10,18 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import { type MembershipsPage } from '../models/MembershipsPage';
 import { type OnboardResponse } from '../models/OnboardResponse';
-import { type PatchUserBody } from '../models/PatchUserBody';
 import { type SpanListEnvelope } from '../models/SpanListEnvelope';
+import { type TraceContentDeletionDto } from '../models/TraceContentDeletionDto';
 import { type TraceDetailView } from '../models/TraceDetailView';
 import { type TraceListEnvelope } from '../models/TraceListEnvelope';
-import { type UserDto } from '../models/UserDto';
+import { type UserDirectoryDto } from '../models/UserDirectoryDto';
 import { type UsersPage } from '../models/UsersPage';
+export interface RegistryDeleteUserTraceContentRequest {
+    userId: string;
+    traceId: string;
+    workspaceId: string;
+}
 export interface RegistryGetUserRequest {
     userId: string;
 }
@@ -25,9 +29,6 @@ export interface RegistryGetUserTraceRequest {
     userId: string;
     traceId: string;
 }
-export interface RegistryListUserMembershipsRequest {
-    userId: string;
-}
 export interface RegistryListUserTraceSpansRequest {
     userId: string;
     traceId: string;
@@ -46,29 +47,58 @@ export interface RegistryListUserTracesRequest {
 export interface RegistryQueryUserTraceStatsRequest {
     userId: string;
     body: any | null;
+    contentEncoding?: RegistryQueryUserTraceStatsContentEncodingEnum;
 }
-export interface RegistryUpdateUserRequest {
-    userId: string;
-    patchUserBody: PatchUserBody;
+export interface RegistryUpdateOwnUserRequest {
+    requestBody: Array<number>;
+    contentEncoding?: RegistryUpdateOwnUserContentEncodingEnum;
 }
 /**
  *
  */
 export declare class UsersApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for registryDeleteUserTraceContent without sending the request
+     */
+    registryDeleteUserTraceContentRequestOpts(requestParameters: RegistryDeleteUserTraceContentRequest): Promise<runtime.RequestOpts>;
+    /**
+     * The content plane\'s deletion: one transaction tombstones the control row, nulls the manifest and the content-derived title, writes the `trace_content_delete` audit row, and enqueues the physical object deletions — so the commit IS the deletion, every read is structure-only from that moment, and the bytes follow within the executor\'s retry budget. Permanent: a late-arriving part for a deleted trace is refused, and re-approval does not resurrect it. The trace\'s STRUCTURE — the timeline, counts, costs — is untouched, deliberately. Allowed to the trace\'s creator and to an org admin; the `user_id` in the path must be the creator, so an admin deleting on someone\'s behalf addresses the trace under that person.
+     * Delete one trace\'s stored content
+     */
+    registryDeleteUserTraceContentRaw(requestParameters: RegistryDeleteUserTraceContentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TraceContentDeletionDto>>;
+    /**
+     * The content plane\'s deletion: one transaction tombstones the control row, nulls the manifest and the content-derived title, writes the `trace_content_delete` audit row, and enqueues the physical object deletions — so the commit IS the deletion, every read is structure-only from that moment, and the bytes follow within the executor\'s retry budget. Permanent: a late-arriving part for a deleted trace is refused, and re-approval does not resurrect it. The trace\'s STRUCTURE — the timeline, counts, costs — is untouched, deliberately. Allowed to the trace\'s creator and to an org admin; the `user_id` in the path must be the creator, so an admin deleting on someone\'s behalf addresses the trace under that person.
+     * Delete one trace\'s stored content
+     */
+    registryDeleteUserTraceContent(requestParameters: RegistryDeleteUserTraceContentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TraceContentDeletionDto>;
+    /**
+     * Creates request options for registryGetOwnUser without sending the request
+     */
+    registryGetOwnUserRequestOpts(): Promise<runtime.RequestOpts>;
+    /**
+     * The caller\'s own profile, proxied to the control plane verbatim. The registry\'s own account `role` and its advisory `permissions` are **not** merged here — read them from `GET /auth/whoami`. Authenticated only — no role check, because the control plane resolves \"me\" from the asserted bearer.
+     * Get the caller\'s own user record
+     */
+    registryGetOwnUserRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * The caller\'s own profile, proxied to the control plane verbatim. The registry\'s own account `role` and its advisory `permissions` are **not** merged here — read them from `GET /auth/whoami`. Authenticated only — no role check, because the control plane resolves \"me\" from the asserted bearer.
+     * Get the caller\'s own user record
+     */
+    registryGetOwnUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
      * Creates request options for registryGetUser without sending the request
      */
     registryGetUserRequestOpts(requestParameters: RegistryGetUserRequest): Promise<runtime.RequestOpts>;
     /**
-     * One directory row by principal id. The id is the identity provider\'s subject, not a minted handle, so it carries no prefix to strip.
-     * Get a directory user
+     * One of the account\'s users by id, read natively from the registry. Any account member may read (`members_view`). Carries the user\'s account `role`; an unassigned user reads as `member`.
+     * Get a user
      */
-    registryGetUserRaw(requestParameters: RegistryGetUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserDto>>;
+    registryGetUserRaw(requestParameters: RegistryGetUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserDirectoryDto>>;
     /**
-     * One directory row by principal id. The id is the identity provider\'s subject, not a minted handle, so it carries no prefix to strip.
-     * Get a directory user
+     * One of the account\'s users by id, read natively from the registry. Any account member may read (`members_view`). Carries the user\'s account `role`; an unassigned user reads as `member`.
+     * Get a user
      */
-    registryGetUser(requestParameters: RegistryGetUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDto>;
+    registryGetUser(requestParameters: RegistryGetUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDirectoryDto>;
     /**
      * Creates request options for registryGetUserTrace without sending the request
      */
@@ -83,20 +113,6 @@ export declare class UsersApi extends runtime.BaseAPI {
      * Read one of this person\'s traces
      */
     registryGetUserTrace(requestParameters: RegistryGetUserTraceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TraceDetailView>;
-    /**
-     * Creates request options for registryListUserMemberships without sending the request
-     */
-    registryListUserMembershipsRequestOpts(requestParameters: RegistryListUserMembershipsRequest): Promise<runtime.RequestOpts>;
-    /**
-     * The roster read from the other end: which workspaces this person is seated in. **Bounded by the caller\'s own reach, not the subject\'s** — the page is resolved over the workspaces the caller can **read**, so asking about somebody else cannot reveal a workspace the caller has no access to. A subject seated only in workspaces the caller cannot see returns an empty page, which is the correct answer and deliberately not a 403: the alternative leaks that the seat exists.  Fields: `workspace_id`, `user_id`, `role`, `added_by`, `added_at`, `updated_at`.
-     * List a user\'s workspace memberships
-     */
-    registryListUserMembershipsRaw(requestParameters: RegistryListUserMembershipsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MembershipsPage>>;
-    /**
-     * The roster read from the other end: which workspaces this person is seated in. **Bounded by the caller\'s own reach, not the subject\'s** — the page is resolved over the workspaces the caller can **read**, so asking about somebody else cannot reveal a workspace the caller has no access to. A subject seated only in workspaces the caller cannot see returns an empty page, which is the correct answer and deliberately not a 403: the alternative leaks that the seat exists.  Fields: `workspace_id`, `user_id`, `role`, `added_by`, `added_at`, `updated_at`.
-     * List a user\'s workspace memberships
-     */
-    registryListUserMemberships(requestParameters: RegistryListUserMembershipsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MembershipsPage>;
     /**
      * Creates request options for registryListUserTraceSpans without sending the request
      */
@@ -130,13 +146,13 @@ export declare class UsersApi extends runtime.BaseAPI {
      */
     registryListUsersRequestOpts(): Promise<runtime.RequestOpts>;
     /**
-     * A page of the account\'s directory. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`; `q=` searches the three identifiers. Ordered by name, not by recency — a directory is browsed, and `updated_at` here moves when a token refreshes.
-     * List directory users
+     * A page of the account\'s users, read natively from the registry. Any account member may read (`members_view`). Each row carries its account `role` (`admin` or `member`); an unassigned user reads as `member`. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`.
+     * List users
      */
     registryListUsersRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UsersPage>>;
     /**
-     * A page of the account\'s directory. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`; `q=` searches the three identifiers. Ordered by name, not by recency — a directory is browsed, and `updated_at` here moves when a token refreshes.
-     * List directory users
+     * A page of the account\'s users, read natively from the registry. Any account member may read (`members_view`). Each row carries its account `role` (`admin` or `member`); an unassigned user reads as `member`. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`.
+     * List users
      */
     registryListUsers(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UsersPage>;
     /**
@@ -144,12 +160,12 @@ export declare class UsersApi extends runtime.BaseAPI {
      */
     registryOnboardRequestOpts(): Promise<runtime.RequestOpts>;
     /**
-     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.
+     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.  **A machine identity may not call this**, and gets `403`. Account membership is held by people; a service account, an agent\'s own identity and an action identity each already hold whatever seats they were granted where they were provisioned.
      * Onboard the caller
      */
     registryOnboardRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OnboardResponse>>;
     /**
-     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.
+     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.  **A machine identity may not call this**, and gets `403`. Account membership is held by people; a service account, an agent\'s own identity and an action identity each already hold whatever seats they were granted where they were provisioned.
      * Onboard the caller
      */
     registryOnboard(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OnboardResponse>;
@@ -168,17 +184,33 @@ export declare class UsersApi extends runtime.BaseAPI {
      */
     registryQueryUserTraceStats(requestParameters: RegistryQueryUserTraceStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any>;
     /**
-     * Creates request options for registryUpdateUser without sending the request
+     * Creates request options for registryUpdateOwnUser without sending the request
      */
-    registryUpdateUserRequestOpts(requestParameters: RegistryUpdateUserRequest): Promise<runtime.RequestOpts>;
+    registryUpdateOwnUserRequestOpts(requestParameters: RegistryUpdateOwnUserRequest): Promise<runtime.RequestOpts>;
     /**
-     * The whole write surface of this table. **Self only**: every org member holds the one organization permission, so the check that keeps one member out of another\'s row is a domain rule and a 403, not a missing permission. `enrichment: null` clears the blob.
-     * Replace a user\'s enrichment
+     * Update the caller\'s own user record, proxied to the control plane. Authenticated only; the control plane resolves \"me\" from the asserted bearer.
+     * Update the caller\'s own user record
      */
-    registryUpdateUserRaw(requestParameters: RegistryUpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserDto>>;
+    registryUpdateOwnUserRaw(requestParameters: RegistryUpdateOwnUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
     /**
-     * The whole write surface of this table. **Self only**: every org member holds the one organization permission, so the check that keeps one member out of another\'s row is a domain rule and a 403, not a missing permission. `enrichment: null` clears the blob.
-     * Replace a user\'s enrichment
+     * Update the caller\'s own user record, proxied to the control plane. Authenticated only; the control plane resolves \"me\" from the asserted bearer.
+     * Update the caller\'s own user record
      */
-    registryUpdateUser(requestParameters: RegistryUpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDto>;
+    registryUpdateOwnUser(requestParameters: RegistryUpdateOwnUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryQueryUserTraceStatsContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryUpdateOwnUserContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
 }

package/dist/raw/registry/apis/UsersApi.js

@@ -46,28 +46,36 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UsersApi = void 0;
+exports.RegistryUpdateOwnUserContentEncodingEnum = exports.RegistryQueryUserTraceStatsContentEncodingEnum = exports.UsersApi = void 0;
 const runtime = __importStar(require("../runtime"));
-const MembershipsPage_1 = require("../models/MembershipsPage");
 const OnboardResponse_1 = require("../models/OnboardResponse");
-const PatchUserBody_1 = require("../models/PatchUserBody");
 const SpanListEnvelope_1 = require("../models/SpanListEnvelope");
+const TraceContentDeletionDto_1 = require("../models/TraceContentDeletionDto");
 const TraceDetailView_1 = require("../models/TraceDetailView");
 const TraceListEnvelope_1 = require("../models/TraceListEnvelope");
-const UserDto_1 = require("../models/UserDto");
+const UserDirectoryDto_1 = require("../models/UserDirectoryDto");
 const UsersPage_1 = require("../models/UsersPage");
 /**
  *
  */
 class UsersApi extends runtime.BaseAPI {
     /**
-     * Creates request options for registryGetUser without sending the request
+     * Creates request options for registryDeleteUserTraceContent without sending the request
      */
-    async registryGetUserRequestOpts(requestParameters) {
+    async registryDeleteUserTraceContentRequestOpts(requestParameters) {
         if (requestParameters['userId'] == null) {
-            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling registryGetUser().');
+            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling registryDeleteUserTraceContent().');
+        }
+        if (requestParameters['traceId'] == null) {
+            throw new runtime.RequiredError('traceId', 'Required parameter "traceId" was null or undefined when calling registryDeleteUserTraceContent().');
+        }
+        if (requestParameters['workspaceId'] == null) {
+            throw new runtime.RequiredError('workspaceId', 'Required parameter "workspaceId" was null or undefined when calling registryDeleteUserTraceContent().');
         }
         const queryParameters = {};
+        if (requestParameters['workspaceId'] != null) {
+            queryParameters['workspace_id'] = requestParameters['workspaceId'];
+        }
         const headerParameters = {};
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
@@ -76,41 +84,76 @@ class UsersApi extends runtime.BaseAPI {
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        let urlPath = `/users/{user_id}`;
+        let urlPath = `/users/{user_id}/traces/{trace_id}/content`;
         urlPath = urlPath.replace('{user_id}', encodeURIComponent(String(requestParameters['userId'])));
+        urlPath = urlPath.replace('{trace_id}', encodeURIComponent(String(requestParameters['traceId'])));
         return {
             path: urlPath,
-            method: 'GET',
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         };
     }
     /**
-     * One directory row by principal id. The id is the identity provider\'s subject, not a minted handle, so it carries no prefix to strip.
-     * Get a directory user
+     * The content plane\'s deletion: one transaction tombstones the control row, nulls the manifest and the content-derived title, writes the `trace_content_delete` audit row, and enqueues the physical object deletions — so the commit IS the deletion, every read is structure-only from that moment, and the bytes follow within the executor\'s retry budget. Permanent: a late-arriving part for a deleted trace is refused, and re-approval does not resurrect it. The trace\'s STRUCTURE — the timeline, counts, costs — is untouched, deliberately. Allowed to the trace\'s creator and to an org admin; the `user_id` in the path must be the creator, so an admin deleting on someone\'s behalf addresses the trace under that person.
+     * Delete one trace\'s stored content
      */
-    async registryGetUserRaw(requestParameters, initOverrides) {
-        const requestOptions = await this.registryGetUserRequestOpts(requestParameters);
+    async registryDeleteUserTraceContentRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryDeleteUserTraceContentRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, UserDto_1.UserDtoFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, TraceContentDeletionDto_1.TraceContentDeletionDtoFromJSON)(jsonValue));
     }
     /**
-     * One directory row by principal id. The id is the identity provider\'s subject, not a minted handle, so it carries no prefix to strip.
-     * Get a directory user
+     * The content plane\'s deletion: one transaction tombstones the control row, nulls the manifest and the content-derived title, writes the `trace_content_delete` audit row, and enqueues the physical object deletions — so the commit IS the deletion, every read is structure-only from that moment, and the bytes follow within the executor\'s retry budget. Permanent: a late-arriving part for a deleted trace is refused, and re-approval does not resurrect it. The trace\'s STRUCTURE — the timeline, counts, costs — is untouched, deliberately. Allowed to the trace\'s creator and to an org admin; the `user_id` in the path must be the creator, so an admin deleting on someone\'s behalf addresses the trace under that person.
+     * Delete one trace\'s stored content
      */
-    async registryGetUser(requestParameters, initOverrides) {
-        const response = await this.registryGetUserRaw(requestParameters, initOverrides);
+    async registryDeleteUserTraceContent(requestParameters, initOverrides) {
+        const response = await this.registryDeleteUserTraceContentRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Creates request options for registryGetUserTrace without sending the request
+     * Creates request options for registryGetOwnUser without sending the request
      */
-    async registryGetUserTraceRequestOpts(requestParameters) {
-        if (requestParameters['userId'] == null) {
-            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling registryGetUserTrace().');
+    async registryGetOwnUserRequestOpts() {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
         }
-        if (requestParameters['traceId'] == null) {
-            throw new runtime.RequiredError('traceId', 'Required parameter "traceId" was null or undefined when calling registryGetUserTrace().');
+        let urlPath = `/users/me`;
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * The caller\'s own profile, proxied to the control plane verbatim. The registry\'s own account `role` and its advisory `permissions` are **not** merged here — read them from `GET /auth/whoami`. Authenticated only — no role check, because the control plane resolves \"me\" from the asserted bearer.
+     * Get the caller\'s own user record
+     */
+    async registryGetOwnUserRaw(initOverrides) {
+        const requestOptions = await this.registryGetOwnUserRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * The caller\'s own profile, proxied to the control plane verbatim. The registry\'s own account `role` and its advisory `permissions` are **not** merged here — read them from `GET /auth/whoami`. Authenticated only — no role check, because the control plane resolves \"me\" from the asserted bearer.
+     * Get the caller\'s own user record
+     */
+    async registryGetOwnUser(initOverrides) {
+        await this.registryGetOwnUserRaw(initOverrides);
+    }
+    /**
+     * Creates request options for registryGetUser without sending the request
+     */
+    async registryGetUserRequestOpts(requestParameters) {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling registryGetUser().');
         }
         const queryParameters = {};
         const headerParameters = {};
@@ -121,9 +164,8 @@ class UsersApi extends runtime.BaseAPI {
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        let urlPath = `/users/{user_id}/traces/{trace_id}`;
+        let urlPath = `/users/{user_id}`;
         urlPath = urlPath.replace('{user_id}', encodeURIComponent(String(requestParameters['userId'])));
-        urlPath = urlPath.replace('{trace_id}', encodeURIComponent(String(requestParameters['traceId'])));
         return {
             path: urlPath,
             method: 'GET',
@@ -132,28 +174,31 @@ class UsersApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Use this operation to read one of this person\'s traces.
-     * Read one of this person\'s traces
+     * One of the account\'s users by id, read natively from the registry. Any account member may read (`members_view`). Carries the user\'s account `role`; an unassigned user reads as `member`.
+     * Get a user
      */
-    async registryGetUserTraceRaw(requestParameters, initOverrides) {
-        const requestOptions = await this.registryGetUserTraceRequestOpts(requestParameters);
+    async registryGetUserRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryGetUserRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, TraceDetailView_1.TraceDetailViewFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, UserDirectoryDto_1.UserDirectoryDtoFromJSON)(jsonValue));
     }
     /**
-     * Use this operation to read one of this person\'s traces.
-     * Read one of this person\'s traces
+     * One of the account\'s users by id, read natively from the registry. Any account member may read (`members_view`). Carries the user\'s account `role`; an unassigned user reads as `member`.
+     * Get a user
      */
-    async registryGetUserTrace(requestParameters, initOverrides) {
-        const response = await this.registryGetUserTraceRaw(requestParameters, initOverrides);
+    async registryGetUser(requestParameters, initOverrides) {
+        const response = await this.registryGetUserRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Creates request options for registryListUserMemberships without sending the request
+     * Creates request options for registryGetUserTrace without sending the request
      */
-    async registryListUserMembershipsRequestOpts(requestParameters) {
+    async registryGetUserTraceRequestOpts(requestParameters) {
         if (requestParameters['userId'] == null) {
-            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling registryListUserMemberships().');
+            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling registryGetUserTrace().');
+        }
+        if (requestParameters['traceId'] == null) {
+            throw new runtime.RequiredError('traceId', 'Required parameter "traceId" was null or undefined when calling registryGetUserTrace().');
         }
         const queryParameters = {};
         const headerParameters = {};
@@ -164,8 +209,9 @@ class UsersApi extends runtime.BaseAPI {
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        let urlPath = `/users/{user_id}/memberships`;
+        let urlPath = `/users/{user_id}/traces/{trace_id}`;
         urlPath = urlPath.replace('{user_id}', encodeURIComponent(String(requestParameters['userId'])));
+        urlPath = urlPath.replace('{trace_id}', encodeURIComponent(String(requestParameters['traceId'])));
         return {
             path: urlPath,
             method: 'GET',
@@ -174,20 +220,20 @@ class UsersApi extends runtime.BaseAPI {
         };
     }
     /**
-     * The roster read from the other end: which workspaces this person is seated in. **Bounded by the caller\'s own reach, not the subject\'s** — the page is resolved over the workspaces the caller can **read**, so asking about somebody else cannot reveal a workspace the caller has no access to. A subject seated only in workspaces the caller cannot see returns an empty page, which is the correct answer and deliberately not a 403: the alternative leaks that the seat exists.  Fields: `workspace_id`, `user_id`, `role`, `added_by`, `added_at`, `updated_at`.
-     * List a user\'s workspace memberships
+     * Use this operation to read one of this person\'s traces.
+     * Read one of this person\'s traces
      */
-    async registryListUserMembershipsRaw(requestParameters, initOverrides) {
-        const requestOptions = await this.registryListUserMembershipsRequestOpts(requestParameters);
+    async registryGetUserTraceRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryGetUserTraceRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, MembershipsPage_1.MembershipsPageFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, TraceDetailView_1.TraceDetailViewFromJSON)(jsonValue));
     }
     /**
-     * The roster read from the other end: which workspaces this person is seated in. **Bounded by the caller\'s own reach, not the subject\'s** — the page is resolved over the workspaces the caller can **read**, so asking about somebody else cannot reveal a workspace the caller has no access to. A subject seated only in workspaces the caller cannot see returns an empty page, which is the correct answer and deliberately not a 403: the alternative leaks that the seat exists.  Fields: `workspace_id`, `user_id`, `role`, `added_by`, `added_at`, `updated_at`.
-     * List a user\'s workspace memberships
+     * Use this operation to read one of this person\'s traces.
+     * Read one of this person\'s traces
      */
-    async registryListUserMemberships(requestParameters, initOverrides) {
-        const response = await this.registryListUserMembershipsRaw(requestParameters, initOverrides);
+    async registryGetUserTrace(requestParameters, initOverrides) {
+        const response = await this.registryGetUserTraceRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
@@ -324,8 +370,8 @@ class UsersApi extends runtime.BaseAPI {
         };
     }
     /**
-     * A page of the account\'s directory. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`; `q=` searches the three identifiers. Ordered by name, not by recency — a directory is browsed, and `updated_at` here moves when a token refreshes.
-     * List directory users
+     * A page of the account\'s users, read natively from the registry. Any account member may read (`members_view`). Each row carries its account `role` (`admin` or `member`); an unassigned user reads as `member`. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`.
+     * List users
      */
     async registryListUsersRaw(initOverrides) {
         const requestOptions = await this.registryListUsersRequestOpts();
@@ -333,8 +379,8 @@ class UsersApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, UsersPage_1.UsersPageFromJSON)(jsonValue));
     }
     /**
-     * A page of the account\'s directory. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`; `q=` searches the three identifiers. Ordered by name, not by recency — a directory is browsed, and `updated_at` here moves when a token refreshes.
-     * List directory users
+     * A page of the account\'s users, read natively from the registry. Any account member may read (`members_view`). Each row carries its account `role` (`admin` or `member`); an unassigned user reads as `member`. Supports the shared query grammar over `user_id`, `name`, `email`, `created_at` and `updated_at`.
+     * List users
      */
     async registryListUsers(initOverrides) {
         const response = await this.registryListUsersRaw(initOverrides);
@@ -362,7 +408,7 @@ class UsersApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.
+     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.  **A machine identity may not call this**, and gets `403`. Account membership is held by people; a service account, an agent\'s own identity and an action identity each already hold whatever seats they were granted where they were provisioned.
      * Onboard the caller
      */
     async registryOnboardRaw(initOverrides) {
@@ -371,7 +417,7 @@ class UsersApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, OnboardResponse_1.OnboardResponseFromJSON)(jsonValue));
     }
     /**
-     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.
+     * Scaffold the calling account and the caller\'s personal workspace: the account\'s shared root, the caller\'s own private root, their directory row, their groups, and the account membership every other read is gated on.  **This is the first call a new caller makes.** Before it, the caller holds no account membership, so every account-scoped read answers `403` and the caller has no workspace to create anything in.  **It also installs the deployment\'s extensions**, in dependency order, for any of them this account does not have yet — firing each one\'s `pre_install` gate and seeding `post_install` hook under **your** bearer, exactly as `POST /extensions/{extension}/install` does. On a brand-new account that is the whole set; on an existing one it is usually none, so a repeat onboard fires no install hooks at all. An account whose installs were interrupted completes on its next onboard.  **Idempotent.** A repeat call re-reads what exists and answers `200` with the same assets and `is_created: false`. It also re-asserts the caller\'s access relationships, so a relationship lost to a partial earlier run heals on the next call rather than needing repair.  The caller\'s role on the **shared** root is `admin` for whoever created the account and `member` for everyone after them, and a re-onboard preserves whatever the roster says — a caller whose role was changed is not restored to `admin` by signing in again.  **A machine identity may not call this**, and gets `403`. Account membership is held by people; a service account, an agent\'s own identity and an action identity each already hold whatever seats they were granted where they were provisioned.
      * Onboard the caller
      */
     async registryOnboard(initOverrides) {
@@ -391,6 +437,9 @@ class UsersApi extends runtime.BaseAPI {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -431,18 +480,18 @@ class UsersApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Creates request options for registryUpdateUser without sending the request
+     * Creates request options for registryUpdateOwnUser without sending the request
      */
-    async registryUpdateUserRequestOpts(requestParameters) {
-        if (requestParameters['userId'] == null) {
-            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling registryUpdateUser().');
-        }
-        if (requestParameters['patchUserBody'] == null) {
-            throw new runtime.RequiredError('patchUserBody', 'Required parameter "patchUserBody" was null or undefined when calling registryUpdateUser().');
+    async registryUpdateOwnUserRequestOpts(requestParameters) {
+        if (requestParameters['requestBody'] == null) {
+            throw new runtime.RequiredError('requestBody', 'Required parameter "requestBody" was null or undefined when calling registryUpdateOwnUser().');
         }
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -450,32 +499,48 @@ class UsersApi extends runtime.BaseAPI {
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        let urlPath = `/users/{user_id}`;
-        urlPath = urlPath.replace('{user_id}', encodeURIComponent(String(requestParameters['userId'])));
+        let urlPath = `/users/me`;
         return {
             path: urlPath,
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, PatchUserBody_1.PatchUserBodyToJSON)(requestParameters['patchUserBody']),
+            body: requestParameters['requestBody'],
         };
     }
     /**
-     * The whole write surface of this table. **Self only**: every org member holds the one organization permission, so the check that keeps one member out of another\'s row is a domain rule and a 403, not a missing permission. `enrichment: null` clears the blob.
-     * Replace a user\'s enrichment
+     * Update the caller\'s own user record, proxied to the control plane. Authenticated only; the control plane resolves \"me\" from the asserted bearer.
+     * Update the caller\'s own user record
      */
-    async registryUpdateUserRaw(requestParameters, initOverrides) {
-        const requestOptions = await this.registryUpdateUserRequestOpts(requestParameters);
+    async registryUpdateOwnUserRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registryUpdateOwnUserRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, UserDto_1.UserDtoFromJSON)(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     * The whole write surface of this table. **Self only**: every org member holds the one organization permission, so the check that keeps one member out of another\'s row is a domain rule and a 403, not a missing permission. `enrichment: null` clears the blob.
-     * Replace a user\'s enrichment
+     * Update the caller\'s own user record, proxied to the control plane. Authenticated only; the control plane resolves \"me\" from the asserted bearer.
+     * Update the caller\'s own user record
      */
-    async registryUpdateUser(requestParameters, initOverrides) {
-        const response = await this.registryUpdateUserRaw(requestParameters, initOverrides);
-        return await response.value();
+    async registryUpdateOwnUser(requestParameters, initOverrides) {
+        await this.registryUpdateOwnUserRaw(requestParameters, initOverrides);
     }
 }
 exports.UsersApi = UsersApi;
+/**
+  * @export
+  * @enum {string}
+  */
+var RegistryQueryUserTraceStatsContentEncodingEnum;
+(function (RegistryQueryUserTraceStatsContentEncodingEnum) {
+    RegistryQueryUserTraceStatsContentEncodingEnum["Base64"] = "base64";
+    RegistryQueryUserTraceStatsContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(RegistryQueryUserTraceStatsContentEncodingEnum || (exports.RegistryQueryUserTraceStatsContentEncodingEnum = RegistryQueryUserTraceStatsContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var RegistryUpdateOwnUserContentEncodingEnum;
+(function (RegistryUpdateOwnUserContentEncodingEnum) {
+    RegistryUpdateOwnUserContentEncodingEnum["Base64"] = "base64";
+    RegistryUpdateOwnUserContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(RegistryUpdateOwnUserContentEncodingEnum || (exports.RegistryUpdateOwnUserContentEncodingEnum = RegistryUpdateOwnUserContentEncodingEnum = {}));