@powerportalspro/core 6.0.0 → 7.0.0

package/dist/index.d.cts

@@ -199,6 +199,12 @@ declare const Routes: {
             readonly externalLoginRememberChoice: "/api/auth/external-login/remember-choice";
             /** POST — swap the current cookie for the user's alt identity (the contact↔systemuser sibling). */
             readonly switchIdentity: "/api/auth/switch-identity";
+            /** POST — start impersonating a portal contact. Internal users holding the SystemAdmin role only. */
+            readonly impersonate: "/api/auth/impersonate";
+            /** POST — end an impersonation session. Takes no body; the user to return to comes from the session's claims. */
+            readonly stopImpersonation: "/api/auth/stop-impersonation";
+            /** POST — search portal contacts for the impersonation picker. */
+            readonly impersonateSearch: "/api/auth/impersonate/search";
             /** GET — snapshot of the current user (or anonymous shape). */
             readonly me: "/api/auth/me";
             /** Account-management endpoints under `/api/auth/manage/*`. */
@@ -1508,6 +1514,139 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/auth/impersonate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Starts impersonating the contact named in the request. Requires an authenticated internal
+         *     user holding string AuthEndpoints.ImpersonationRole; see ImpersonateResult? AuthEndpoints.AuthorizeImpersonator(ClaimsPrincipal? principal) for
+         *     why the role alone isn't enough.
+         * @description Typed to PortalUser rather than a generic `TUser`, unlike the rest of
+         *     the auth surface. The whole point of this endpoint is the distinction between a contact
+         *     and a systemuser, which a generic user type has no notion of — the safety of the feature
+         *     rests on resolving the target through the contact store and the caller through the
+         *     systemuser store, so the concrete type is load-bearing rather than incidental.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["ImpersonateRequest"];
+                    "application/x-www-form-urlencoded": components["schemas"]["ImpersonateRequest"];
+                };
+            };
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ImpersonateResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/stop-impersonation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ends an impersonation session and signs the internal user back in. Takes no request body:
+         *         the user to return to comes from string PortalClaimTypes.ImpersonatorUserId on the
+         *         current principal, so a caller can't choose who it becomes on the way back.
+         *         Deliberately NOT gated on string AuthEndpoints.ImpersonationRole. The caller is currently a
+         *     contact — the impersonated one — and won't hold the role; more importantly, an admin whose
+         *     role was revoked mid-session must still be able to get out. The operation only ever
+         *     restores the identity that started the session, so it grants nothing.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["StopImpersonationResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/impersonate/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["ImpersonationSearchRequest"];
+                };
+            };
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ImpersonationSearchResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/Account/Logout": {
         parameters: {
             query?: never;
@@ -3759,6 +3898,14 @@ interface components {
             /** @description Indicates whether this column can be modified when updating an existing record. */
             isValidForUpdate: boolean;
         };
+        /**
+         * @description Bit flags describing what the current user may do with one column of a record. Reported per
+         *     column on Dictionary<string, ColumnSecurityPermission>? TableRecord.ColumnPermissions; the two dimensions are independent, so
+         *     every combination is meaningful — including ColumnSecurityPermission.Write without ColumnSecurityPermission.Read for a
+         *     column a user fills in but never sees back.
+         * @enum {integer}
+         */
+        ColumnSecurityPermission: 0 | 1 | 2 | 3;
         /**
          * @description A sort specification — a column to sort by and the direction. Shared
          *     across the framework: grid UIs use it for sort state,
@@ -4171,6 +4318,29 @@ interface components {
              *     string? CurrentUserInfo.AltIdentityTableName.
              */
             altIdentityUserId?: null | string;
+            /**
+             * @description `true` when this session was started by an internal user impersonating a portal
+             *                 contact. SPA hosts treat it as the trigger to render the impersonation banner and the
+             *                 "stop impersonating" affordance.
+             *                 Every other field on this record describes the impersonated user, by design —
+             *     Guid? CurrentUserInfo.UserId, IReadOnlyList<string> CurrentUserInfo.Roles and PortalUserType? CurrentUserInfo.PortalUserType are the
+             *     contact's, because the session genuinely behaves as that contact. This flag and the two
+             *     Impersonator* fields are the only trace of who is really driving it.
+             */
+            isImpersonating?: boolean;
+            /**
+             * Format: uuid
+             * @description Id of the internal user behind an active impersonation session, or `null` when the
+             *     session is not impersonating. Informational — `POST /api/auth/stop-impersonation`
+             *     re-resolves it server-side from the principal's claims, so SPAs never send it back.
+             */
+            impersonatorUserId?: null | string;
+            /**
+             * @description Display name of the internal user behind an active impersonation session, for the
+             *     banner's "you are viewing as … " text. `null` when the session is not impersonating,
+             *     or when the name could not be resolved. Display only — never an authorization input.
+             */
+            impersonatorName?: null | string;
         };
         /**
          * @description A single value plotted by Chart.js, plus optional per-point color
@@ -4611,6 +4781,73 @@ interface components {
              */
             mode?: components["schemas"]["RelationshipFilterMode"];
         };
+        /** @description Request body for `POST /api/auth/impersonate`. */
+        ImpersonateRequest: {
+            /**
+             * Format: uuid
+             * @description The `contactid` of the portal contact to impersonate. Resolved server-side through
+             *     the contact store only — a systemuserid supplied here does not resolve, so the endpoint
+             *     cannot be used to assume another internal user's identity.
+             */
+            targetUserId?: string;
+        };
+        /** @description Outcome of `POST /api/auth/impersonate`. */
+        ImpersonateResponse: {
+            /** @description What happened. See ImpersonateResult. */
+            result?: components["schemas"]["ImpersonateResult"];
+        };
+        /**
+         * @description Outcome of `POST /api/auth/impersonate`. Members carry explicit integer values so the
+         *     JSON wire form is a stable contract across reorderings.
+         * @enum {integer}
+         */
+        ImpersonateResult: 0 | 1 | 2 | 3 | 4 | 5;
+        /**
+         * @description A portal contact offered as an impersonation target. Deliberately minimal: just enough to
+         *     identify the right person in the picker, since this crosses the wire to an admin's browser.
+         */
+        ImpersonationCandidate: {
+            /**
+             * Format: uuid
+             * @description The contact's `contactid`, sent back as the target of the impersonate call.
+             */
+            contactId?: string;
+            /** @description The contact's `fullname`, or `null` when unset. */
+            fullName?: null | string;
+            /**
+             * @description The first non-empty address among the contact's configured email columns, shown to
+             *     disambiguate people who share a name. `null` when the contact has no address.
+             */
+            email?: null | string;
+        };
+        /**
+         * @description Request body for `POST /api/auth/impersonate/search` — the query behind the
+         *     impersonation picker.
+         */
+        ImpersonationSearchRequest: {
+            /**
+             * @description What the admin typed. A value that parses as a Guid is treated as an exact
+             *     `contactid` lookup; anything else is matched against the contact's full name and
+             *     email columns. Queries shorter than
+             *     int ImpersonationSearch.MinimumQueryLength characters return no results.
+             */
+            query?: string;
+        };
+        /** @description Results of `POST /api/auth/impersonate/search`. */
+        ImpersonationSearchResponse: {
+            /**
+             * @description The matching contacts the caller is allowed to impersonate, capped at
+             *     int ImpersonationSearch.MaximumResults. Empty when the query was too short,
+             *     matched nothing, or the caller isn't permitted to impersonate.
+             */
+            results?: components["schemas"]["ImpersonationCandidate"][];
+            /**
+             * @description `true` when the result set hit int ImpersonationSearch.MaximumResults and
+             *             more matches may exist. The picker uses it to prompt for a narrower query rather than
+             *             implying the list is complete. No total count is computed — this is a picker, not a grid.
+             */
+            hasMore?: boolean;
+        };
         /**
          * @description Join type used on a FetchXML link-entity.
          * @enum {integer}
@@ -5121,13 +5358,25 @@ interface components {
              * @description The total number of records that match the query, when the server returned a count. Null when the count was not requested or could not be computed.
              */
             totalRecordCount?: null | number | string;
-            /** @description The opaque paging cookie used by Dataverse to efficiently fetch the next page. Null when there are no further pages. */
+            /**
+             * @description The opaque paging cookie used by Dataverse to efficiently fetch the next page. Dataverse still issues a
+             *     cookie on the final populated page (it only comes back null once a page past the end is requested), so this
+             *     is not an end-of-data signal — use bool? PagingInfo.MoreRecords for that.
+             */
             pagingCookie?: null | string;
             /**
              * Format: int32
              * @description The 1-based page number of the records in the response.
              */
             pageNumber?: number | string;
+            /**
+             * @description Whether Dataverse reports further pages beyond this one (`EntityCollection.MoreRecords`). This is the
+             *     authoritative end-of-data signal for sequential paging: int? PagingInfo.TotalRecordCount is computed by
+             *     Dataverse before the portal's per-row permission handlers drop rows, so the rows a caller accumulates can
+             *     legitimately total fewer than the count, and string? PagingInfo.PagingCookie is still populated on the last
+             *     populated page. Null when the source of the response cannot report it.
+             */
+            moreRecords?: null | boolean;
         };
         /**
          * @description Returned by `GET /api/auth/external-login/pending` when a recent OAuth
@@ -5470,6 +5719,18 @@ interface components {
              *     "open this record"-style links without per-row metadata lookups.
              */
             isPrimaryName?: boolean;
+            /**
+             * @description What the current user may do with this column, from column-level
+             *     security. ColumnSecurityPermission.All — the default —
+             *     whenever no column restriction applies, which is the usual case.
+             *     A column missing ColumnSecurityPermission.Read is one
+             *     whose values arrive masked, and one missing
+             *     ColumnSecurityPermission.Write should not offer inline
+             *     editing, since the save would be rejected server-side. Columns the user
+             *     may not read at all are absent from the list entirely rather than
+             *     reported here.
+             */
+            permissions?: components["schemas"]["ColumnSecurityPermission"];
             /**
              * Format: int32
              * @description Configured display width in pixels (from the view definition).
@@ -5531,6 +5792,22 @@ interface components {
              */
             errors?: string[];
         };
+        /**
+         * @description Outcome of `POST /api/auth/stop-impersonation`. Takes no request body — the internal
+         *     user to return to is re-resolved server-side from
+         *     string PortalClaimTypes.ImpersonatorUserId, so the client can't choose who it
+         *     becomes on the way back.
+         */
+        StopImpersonationResponse: {
+            /** @description What happened. See StopImpersonationResult. */
+            result?: components["schemas"]["StopImpersonationResult"];
+        };
+        /**
+         * @description Outcome of `POST /api/auth/stop-impersonation`. Members carry explicit integer values
+         *     so the JSON wire form is a stable contract across reorderings.
+         * @enum {integer}
+         */
+        StopImpersonationResult: 0 | 1 | 2 | 3;
         /** @description Outcome of `POST /api/auth/switch-identity`. */
         SwitchIdentityResponse: {
             /** @description What happened. See SwitchIdentityResult. */
@@ -5584,6 +5861,22 @@ interface components {
             };
             /** @description The set of permissions the current user has on this record. Defaults to TableSecurityPermission.Read. */
             permissions?: components["schemas"]["TableSecurityPermission"];
+            /**
+             * @description Per-column access for the current user, keyed by column logical name — populated only for
+             *                 the columns of this record whose access is narrowed by column-level security, so a record on
+             *                 an unrestricted table carries nothing. Absent from the dictionary means full access, which is
+             *                 the overwhelmingly common case; the dictionary itself is null when nothing is restricted.
+             *                 Clients use it to render honestly rather than to enforce anything — the server has already
+             *     withheld what the user may not read and rejects what they may not write. A column present
+             *     here without ColumnSecurityPermission.Read is one whose value has been masked
+             *     (its real value never left the server), and one without
+             *     ColumnSecurityPermission.Write should render read-only rather than letting the
+             *     user edit into a save that will be rejected.Columns withheld by omission are deliberately NOT listed: omitting exists precisely so that
+             *     nothing in the response reveals the column, and naming it here would undo that.
+             */
+            columnPermissions?: null | {
+                [key: string]: components["schemas"]["ColumnSecurityPermission"];
+            };
             /** @description Per-column localized display strings supplied by Dataverse, keyed by column logical name. */
             formattedValues?: {
                 [key: string]: string;
@@ -5906,6 +6199,12 @@ type ConfirmExternalLoginRequest = Schemas$1['ConfirmExternalLoginRequest'];
 type ConfirmExternalLoginResponse = Schemas$1['ConfirmExternalLoginResponse'];
 type SelectExternalLoginRequest = Schemas$1['SelectExternalLoginRequest'];
 type SwitchIdentityResponse = Schemas$1['SwitchIdentityResponse'];
+type ImpersonateRequest = Schemas$1['ImpersonateRequest'];
+type ImpersonateResponse = Schemas$1['ImpersonateResponse'];
+type StopImpersonationResponse = Schemas$1['StopImpersonationResponse'];
+type ImpersonationSearchRequest = Schemas$1['ImpersonationSearchRequest'];
+type ImpersonationSearchResponse = Schemas$1['ImpersonationSearchResponse'];
+type ImpersonationCandidate = Schemas$1['ImpersonationCandidate'];
 type ProfileResponse = Schemas$1['ProfileResponse'];
 type UpdateProfileRequest = Schemas$1['UpdateProfileRequest'];
 type SetPasswordRequest = Schemas$1['SetPasswordRequest'];
@@ -6014,6 +6313,32 @@ declare class AuthClient {
      * supplies no parameters.
      */
     switchIdentityAsync(signal?: AbortSignal): Promise<SwitchIdentityResponse>;
+    /**
+     * Starts impersonating a portal contact, swapping the auth cookie for theirs. Restricted
+     * server-side to internal users holding the `SystemAdmin` role; the target is resolved through
+     * the contact store alone, so a systemuser id can't be supplied to assume a staff identity.
+     *
+     * On `ImpersonateResult.Started` the session IS that contact — `/api/auth/me` reports the
+     * contact's id, roles and user type, with only `isImpersonating` / `impersonator*` betraying
+     * who is behind it. Reload or re-fetch the user after this resolves; anything already rendered
+     * was rendered for the previous identity.
+     */
+    impersonateAsync(targetUserId: string, signal?: AbortSignal): Promise<ImpersonateResponse>;
+    /**
+     * Ends an impersonation session and signs the internal user back in. Takes no parameters — the
+     * identity to return to is read from the session's own claims server-side, so a caller can't
+     * choose who it becomes on the way back.
+     */
+    stopImpersonationAsync(signal?: AbortSignal): Promise<StopImpersonationResponse>;
+    /**
+     * Searches portal contacts that may be impersonated. A query that parses as a GUID is an exact
+     * user-id lookup; otherwise it matches full name and email columns, and queries shorter than
+     * three characters return nothing.
+     *
+     * Returns an empty result rather than failing when the caller isn't permitted to impersonate,
+     * so a picker renders "no matches" without learning which condition applied.
+     */
+    searchImpersonationTargetsAsync(query: string, signal?: AbortSignal): Promise<ImpersonationSearchResponse>;
     /** Reads the signed-in user's manage-profile snapshot (Identity status + linked contact fields). */
     getProfileAsync(signal?: AbortSignal): Promise<ProfileResponse>;
     /** Updates first/last/mobile on the signed-in user's linked Dataverse contact. */
@@ -6158,6 +6483,23 @@ declare const ChartDateGrouping: {
     readonly QuarterAndYear: 10;
 };
 type ChartDateGrouping = (typeof ChartDateGrouping)[keyof typeof ChartDateGrouping];
+/**
+ * Bit flags describing what the current user may do with one column of a record. Reported per
+ * column on Dictionary&lt;string, ColumnSecurityPermission&gt;? TableRecord.ColumnPermissions; the two dimensions are independent, so
+ * every combination is meaningful — including ColumnSecurityPermission.Write without ColumnSecurityPermission.Read for a
+ * column a user fills in but never sees back.
+ */
+declare const ColumnSecurityPermission: {
+    /** The column can be neither read nor written. */
+    readonly None: 0;
+    /** The column's real value is returned. */
+    readonly Read: 1;
+    /** The column can be included in a create or update. */
+    readonly Write: 2;
+    /** Full access — the default for every column not listed in ColumnPermissions. */
+    readonly All: 3;
+};
+type ColumnSecurityPermission = (typeof ColumnSecurityPermission)[keyof typeof ColumnSecurityPermission];
 /**
  * Identifies the data type of a Dataverse column. Values 0–20 mirror the Dataverse SDK's `AttributeTypeCode`; values 40+ are PowerPortalsPro-specific column types not present in Dataverse.
  */
@@ -6283,6 +6625,25 @@ declare const FileArchiveResponseFormat: {
     readonly Json: 1;
 };
 type FileArchiveResponseFormat = (typeof FileArchiveResponseFormat)[keyof typeof FileArchiveResponseFormat];
+/**
+ * Outcome of `POST /api/auth/impersonate`. Members carry explicit integer values so the
+ * JSON wire form is a stable contract across reorderings.
+ */
+declare const ImpersonateResult: {
+    /** The target contact was signed in and the auth cookie has been swapped. */
+    readonly Started: 0;
+    /** The current request is unauthenticated. */
+    readonly NotAuthenticated: 1;
+    /** The caller may not impersonate — either they don't hold the SystemAdmin role, or they aren't a real internal systemuser (a contact backed by a stub systemuser is still a portal contact and can never impersonate). */
+    readonly NotAuthorized: 2;
+    /** No active contact exists with the requested id. Also returned when the id belongs to a systemuser — the lookup only ever consults the contact store, so an internal user's id simply doesn't resolve. */
+    readonly TargetNotFound: 3;
+    /** The contact exists but the host's impersonation target filter rejected it. */
+    readonly TargetNotImpersonatable: 4;
+    /** The session is already impersonating. Nesting isn't supported — it would make the return path order-dependent — so stop the current impersonation first. */
+    readonly AlreadyImpersonating: 5;
+};
+type ImpersonateResult = (typeof ImpersonateResult)[keyof typeof ImpersonateResult];
 /**
  * Join type used on a FetchXML link-entity.
  */
@@ -6400,6 +6761,21 @@ declare const ResetPasswordResult: {
     readonly InvalidPassword: 2;
 };
 type ResetPasswordResult = (typeof ResetPasswordResult)[keyof typeof ResetPasswordResult];
+/**
+ * Outcome of `POST /api/auth/stop-impersonation`. Members carry explicit integer values
+ * so the JSON wire form is a stable contract across reorderings.
+ */
+declare const StopImpersonationResult: {
+    /** Impersonation ended and the auth cookie is back to the internal user. */
+    readonly Stopped: 0;
+    /** The session wasn't impersonating — there was nothing to stop. */
+    readonly NotImpersonating: 1;
+    /** The internal user recorded on the session no longer resolves (disabled or removed in Dataverse mid-session). The impersonated session is signed out rather than left running, so the caller ends up anonymous and must sign in again. */
+    readonly ImpersonatorNotFound: 2;
+    /** The current request is unauthenticated. */
+    readonly NotAuthenticated: 3;
+};
+type StopImpersonationResult = (typeof StopImpersonationResult)[keyof typeof StopImpersonationResult];
 /**
  * Outcome of `POST /api/auth/switch-identity`. Members carry explicit
  * integer values so the JSON wire form is a stable contract across
@@ -6457,7 +6833,7 @@ declare const ViewType: {
 type ViewType = (typeof ViewType)[keyof typeof ViewType];
 
 type Schemas = components['schemas'];
-type TableRecord$1 = Schemas['TableRecord'];
+type TableRecord$2 = Schemas['TableRecord'];
 type TableRecordReference = Schemas['TableRecordReference'];
 type CreateResponse = Schemas['CreateResponse'];
 type UpdateResponse = Schemas['UpdateResponse'];
@@ -6564,12 +6940,12 @@ declare class PowerPortalsProClient {
      * marks every property as modified before applying so column values
      * arriving from JSON (which carry no dirty flags) round-trip correctly.
      */
-    createRecordAsync(record: TableRecord$1, signal?: AbortSignal): Promise<CreateResponse>;
+    createRecordAsync(record: TableRecord$2, signal?: AbortSignal): Promise<CreateResponse>;
     /**
      * Reads a single record. `columns` (logical names) narrows the projection to a subset;
      * omit it for the table's full set of columns visible to the caller.
      */
-    retrieveRecordAsync(tableLogicalName: string, recordId: string, columns?: readonly string[], signal?: AbortSignal): Promise<TableRecord$1>;
+    retrieveRecordAsync(tableLogicalName: string, recordId: string, columns?: readonly string[], signal?: AbortSignal): Promise<TableRecord$2>;
     /**
      * Probes whether the localization-translation feature is usable: whether a translation
      * provider is configured, whether the managed solution is installed, and the candidate
@@ -6673,7 +7049,7 @@ declare class PowerPortalsProClient {
      * Updates an existing record. URL is derived from `record.tableName` and `record.id`
      * `record.id` must be set. For a new record, use {@link createRecordAsync} instead.
      */
-    updateRecordAsync(record: TableRecord$1, signal?: AbortSignal): Promise<UpdateResponse>;
+    updateRecordAsync(record: TableRecord$2, signal?: AbortSignal): Promise<UpdateResponse>;
     /**
      * Executes a batch of {@link OrganizationRequest}s as a single round-trip.
      * The MainContext save flow uses this to ship every dirty descendant's
@@ -6867,6 +7243,32 @@ declare class PowerPortalsProClient {
     getOrganizationSettingsAsync(signal?: AbortSignal): Promise<OrganizationSettings>;
 }
 
+type TableRecord$1 = components['schemas']['TableRecord'];
+/**
+ * Returns what the current user may do with one of a record's columns, from column-level
+ * security. Columns the server didn't narrow — the overwhelming majority — aren't carried on the
+ * record at all, so anything unlisted comes back as `ColumnSecurityPermission.All`.
+ *
+ * Mirrors `TableRecordExtensions.GetColumnPermissions` on the .NET side.
+ */
+declare function getColumnPermissions(record: Pick<TableRecord$1, 'columnPermissions'> | null | undefined, columnName: string): ColumnSecurityPermission;
+/**
+ * Whether the record carries this column's real value. `false` means the value present is a mask
+ * standing in for one the user may not see — render it as withheld rather than as data. A column
+ * the user may not read at all isn't on the record in the first place, so it never reaches here.
+ *
+ * Note that for every column type but text the mask lives in the record's *formatted* value, not
+ * its value: the server can't express a placeholder as a number, date or lookup, so it clears the
+ * value instead. Render a withheld column through `<ColumnDisplayValue>`, which reads the
+ * formatted value and therefore shows the mask whatever the column's type.
+ */
+declare function canReadColumn(record: Pick<TableRecord$1, 'columnPermissions'> | null | undefined, columnName: string): boolean;
+/**
+ * Whether the user may include this column in a save. `false` means an editor should render
+ * read-only — the server rejects a create or update that changes it.
+ */
+declare function canWriteColumn(record: Pick<TableRecord$1, 'columnPermissions'> | null | undefined, columnName: string): boolean;
+
 type TableRecord = components['schemas']['TableRecord'];
 /**
  * Resolves the id to use when building a `TableRecordReference` (or any
@@ -6887,4 +7289,4 @@ declare function getRecordReferenceId(record: Pick<TableRecord, 'id' | '_idForCr
 
 declare const VERSION = "0.1.0";
 
-export { type AggregateChartConfig, AggregateType, ArchiveFormat, ArgumentError, ArgumentNullError, type AssociateRequest, AuthClient, type AuthOptionsResponse, type AuthenticatorSetupResponse, type BaseDataPoint, type CacheClearResult, type ChangeEmailRequest, type ChangeEmailResponse, ChangeEmailResult, type ChangePasswordRequest, type ChangePasswordResponse, ChangePasswordResult, type ChartAggregation, type ChartData, type ChartDataRequest, type ChartDataResponse, type ChartDataset, ChartDateGrouping, type ChartGrouping, type ChartLinkedEntity, type ColumnSort, ColumnType, type ConfirmEmailRequest, type ConfirmEmailResponse, type ConfirmExternalLoginRequest, type ConfirmExternalLoginResponse, ConfirmExternalLoginResult, type CreateRequest, type CreateResponse, type Currency, type CurrentLoginInfo, type CurrentUserInfo, type DataPoint, type DataverseDataPoint, DateTimeBehavior, type DeletePersonalDataRequest, type DeletePersonalDataResponse, DeletePersonalDataResult, type DeleteRequest, type DeleteResponse, type Disable2faResponse, type DisassociateRequest, EntityRole, ExternalLoginCandidateKind, type ExternalLoginProviderInfo, type ExternalLoginsResponse, FileArchiveResponseFormat, type FileInfo, type Forget2faResponse, type GridDataRequest, type GridDataResponse, type GridFilterBase, InvalidOperationError, JoinOperator, type LocalizationFileDownload, type LocalizationOverview, type LocalizationPipelineConfiguration, type LocalizationSourceKind, type LocalizationSourceLoad, type LocalizationSourceStatus, type LoginRequest, type LoginResponse, LoginResult, type MergedLocalizationEntry, type OrganizationRequest, type OrganizationResponse, type OrganizationSettings, type PendingExternalLoginResponse, type PersonalDataResponse, PortalUserType, PowerPortalsProClient, PowerPortalsProError, type PowerPortalsProErrorInit, type ProblemDetails, type ProfileResponse, type RecoveryCodesResponse, type RegisterRequest, type RegisterResponse, RegisterResult, type RelationshipFilter, RelationshipFilterMode, type RemoveExternalLoginRequest, type RemoveExternalLoginResponse, type RequestOptions, type RequestPasswordResetRequest, RequiredLevel, type ResendEmailConfirmationRequest, type ResetAuthenticatorResponse, type ResetPasswordRequest, type ResetPasswordResponse, ResetPasswordResult, type ResolvedColumn, type RetrieveRecordsResponse, Routes, type SelectExternalLoginRequest, type SendEmailConfirmationResponse, type SetPasswordRequest, type SetPasswordResponse, type SwitchIdentityResponse, SwitchIdentityResult, type TableMetadata, type TableRecord$1 as TableRecord, type TableRecordReference, TableSecurityPermission, type TranslatedFile, type TranslationAvailability, type TranslationLanguageOption, type TranslationRequest, type TranslationResult, Transport, type TransportOptions, type TwoFactorStatusResponse, UnauthorizedAccessError, type UpdateProfileRequest, type UpdateRequest, type UpdateResponse, VERSION, type VerifyAuthenticatorRequest, type VerifyAuthenticatorResponse, type VerifyTwoFactorRequest, type VerifyTwoFactorResponse, type ViewMetadata, ViewType, type components, getRecordReferenceId, mapProblemDetails, type paths };
+export { type AggregateChartConfig, AggregateType, ArchiveFormat, ArgumentError, ArgumentNullError, type AssociateRequest, AuthClient, type AuthOptionsResponse, type AuthenticatorSetupResponse, type BaseDataPoint, type CacheClearResult, type ChangeEmailRequest, type ChangeEmailResponse, ChangeEmailResult, type ChangePasswordRequest, type ChangePasswordResponse, ChangePasswordResult, type ChartAggregation, type ChartData, type ChartDataRequest, type ChartDataResponse, type ChartDataset, ChartDateGrouping, type ChartGrouping, type ChartLinkedEntity, ColumnSecurityPermission, type ColumnSort, ColumnType, type ConfirmEmailRequest, type ConfirmEmailResponse, type ConfirmExternalLoginRequest, type ConfirmExternalLoginResponse, ConfirmExternalLoginResult, type CreateRequest, type CreateResponse, type Currency, type CurrentLoginInfo, type CurrentUserInfo, type DataPoint, type DataverseDataPoint, DateTimeBehavior, type DeletePersonalDataRequest, type DeletePersonalDataResponse, DeletePersonalDataResult, type DeleteRequest, type DeleteResponse, type Disable2faResponse, type DisassociateRequest, EntityRole, ExternalLoginCandidateKind, type ExternalLoginProviderInfo, type ExternalLoginsResponse, FileArchiveResponseFormat, type FileInfo, type Forget2faResponse, type GridDataRequest, type GridDataResponse, type GridFilterBase, type ImpersonateRequest, type ImpersonateResponse, ImpersonateResult, type ImpersonationCandidate, type ImpersonationSearchRequest, type ImpersonationSearchResponse, InvalidOperationError, JoinOperator, type LocalizationFileDownload, type LocalizationOverview, type LocalizationPipelineConfiguration, type LocalizationSourceKind, type LocalizationSourceLoad, type LocalizationSourceStatus, type LoginRequest, type LoginResponse, LoginResult, type MergedLocalizationEntry, type OrganizationRequest, type OrganizationResponse, type OrganizationSettings, type PendingExternalLoginResponse, type PersonalDataResponse, PortalUserType, PowerPortalsProClient, PowerPortalsProError, type PowerPortalsProErrorInit, type ProblemDetails, type ProfileResponse, type RecoveryCodesResponse, type RegisterRequest, type RegisterResponse, RegisterResult, type RelationshipFilter, RelationshipFilterMode, type RemoveExternalLoginRequest, type RemoveExternalLoginResponse, type RequestOptions, type RequestPasswordResetRequest, RequiredLevel, type ResendEmailConfirmationRequest, type ResetAuthenticatorResponse, type ResetPasswordRequest, type ResetPasswordResponse, ResetPasswordResult, type ResolvedColumn, type RetrieveRecordsResponse, Routes, type SelectExternalLoginRequest, type SendEmailConfirmationResponse, type SetPasswordRequest, type SetPasswordResponse, type StopImpersonationResponse, StopImpersonationResult, type SwitchIdentityResponse, SwitchIdentityResult, type TableMetadata, type TableRecord$2 as TableRecord, type TableRecordReference, TableSecurityPermission, type TranslatedFile, type TranslationAvailability, type TranslationLanguageOption, type TranslationRequest, type TranslationResult, Transport, type TransportOptions, type TwoFactorStatusResponse, UnauthorizedAccessError, type UpdateProfileRequest, type UpdateRequest, type UpdateResponse, VERSION, type VerifyAuthenticatorRequest, type VerifyAuthenticatorResponse, type VerifyTwoFactorRequest, type VerifyTwoFactorResponse, type ViewMetadata, ViewType, canReadColumn, canWriteColumn, type components, getColumnPermissions, getRecordReferenceId, mapProblemDetails, type paths };