@byline/admin 3.17.1 → 3.19.0

package/dist/fields/file/file-field.js

@@ -25,7 +25,7 @@ const FileField = ({ field, collectionPath, value, defaultValue, onChange: _onCh
     const isDirty = useIsDirty(fieldPath);
     const fieldValue = useFieldValue(fieldPath);
     const isUploading = useIsFieldUploading(fieldPath);
-    const { removePendingUpload } = useFormContext();
+    const { removePendingUpload, documentId } = useFormContext();
     const handleChange = useFieldChangeHandler(field, fieldPath);
     const incomingValue = isDirty ? fieldValue ?? null : value ?? fieldValue ?? defaultValue ?? null;
     const isPending = isPendingStoredFileValue(incomingValue);
@@ -35,6 +35,7 @@ const FileField = ({ field, collectionPath, value, defaultValue, onChange: _onCh
         return 'placeholder' === maybe.storageProvider && 'pending' === maybe.storagePath;
     };
     const showUploadWidget = null == incomingValue || isOldPlaceholder(incomingValue);
+    const uploadGated = field.upload?.requireSavedDocument === true && null == documentId;
     const handleRemove = ()=>{
         if (isPending) removePendingUpload(fieldPath);
         handleChange(null);
@@ -54,7 +55,12 @@ const FileField = ({ field, collectionPath, value, defaultValue, onChange: _onCh
                     required: !field.optional
                 })
             }),
-            showUploadWidget ? collectionPath ? /*#__PURE__*/ jsx(FileUploadField, {
+            showUploadWidget ? uploadGated ? /*#__PURE__*/ jsx("div", {
+                className: classnames('byline-field-file-empty', file_field_module.empty),
+                role: "note",
+                "data-testid": "upload-require-saved-document",
+                children: t('fields.upload.requireSavedDocument')
+            }) : collectionPath ? /*#__PURE__*/ jsx(FileUploadField, {
                 field: field,
                 collectionPath: collectionPath,
                 fieldPath: fieldPath,

package/dist/fields/image/image-field.js

@@ -14,7 +14,7 @@ const ImageField = ({ field, collectionPath, value, defaultValue, onChange: _onC
     const isDirty = useIsDirty(fieldPath);
     const fieldValue = useFieldValue(fieldPath);
     const isUploading = useIsFieldUploading(fieldPath);
-    const { removePendingUpload } = useFormContext();
+    const { removePendingUpload, documentId } = useFormContext();
     const { t } = useTranslation('byline-admin');
     const handleChange = useFieldChangeHandler(field, fieldPath);
     const incomingValue = isDirty ? fieldValue ?? null : value ?? fieldValue ?? defaultValue ?? null;
@@ -25,6 +25,7 @@ const ImageField = ({ field, collectionPath, value, defaultValue, onChange: _onC
         return 'placeholder' === maybe.storageProvider && 'pending' === maybe.storagePath;
     };
     const showUploadWidget = null == incomingValue || isOldPlaceholder(incomingValue);
+    const uploadGated = field.upload?.requireSavedDocument === true && null == documentId;
     const thumbVariant = incomingValue && !isPendingStoredFileValue(incomingValue) ? incomingValue.variants?.find((v)=>'thumbnail' === v.name) : void 0;
     const previewUrl = thumbVariant?.storageUrl ?? incomingValue?.storageUrl;
     const handleRemove = ()=>{
@@ -46,7 +47,12 @@ const ImageField = ({ field, collectionPath, value, defaultValue, onChange: _onC
                     required: !field.optional
                 })
             }),
-            showUploadWidget ? collectionPath ? /*#__PURE__*/ jsx(ImageUploadField, {
+            showUploadWidget ? uploadGated ? /*#__PURE__*/ jsx("div", {
+                className: classnames('byline-field-image-empty', image_field_module.empty),
+                role: "note",
+                "data-testid": "upload-require-saved-document",
+                children: t('fields.upload.requireSavedDocument')
+            }) : collectionPath ? /*#__PURE__*/ jsx(ImageUploadField, {
                 field: field,
                 collectionPath: collectionPath,
                 fieldPath: fieldPath,

package/dist/forms/form-context.d.ts

@@ -48,6 +48,13 @@ export interface DirtyBreakdown {
     availableLocalesDirty: boolean;
 }
 interface FormContextType {
+    /**
+     * The persisted document id when the form edits an existing document,
+     * `null` while the document is unsaved (create mode). Upload widgets use
+     * this to honour `upload.requireSavedDocument` (see `UploadConfig` in
+     * `@byline/core`).
+     */
+    documentId: string | null;
     setFieldValue: (name: string, value: any) => void;
     setFieldStore: (name: string, value: any) => void;
     getFieldValue: (name: string) => any;
@@ -90,9 +97,14 @@ interface FormContextType {
     subscribeSystemAvailableLocales: (listener: SystemAvailableLocalesListener) => () => void;
 }
 export declare const useFormContext: () => FormContextType;
-export declare const FormProvider: ({ children, initialData, }: {
+export declare const FormProvider: ({ children, initialData, documentId, }: {
     children: React.ReactNode;
     initialData?: Record<string, any>;
+    /**
+     * The persisted document id (edit mode); `null` while unsaved. Exposed on
+     * the context for upload widgets honouring `upload.requireSavedDocument`.
+     */
+    documentId?: string | null;
 }) => React.JSX.Element;
 /**
  * Subscribe to the system `path` slot edited by the path widget.

package/dist/forms/form-context.js

@@ -22,7 +22,7 @@ const useFormContext = ()=>{
     if (null == context) throw new Error('useFormContext must be used within a FormProvider');
     return context;
 };
-const FormProvider = ({ children, initialData = {} })=>{
+const FormProvider = ({ children, initialData = {}, documentId = null })=>{
     const fieldValues = useRef(JSON.parse(JSON.stringify(initialData?.fields ?? initialData)));
     const initialValues = useRef(initialData?.fields ?? initialData);
     const errorsRef = useRef([]);
@@ -376,6 +376,7 @@ const FormProvider = ({ children, initialData = {} })=>{
     ]);
     return /*#__PURE__*/ jsx(FormContext.Provider, {
         value: {
+            documentId,
             setFieldValue,
             setFieldStore,
             getFieldValue,

package/dist/forms/form-renderer.js

@@ -1,6 +1,7 @@
 "use client";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { getClientConfig } from "@byline/core";
 import { useTranslation } from "@byline/i18n/react";
 import { Alert, Button, ComboButton } from "@byline/ui/react";
 import classnames from "classnames";
@@ -32,6 +33,15 @@ const FormContent = ({ mode, fields, onSubmit, onCancel, onStatusChange, onUnpub
     const [pendingSystemFieldsSubmit, setPendingSystemFieldsSubmit] = useState(null);
     const [contentLocale, setContentLocale] = useState(initialLocale ?? defaultLocale);
     const { uploadField } = useBylineFieldServices();
+    const pathSlugifier = getClientConfig().slugifier;
+    const pathSourceLocked = useMemo(()=>{
+        if (!useAsPath) return false;
+        const source = fields.find((f)=>f.name === useAsPath);
+        return null != source && ('counter' === source.type || true === source.readOnly);
+    }, [
+        useAsPath,
+        fields
+    ]);
     useEffect(()=>{
         if (initialLocale) setContentLocale(initialLocale);
     }, [
@@ -112,6 +122,10 @@ const FormContent = ({ mode, fields, onSubmit, onCancel, onStatusChange, onUnpub
                 try {
                     const uploadResult = await executeUploadsWithProgress(pendingUploads, uploadField, ({ fieldPath, status })=>{
                         setFieldUploading(fieldPath, 'uploading' === status);
+                    }, {
+                        documentId: 'edit' === mode && 'string' == typeof initialData?.id ? initialData.id : void 0,
+                        fields,
+                        getFormValues: getFieldValues
                     });
                     if (!uploadResult.allSucceeded) {
                         for (const [fieldPath, errorMessage] of uploadResult.errors.entries())setFieldError(fieldPath, t('forms.uploadFailedFieldError', {
@@ -345,7 +359,9 @@ const FormContent = ({ mode, fields, onSubmit, onCancel, onStatusChange, onUnpub
                                 collectionPath: collectionPath ?? '',
                                 defaultLocale: defaultLocale,
                                 activeLocale: contentLocale,
-                                mode: mode
+                                mode: mode,
+                                slugifier: pathSlugifier,
+                                sourceLocked: pathSourceLocked
                             }),
                             tree && 'edit' === mode && 'string' == typeof initialData?.id && /*#__PURE__*/ jsx(TreePlacementWidget, {
                                 collectionPath: collectionPath ?? '',
@@ -386,6 +402,7 @@ const FormRenderer = ({ mode, fields, onSubmit, onCancel, onStatusChange, onUnpu
     const savedTabsRef = useRef({});
     return /*#__PURE__*/ jsx(FormProvider, {
         initialData: initialData,
+        documentId: 'edit' === mode && 'string' == typeof initialData?.id ? initialData.id : null,
         children: /*#__PURE__*/ jsx(FormContent, {
             mode: mode,
             fields: fields,

package/dist/forms/path-widget.d.ts

@@ -1,3 +1,4 @@
+import type { SlugifierFn } from '@byline/core';
 export interface PathWidgetProps {
     /** The collection's `useAsPath` source field name, when configured. */
     useAsPath: string | undefined;
@@ -16,6 +17,23 @@ export interface PathWidgetProps {
     activeLocale: string;
     /** `'create'` shows the live derived preview as placeholder text. */
     mode: 'create' | 'edit';
+    /**
+     * Installation slugifier used to derive the live preview. Must match the
+     * server-side `ServerConfig.slugifier` so the preview agrees with what is
+     * persisted. Defaults to the built-in `slugify` when omitted — callers
+     * that keep the default slugifier need not pass this.
+     */
+    slugifier?: SlugifierFn;
+    /**
+     * When `true`, the `useAsPath` source field's value is not editable through
+     * this form (e.g. it is an allocator-assigned `counter`, or an otherwise
+     * read-only field). Its value is either server-assigned — and so not
+     * reproducible client-side — or simply cannot change, which means the
+     * source-derived live preview and the "Regenerate" affordance are
+     * meaningless. When set, the widget suppresses both and just shows the
+     * persisted path. Defaults to `false`.
+     */
+    sourceLocked?: boolean;
 }
 /**
  * System-managed `path` widget.
@@ -33,4 +51,4 @@ export interface PathWidgetProps {
  * Stable override handles: `.byline-form-path`, `.byline-form-path-header`,
  * `.byline-form-path-regenerate`.
  */
-export declare const PathWidget: ({ useAsPath, collectionPath, defaultLocale, activeLocale, mode, }: PathWidgetProps) => import("react").JSX.Element;
+export declare const PathWidget: ({ useAsPath, collectionPath, defaultLocale, activeLocale, mode, slugifier, sourceLocked, }: PathWidgetProps) => import("react").JSX.Element;

package/dist/forms/path-widget.js

@@ -12,25 +12,28 @@ function coerceToString(value) {
     if (value instanceof Date) return value.toISOString();
     return String(value);
 }
-const PathWidget = ({ useAsPath, collectionPath, defaultLocale, activeLocale, mode })=>{
+const PathWidget = ({ useAsPath, collectionPath, defaultLocale, activeLocale, mode, slugifier, sourceLocked = false })=>{
     const { setSystemPath } = useFormContext();
     const { t } = useTranslation('byline-admin');
     const systemPath = useSystemPath();
     const sourceValue = useFieldValue(useAsPath ?? '');
+    const runSlugify = slugifier ?? slugify;
     const isReadOnly = activeLocale !== defaultLocale;
     const livePreview = useMemo(()=>{
-        if (!useAsPath) return '';
+        if (!useAsPath || sourceLocked) return '';
         const asString = coerceToString(sourceValue);
         if (0 === asString.length) return '';
-        return slugify(asString, {
+        return runSlugify(asString, {
             locale: defaultLocale,
             collectionPath
         });
     }, [
         useAsPath,
+        sourceLocked,
         sourceValue,
         defaultLocale,
-        collectionPath
+        collectionPath,
+        runSlugify
     ]);
     const inputValue = systemPath ?? '';
     const handleChange = useCallback((next)=>{
@@ -46,14 +49,15 @@ const PathWidget = ({ useAsPath, collectionPath, defaultLocale, activeLocale, mo
     ]);
     const formatted = useMemo(()=>{
         if (0 === inputValue.length) return '';
-        return slugify(inputValue, {
+        return runSlugify(inputValue, {
             locale: defaultLocale,
             collectionPath
         });
     }, [
         inputValue,
         defaultLocale,
-        collectionPath
+        collectionPath,
+        runSlugify
     ]);
     const validationHint = inputValue.length > 0 && formatted !== inputValue ? t('pathWidget.suggestedHint', {
         formatted

package/dist/forms/upload-executor.d.ts

@@ -12,7 +12,7 @@
  * This enables "deferred uploads" — files are selected/previewed immediately
  * but only uploaded when the user clicks Save.
  */
-import type { StoredFileValue } from '@byline/core';
+import type { Field, StoredFileValue } from '@byline/core';
 import type { UploadFieldFn } from '../fields/field-services-types';
 import type { PendingUpload } from './form-context';
 export interface UploadResult {
@@ -31,6 +31,28 @@ export interface ExecuteUploadsResult {
     /** Whether all uploads succeeded */
     allSucceeded: boolean;
 }
+/**
+ * Optional document context threaded from the form renderer so upload
+ * requests carry the state that server-side `beforeStore` / `afterStore`
+ * hooks need (see `UploadConfig.context` in `@byline/core`).
+ */
+export interface UploadExecutionContext {
+    /**
+     * The persisted document id (edit mode). Posted as `documentId` on every
+     * upload request; omitted while the document is unsaved (create mode).
+     */
+    documentId?: string;
+    /**
+     * The collection's schema fields — used to locate each upload field's
+     * `upload.context` declaration by walking the pending upload's field path.
+     */
+    fields?: readonly Field[];
+    /**
+     * Snapshot accessor for the live form values, resolved lazily per upload
+     * so context reflects the state at the moment the request is built.
+     */
+    getFormValues?: () => Record<string, any>;
+}
 /**
  * Execute all pending uploads sequentially.
  * Returns a result object with successful uploads and any errors.
@@ -38,9 +60,11 @@ export interface ExecuteUploadsResult {
  * @param pendingUploads - Map of field path to PendingUpload
  * @param uploadField - Host-provided upload transport (resolved via
  *                         `useBylineFieldServices()` in the calling React tree)
+ * @param executionContext - Optional document/form context appended to each
+ *                         upload request (documentId, `upload.context` values)
  * @returns Promise resolving to ExecuteUploadsResult
  */
-export declare function executeUploads(pendingUploads: Map<string, PendingUpload>, uploadField: UploadFieldFn): Promise<ExecuteUploadsResult>;
+export declare function executeUploads(pendingUploads: Map<string, PendingUpload>, uploadField: UploadFieldFn, executionContext?: UploadExecutionContext): Promise<ExecuteUploadsResult>;
 /**
  * Progress callback type for upload execution with progress tracking.
  */
@@ -54,4 +78,4 @@ export type UploadProgressCallback = (info: {
  * Execute uploads with progress callbacks.
  * Useful for showing upload progress in the UI.
  */
-export declare function executeUploadsWithProgress(pendingUploads: Map<string, PendingUpload>, uploadField: UploadFieldFn, onProgress?: UploadProgressCallback): Promise<ExecuteUploadsResult>;
+export declare function executeUploadsWithProgress(pendingUploads: Map<string, PendingUpload>, uploadField: UploadFieldFn, onProgress?: UploadProgressCallback, executionContext?: UploadExecutionContext): Promise<ExecuteUploadsResult>;

package/dist/forms/upload-executor.js

@@ -1,11 +1,10 @@
-async function executeUploads(pendingUploads, uploadField) {
+import { get } from "./nested-path.js";
+async function executeUploads(pendingUploads, uploadField, executionContext) {
     const results = [];
     const successful = new Map();
     const errors = new Map();
     for (const [fieldPath, upload] of pendingUploads.entries()){
-        const formData = new FormData();
-        formData.append('file', upload.file);
-        formData.append('field', uploadFieldName(fieldPath));
+        const formData = buildUploadFormData(fieldPath, upload, executionContext);
         try {
             const result = await uploadField(upload.collectionPath, formData, false);
             results.push({
@@ -31,11 +30,89 @@ async function executeUploads(pendingUploads, uploadField) {
         allSucceeded: 0 === errors.size
     };
 }
+function buildUploadFormData(fieldPath, upload, executionContext) {
+    const formData = new FormData();
+    formData.append('file', upload.file);
+    formData.append('field', uploadFieldName(fieldPath));
+    formData.append('fieldPath', fieldPath);
+    if (executionContext?.documentId) formData.append('documentId', executionContext.documentId);
+    const contextPaths = executionContext?.fields != null ? findUploadFieldByPath(executionContext.fields, fieldPath)?.context : void 0;
+    if (contextPaths && contextPaths.length > 0 && executionContext?.getFormValues) {
+        const formValues = executionContext.getFormValues();
+        for (const contextPath of contextPaths){
+            const resolvedPath = resolveContextPath(fieldPath, contextPath);
+            if (void 0 === resolvedPath) continue;
+            const value = '' === resolvedPath ? formValues : get(formValues, resolvedPath);
+            const serialized = serializeContextValue(value);
+            if (void 0 !== serialized) formData.append(leafName(contextPath), serialized);
+        }
+    }
+    return formData;
+}
 function uploadFieldName(fieldPath) {
     const dot = fieldPath.lastIndexOf('.');
     return -1 === dot ? fieldPath : fieldPath.slice(dot + 1);
 }
-async function executeUploadsWithProgress(pendingUploads, uploadField, onProgress) {
+function leafName(contextPath) {
+    const segments = contextPath.split('/').pop() ?? contextPath;
+    const dot = segments.lastIndexOf('.');
+    return -1 === dot ? segments : segments.slice(dot + 1);
+}
+function resolveContextPath(fieldPath, contextPath) {
+    if (contextPath.startsWith('/')) return contextPath.slice(1);
+    const scope = fieldPath.split('.');
+    scope.pop();
+    const parts = contextPath.split('/');
+    const leaf = parts.pop() ?? '';
+    for (const part of parts)if ('.' !== part && '' !== part) {
+        if ('..' === part) {
+            if (0 === scope.length) return;
+            scope.pop();
+            continue;
+        }
+        scope.push(part);
+    }
+    return 0 === scope.length ? leaf : `${scope.join('.')}${leaf ? `.${leaf}` : ''}`;
+}
+function serializeContextValue(value) {
+    if (null == value) return;
+    if ('string' == typeof value) return value;
+    if ('number' == typeof value || 'boolean' == typeof value) return String(value);
+    if (isRelationEnvelope(value)) return value.targetDocumentId;
+    if (Array.isArray(value) && value.length > 0 && value.every(isRelationEnvelope)) return value.map((v)=>v.targetDocumentId).join(',');
+    try {
+        return JSON.stringify(value);
+    } catch  {
+        return;
+    }
+}
+function isRelationEnvelope(value) {
+    return 'object' == typeof value && null !== value && 'string' == typeof value.targetDocumentId;
+}
+function findUploadFieldByPath(fields, fieldPath) {
+    const segments = fieldPath.split('.').map((s)=>s.replace(/\[\d+\]$/, ''));
+    let currentFields = fields;
+    for(let i = 0; i < segments.length; i++){
+        const name = segments[i];
+        const isLeaf = i === segments.length - 1;
+        const field = currentFields.find((f)=>f.name === name);
+        if (!field) break;
+        if (isLeaf) return 'image' === field.type || 'file' === field.type ? field.upload : void 0;
+        if ('group' === field.type || 'array' === field.type) {
+            currentFields = field.fields;
+            continue;
+        }
+        if ('blocks' === field.type) {
+            const remaining = segments[i + 1];
+            const block = field.blocks.find((b)=>b.fields.some((f)=>f.name === remaining));
+            if (!block) return;
+            currentFields = block.fields;
+            continue;
+        }
+        break;
+    }
+}
+async function executeUploadsWithProgress(pendingUploads, uploadField, onProgress, executionContext) {
     const results = [];
     const successful = new Map();
     const errors = new Map();
@@ -51,9 +128,7 @@ async function executeUploadsWithProgress(pendingUploads, uploadField, onProgres
             fieldPath,
             status: 'uploading'
         });
-        const formData = new FormData();
-        formData.append('file', upload.file);
-        formData.append('field', uploadFieldName(fieldPath));
+        const formData = buildUploadFormData(fieldPath, upload, executionContext);
         try {
             const result = await uploadField(upload.collectionPath, formData, false);
             results.push({

package/dist/forms/upload-executor.test.node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/modules/admin-account/errors.d.ts

@@ -20,8 +20,8 @@
  * code per condition.
  */
 export declare const AdminAccountErrorCodes: {
-    readonly NOT_FOUND: "admin.account.notFound";
-    readonly INVALID_CURRENT_PASSWORD: "admin.account.invalidCurrentPassword";
+    readonly NOT_FOUND: 'admin.account.notFound';
+    readonly INVALID_CURRENT_PASSWORD: 'admin.account.invalidCurrentPassword';
 };
 export type AdminAccountErrorCode = (typeof AdminAccountErrorCodes)[keyof typeof AdminAccountErrorCodes];
 export interface AdminAccountErrorOptions {

package/dist/modules/admin-activity/abilities.d.ts

@@ -20,7 +20,7 @@ import type { AbilityRegistry } from '@byline/auth';
  * append-only and is written by the lifecycle write-points, never edited.
  */
 export declare const ADMIN_ACTIVITY_ABILITIES: {
-    readonly read: "admin.activity.read";
+    readonly read: 'admin.activity.read';
 };
 export type AdminActivityAbilityKey = (typeof ADMIN_ACTIVITY_ABILITIES)[keyof typeof ADMIN_ACTIVITY_ABILITIES];
 /**

package/dist/modules/admin-permissions/abilities.d.ts

@@ -19,8 +19,8 @@ import type { AbilityRegistry } from '@byline/auth';
  * every permission-managing role.
  */
 export declare const ADMIN_PERMISSIONS_ABILITIES: {
-    readonly read: "admin.permissions.read";
-    readonly update: "admin.permissions.update";
+    readonly read: 'admin.permissions.read';
+    readonly update: 'admin.permissions.update';
 };
 export type AdminPermissionsAbilityKey = (typeof ADMIN_PERMISSIONS_ABILITIES)[keyof typeof ADMIN_PERMISSIONS_ABILITIES];
 export declare function registerAdminPermissionsAbilities(registry: AbilityRegistry): void;

package/dist/modules/admin-permissions/errors.d.ts

@@ -14,8 +14,8 @@
  * inspector is read-only and never throws either of these.
  */
 export declare const AdminPermissionsErrorCodes: {
-    readonly ROLE_NOT_FOUND: "admin.permissions.roleNotFound";
-    readonly ABILITY_UNREGISTERED: "admin.permissions.abilityUnregistered";
+    readonly ROLE_NOT_FOUND: 'admin.permissions.roleNotFound';
+    readonly ABILITY_UNREGISTERED: 'admin.permissions.abilityUnregistered';
 };
 export type AdminPermissionsErrorCode = (typeof AdminPermissionsErrorCodes)[keyof typeof AdminPermissionsErrorCodes];
 export interface AdminPermissionsErrorOptions {

package/dist/modules/admin-permissions/schemas.d.ts

@@ -29,8 +29,8 @@ export declare const abilityDescriptorResponseSchema: z.ZodObject<{
     source: z.ZodNullable<z.ZodEnum<{
         admin: "admin";
         collection: "collection";
-        plugin: "plugin";
         core: "core";
+        plugin: "plugin";
     }>>;
 }, z.core.$strip>;
 export type AbilityDescriptorResponse = z.infer<typeof abilityDescriptorResponseSchema>;
@@ -44,8 +44,8 @@ export declare const abilityGroupResponseSchema: z.ZodObject<{
         source: z.ZodNullable<z.ZodEnum<{
             admin: "admin";
             collection: "collection";
-            plugin: "plugin";
             core: "core";
+            plugin: "plugin";
         }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -63,8 +63,8 @@ export declare const listRegisteredAbilitiesResponseSchema: z.ZodObject<{
         source: z.ZodNullable<z.ZodEnum<{
             admin: "admin";
             collection: "collection";
-            plugin: "plugin";
             core: "core";
+            plugin: "plugin";
         }>>;
     }, z.core.$strip>>;
     groups: z.ZodArray<z.ZodObject<{
@@ -77,8 +77,8 @@ export declare const listRegisteredAbilitiesResponseSchema: z.ZodObject<{
             source: z.ZodNullable<z.ZodEnum<{
                 admin: "admin";
                 collection: "collection";
-                plugin: "plugin";
                 core: "core";
+                plugin: "plugin";
             }>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;

package/dist/modules/admin-roles/abilities.d.ts

@@ -18,10 +18,10 @@ import type { AbilityRegistry } from '@byline/auth';
  * keys there.
  */
 export declare const ADMIN_ROLES_ABILITIES: {
-    readonly read: "admin.roles.read";
-    readonly create: "admin.roles.create";
-    readonly update: "admin.roles.update";
-    readonly delete: "admin.roles.delete";
+    readonly read: 'admin.roles.read';
+    readonly create: 'admin.roles.create';
+    readonly update: 'admin.roles.update';
+    readonly delete: 'admin.roles.delete';
 };
 export type AdminRolesAbilityKey = (typeof ADMIN_ROLES_ABILITIES)[keyof typeof ADMIN_ROLES_ABILITIES];
 /**

package/dist/modules/admin-roles/errors.d.ts

@@ -13,10 +13,10 @@
  * ability keys in logs and admin UI messages.
  */
 export declare const AdminRolesErrorCodes: {
-    readonly NOT_FOUND: "admin.roles.notFound";
-    readonly MACHINE_NAME_IN_USE: "admin.roles.machineNameInUse";
-    readonly VERSION_CONFLICT: "admin.roles.versionConflict";
-    readonly USER_NOT_FOUND: "admin.roles.userNotFound";
+    readonly NOT_FOUND: 'admin.roles.notFound';
+    readonly MACHINE_NAME_IN_USE: 'admin.roles.machineNameInUse';
+    readonly VERSION_CONFLICT: 'admin.roles.versionConflict';
+    readonly USER_NOT_FOUND: 'admin.roles.userNotFound';
 };
 export type AdminRolesErrorCode = (typeof AdminRolesErrorCodes)[keyof typeof AdminRolesErrorCodes];
 export interface AdminRolesErrorOptions {

package/dist/modules/admin-users/abilities.d.ts

@@ -25,11 +25,11 @@ import type { AbilityRegistry } from '@byline/auth';
  * are strictly for administering other admin users.
  */
 export declare const ADMIN_USERS_ABILITIES: {
-    readonly read: "admin.users.read";
-    readonly create: "admin.users.create";
-    readonly update: "admin.users.update";
-    readonly delete: "admin.users.delete";
-    readonly changePassword: "admin.users.changePassword";
+    readonly read: 'admin.users.read';
+    readonly create: 'admin.users.create';
+    readonly update: 'admin.users.update';
+    readonly delete: 'admin.users.delete';
+    readonly changePassword: 'admin.users.changePassword';
 };
 export type AdminUsersAbilityKey = (typeof ADMIN_USERS_ABILITIES)[keyof typeof ADMIN_USERS_ABILITIES];
 /**

package/dist/modules/admin-users/errors.d.ts

@@ -18,11 +18,11 @@
  * alongside the matching ability keys in logs and admin UI messages.
  */
 export declare const AdminUsersErrorCodes: {
-    readonly NOT_FOUND: "admin.users.notFound";
-    readonly EMAIL_IN_USE: "admin.users.emailInUse";
-    readonly SELF_DELETE_FORBIDDEN: "admin.users.selfDeleteForbidden";
-    readonly SELF_DISABLE_FORBIDDEN: "admin.users.selfDisableForbidden";
-    readonly VERSION_CONFLICT: "admin.users.versionConflict";
+    readonly NOT_FOUND: 'admin.users.notFound';
+    readonly EMAIL_IN_USE: 'admin.users.emailInUse';
+    readonly SELF_DELETE_FORBIDDEN: 'admin.users.selfDeleteForbidden';
+    readonly SELF_DISABLE_FORBIDDEN: 'admin.users.selfDisableForbidden';
+    readonly VERSION_CONFLICT: 'admin.users.versionConflict';
 };
 export type AdminUsersErrorCode = (typeof AdminUsersErrorCodes)[keyof typeof AdminUsersErrorCodes];
 export interface AdminUsersErrorOptions {

package/dist/modules/admin-users/schemas.d.ts

@@ -11,12 +11,12 @@ export declare const listAdminUsersRequestSchema: z.ZodObject<{
     pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     query: z.ZodOptional<z.ZodString>;
     order: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        created_at: "created_at";
         email: "email";
-        given_name: "given_name";
         family_name: "family_name";
-        username: "username";
-        created_at: "created_at";
+        given_name: "given_name";
         updated_at: "updated_at";
+        username: "username";
     }>>>;
     desc: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strip>;
@@ -121,12 +121,12 @@ export declare const adminUserListResponseSchema: z.ZodObject<{
         page_size: z.ZodNumber;
         query: z.ZodString;
         order: z.ZodEnum<{
+            created_at: "created_at";
             email: "email";
-            given_name: "given_name";
             family_name: "family_name";
-            username: "username";
-            created_at: "created_at";
+            given_name: "given_name";
             updated_at: "updated_at";
+            username: "username";
         }>;
         desc: z.ZodBoolean;
     }, z.core.$strip>;