@dignite/ng.site 0.0.0-stage → 1.0.1

package/types/dignite-ng.site.d.ts

@@ -0,0 +1,1409 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, AfterContentInit, EventEmitter, ElementRef, SimpleChanges, PipeTransform, OnDestroy } from '@angular/core';
+import { FieldTypeConfigBase, FieldTypeControlBase, FieldTypeDefinition, FlexFieldValue } from '@dignite/ng.flex-fields';
+import * as _abp_ng_core from '@abp/ng.core';
+import { FullAuditedEntityDto, ExtensibleAuditedEntityDto, ExtensibleEntityDto, CreationAuditedEntityDto, PagedAndSortedResultRequestDto, Rest, ListResultDto, PagedResultDto, LocalizationService, ListService } from '@abp/ng.core';
+import { AbstractControl, UntypedFormGroup, FormBuilder, FormGroup, FormArray } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { ConfirmationService, ToasterService } from '@abp/ng.theme.shared';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { CKEditorConfigContributor, CKEditorDisplayContributor, CKEditorUploadProvider } from '@dignite/ng.flex-fields-ckeditor';
+import { Routes } from '@angular/router';
+
+/**
+ * Mirrors `SiteAdminPermissions` (`src/Dignite.Site.Admin.Application.Contracts/Permissions/SiteAdminPermissions.cs`).
+ *
+ * Note the group name is the bare string `SiteAdmin`, not `Site.Admin` - these are the exact strings the
+ * server checks, so they cannot be prefixed further here.
+ */
+declare enum eSitePolicyNames {
+    Pages = "SiteAdmin.Pages",
+    PagesCreate = "SiteAdmin.Pages.Create",
+    PagesUpdate = "SiteAdmin.Pages.Update",
+    PagesDelete = "SiteAdmin.Pages.Delete",
+    ContentTypes = "SiteAdmin.ContentTypes",
+    ContentTypesCreate = "SiteAdmin.ContentTypes.Create",
+    ContentTypesUpdate = "SiteAdmin.ContentTypes.Update",
+    ContentTypesDelete = "SiteAdmin.ContentTypes.Delete",
+    Fields = "SiteAdmin.Fields",
+    FieldsCreate = "SiteAdmin.Fields.Create",
+    FieldsUpdate = "SiteAdmin.Fields.Update",
+    FieldsDelete = "SiteAdmin.Fields.Delete",
+    /** Separate from update on purpose: renaming a field migrates every stored value. */
+    FieldsRename = "SiteAdmin.Fields.Rename",
+    FieldGroups = "SiteAdmin.FieldGroups",
+    FieldGroupsCreate = "SiteAdmin.FieldGroups.Create",
+    FieldGroupsUpdate = "SiteAdmin.FieldGroups.Update",
+    FieldGroupsDelete = "SiteAdmin.FieldGroups.Delete",
+    Contents = "SiteAdmin.Contents",
+    ContentsCreate = "SiteAdmin.Contents.Create",
+    ContentsUpdate = "SiteAdmin.Contents.Update",
+    ContentsDelete = "SiteAdmin.Contents.Delete"
+}
+
+interface ContentTypeFieldDto {
+    fieldId?: string;
+    required?: boolean;
+    searchable?: boolean;
+    showInList?: boolean;
+    displayName?: string | null;
+    order?: number;
+}
+interface ContentTypeDto extends FullAuditedEntityDto<string> {
+    pageId?: string;
+    name?: string;
+    displayName?: string;
+    description?: string | null;
+    fields?: ContentTypeFieldDto[];
+}
+
+/** Designer-side editor for a `Content` field's configuration: which content type to restrict to (if
+ * any), single- vs. multi-select, and a placeholder. */
+declare class ContentConfigComponent extends FieldTypeConfigBase implements OnInit {
+    private readonly contentTypeAdminService;
+    contentTypes: ContentTypeDto[];
+    protected configurationDefaults(): object;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentConfigComponent, "site-content-config", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Configuration of a `Content` field, shaped for `FormBuilder.group()`. Mirrors `ContentConfiguration`
+ * (`src/Dignite.FlexFields.Site/Dignite/FlexFields/Site/Content/ContentConfiguration.cs`).
+ *
+ * The property names are the **stored** configuration keys, not a naming choice.
+ */
+declare class ContentConfiguration {
+    /** Restricts the picker to Content of this content type. `null` = unrestricted. */
+    'Content.ContentTypeId': unknown;
+    'Content.Multiple': unknown;
+    'Content.Placeholder': unknown;
+}
+
+declare enum ContentStatus {
+    Draft = 0,
+    Published = 1,
+    Archived = 2
+}
+declare const contentStatusOptions: _abp_ng_core.ABP.Option<typeof ContentStatus>[];
+
+interface ContentDto extends FullAuditedEntityDto<string> {
+    pageId?: string;
+    contentTypeId?: string;
+    cultureName?: string;
+    slug?: string;
+    publishTime?: string;
+    status?: ContentStatus;
+    url?: string;
+    fieldValues?: Record<string, object>;
+}
+
+/**
+ * Edits the value of a `Content` field: a picker over other Content, restricted to
+ * `Content.ContentTypeId` when set. The value is always a flat array of ids, even in single-select mode
+ * - matching the server's `ContentFieldType`, which always stores `List<Guid>`.
+ *
+ * The picker list is fetched once, in {@link ngOnInit} - `Content.ContentTypeId` is fixed for the
+ * lifetime of one rendered control (it belongs to the field's own definition, not something this
+ * component's own inputs can change), so there is nothing to react to afterward.
+ */
+declare class ContentControlComponent extends FieldTypeControlBase implements OnInit {
+    private readonly contentAdminService;
+    /**
+     * A signal, not a plain field: it is filled by an HTTP callback, and this control renders in the content
+     * editor's page flow, under the host layout's OnPush ancestors - a plain-field write there never marks
+     * them for check, so the options (and a stored selection) would stay blank until an unrelated event.
+     */
+    readonly options: i0.WritableSignal<ContentDto[]>;
+    get multiple(): boolean;
+    get placeholder(): string;
+    protected configurationDefaults(): object;
+    protected createControl(): AbstractControl;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentControlComponent, "site-content-control", never, {}, {}, never, never, true, never>;
+}
+
+/** The registration key. Must equal `ContentFieldType.ControlName` on the server. */
+declare const CONTENT_FIELD_TYPE_NAME = "Content";
+/**
+ * Site's 8th field type, alongside the six the flex-fields library ships and Site's own `Seo` (the
+ * 7th). The server registers `ContentFieldType` through DI automatically; the client has no equivalent
+ * discovery, so it is registered here and wired in through `provideSite()` (GitHub issue #49).
+ *
+ * Named "Content" rather than DynamicForms' own "Entry" - Site's domain has no "Entry" concept, only
+ * `Content`, so the field type is named after what it actually references.
+ *
+ * **No search component.** `ContentFieldType.IndexValueType` is `Guid` on the server (so a future
+ * filter UI is possible), but no `searchComponent` ships this round - same state CKEditor/the file field
+ * are currently in.
+ */
+declare const CONTENT_FIELD_TYPE: FieldTypeDefinition;
+
+/**
+ * Displays the value of a `Content` field read-only: the referenced Content, resolved by id. An id
+ * that no longer resolves (deleted since picked) is silently dropped rather than shown as an error -
+ * the same "fail open" stance the server's own `Content.cshtml` partial takes.
+ */
+declare class ContentViewComponent implements OnChanges {
+    private readonly contentAdminService;
+    showInList: boolean;
+    fields?: FlexFieldValue;
+    /** Registration key of the field type - always `Content` here. */
+    type?: string;
+    value: unknown;
+    /**
+     * A signal, not a plain field: it is filled by an HTTP callback, and this view renders in the content
+     * list's page flow, under the host layout's OnPush ancestors - a plain-field write there never marks
+     * them for check, so the cell would stay at `-` until an unrelated event.
+     */
+    readonly resolved: i0.WritableSignal<ContentDto[]>;
+    get summaryText(): string;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentViewComponent, "site-content-view", never, { "showInList": { "alias": "showInList"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Designer-side editor for a file field's configuration: which of Site's containers, one file or many. */
+declare class FileConfigComponent extends FieldTypeConfigBase {
+    readonly containerNames: readonly ["images", "attachments"];
+    readonly names: {
+        readonly fileContainerName: "FileExplorer.FileContainerName";
+        readonly uploadFileMultiple: "FileExplorer.UploadFileMultiple";
+    };
+    protected configurationDefaults(): object;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileConfigComponent, "site-file-config", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The configuration keys of the file field type. **Persisted data**: every field (and every Matrix
+ * block's nested configuration) stores them under these names, which date from when the field type was
+ * `Dignite.Abp.FlexFields`' - the same keys as the server's `FileFieldConfigurationNames`.
+ */
+declare const FILE_FIELD_CONFIGURATION_NAMES: {
+    readonly fileContainerName: "FileExplorer.FileContainerName";
+    readonly uploadFileMultiple: "FileExplorer.UploadFileMultiple";
+};
+/** Configuration of a file field, shaped for `FormBuilder.group()`. */
+declare class FileFieldConfiguration {
+    [FILE_FIELD_CONFIGURATION_NAMES.fileContainerName]: unknown;
+    [FILE_FIELD_CONFIGURATION_NAMES.uploadFileMultiple]: unknown;
+}
+
+/** Edits a file field's value: picks one or more files from Site's file library. */
+declare class FileControlComponent extends FieldTypeControlBase {
+    get multiple(): boolean;
+    get containerName(): string;
+    /** No fallback container: an unconfigured field is a misconfiguration to surface, not paper over. */
+    get isContainerConfigured(): boolean;
+    protected configurationDefaults(): object;
+    protected createControl(): AbstractControl;
+    onSelectedFileChange(files: unknown[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileControlComponent, "site-file-control", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The registration key. **Persisted data** (every field definition of this type, Matrix block
+ * configurations included) - unchanged from when the field type was `Dignite.Abp.FlexFields`'; must equal
+ * the server's `FileFieldType.ControlName`.
+ */
+declare const FILE_FIELD_TYPE_NAME = "FileExplorer";
+/**
+ * The file field type: picks one or more files from Site's file library. Registered by `provideSite()`
+ * like `Seo` and `Content` - the client has no equivalent of the server's DI discovery.
+ *
+ * **No search component.** `FileFieldType.IndexValueType` is null - the value is an array of file
+ * objects with no typed index column to project into.
+ */
+declare const FILE_FIELD_TYPE: FieldTypeDefinition;
+
+/** The part of a picked file the view reads - what the picker denormalized into the value. */
+interface FileFieldFileValue {
+    url?: string;
+    name?: string;
+    mimeType?: string;
+}
+/** Displays a file field's value read-only: the first file's preview, plus a count. */
+declare class FileViewComponent {
+    /** Renders bare, without the label wrapper, for use inside a table cell. */
+    showInList: boolean;
+    fields?: FlexFieldValue;
+    /** Registration key of the field type (`FileExplorer`). */
+    type?: string;
+    value: unknown;
+    get files(): FileFieldFileValue[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileViewComponent, "site-file-view", never, { "showInList": { "alias": "showInList"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Designer-side editor for a `Seo` field's configuration: the two advisory character limits.
+ *
+ * They are thresholds the value editor counts against, not validation - see {@link SeoConfiguration}.
+ */
+declare class SeoConfigComponent extends FieldTypeConfigBase {
+    protected configurationDefaults(): object;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeoConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SeoConfigComponent, "site-seo-config", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Configuration of a `Seo` field, shaped for `FormBuilder.group()`. Mirrors `SeoConfiguration`
+ * (`src/Dignite.Site.Domain/Seo/SeoConfiguration.cs`).
+ *
+ * The property names are the **stored** configuration keys, not a naming choice.
+ *
+ * Both limits are **advisory**. `SeoFieldType.Validate` does not reject an over-length value, because a
+ * search engine truncates an over-long title or description rather than rejecting it. They are a
+ * threshold for an editing UI (or AI-generated content) to aim for, so the control renders them as a
+ * counter and never as a `Validators.maxLength`.
+ */
+declare class SeoConfiguration {
+    /** 60 - Google's practical truncation point for a search result title. */
+    'Seo.MetaTitleCharLimit': unknown;
+    /** 160 - the conventional SERP snippet length. */
+    'Seo.MetaDescriptionCharLimit': unknown;
+}
+
+interface IRemoteStreamContent {
+    fileName?: string | null;
+    contentType?: string;
+    contentLength?: number | null;
+}
+
+interface CreateDirectoryInput {
+    containerName: string;
+    name: string;
+    parentId?: string | null;
+}
+interface CreateFileInput {
+    containerName: string;
+    directoryId?: string | null;
+    file: IRemoteStreamContent;
+}
+interface DirectoryDescriptorDto extends ExtensibleAuditedEntityDto<string> {
+    containerName?: string;
+    name?: string;
+    parentId?: string | null;
+    order?: number;
+}
+interface DirectoryDescriptorInfoDto extends ExtensibleEntityDto<string> {
+    containerName?: string;
+    name?: string;
+    parentId?: string | null;
+    order?: number;
+    children?: DirectoryDescriptorInfoDto[];
+}
+interface FileContainerConfigurationDto {
+    maxBlobSize?: number;
+    allowedFileTypeNames?: string[];
+    createDirectoryPermissionName?: string | null;
+    createFilePermissionName?: string | null;
+    updateFilePermissionName?: string | null;
+    deleteFilePermissionName?: string | null;
+    getFilePermissionName?: string | null;
+}
+interface FileDescriptorDto extends CreationAuditedEntityDto<string> {
+    containerName?: string;
+    blobName?: string;
+    directoryId?: string | null;
+    size?: number;
+    name?: string;
+    mimeType?: string;
+    url?: string | null;
+    tenantId?: string | null;
+}
+interface GetDirectoriesInput {
+    containerName: string;
+}
+interface GetFilesInput extends PagedAndSortedResultRequestDto {
+    containerName: string;
+    directoryId?: string | null;
+    creatorId?: string | null;
+    filter?: string | null;
+}
+interface MoveDirectoryInput {
+    parentId?: string | null;
+    order?: number;
+}
+interface UpdateDirectoryInput {
+    name: string;
+}
+interface UpdateFileInput {
+    name?: string | null;
+    directoryId?: string | null;
+    directoryIdSpecified?: boolean;
+}
+
+declare class DirectoryAdminService {
+    private restService;
+    apiName: string;
+    create: (input: CreateDirectoryInput, config?: Partial<Rest.Config>) => rxjs.Observable<DirectoryDescriptorDto>;
+    delete: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<void>;
+    get: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<DirectoryDescriptorDto>;
+    getList: (input: GetDirectoriesInput, config?: Partial<Rest.Config>) => rxjs.Observable<ListResultDto<DirectoryDescriptorInfoDto>>;
+    move: (id: string, input: MoveDirectoryInput, config?: Partial<Rest.Config>) => rxjs.Observable<DirectoryDescriptorDto>;
+    update: (id: string, input: UpdateDirectoryInput, config?: Partial<Rest.Config>) => rxjs.Observable<DirectoryDescriptorDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DirectoryAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class FileAdminService {
+    private restService;
+    apiName: string;
+    create: (input: CreateFileInput, config?: Partial<Rest.Config>) => rxjs.Observable<FileDescriptorDto>;
+    delete: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<void>;
+    get: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<FileDescriptorDto>;
+    getContainerConfiguration: (containerName: string, config?: Partial<Rest.Config>) => rxjs.Observable<FileContainerConfigurationDto>;
+    getList: (input: GetFilesInput, config?: Partial<Rest.Config>) => rxjs.Observable<PagedResultDto<FileDescriptorDto>>;
+    update: (id: string, input: UpdateFileInput, config?: Partial<Rest.Config>) => rxjs.Observable<FileDescriptorDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+type index_d$h_CreateDirectoryInput = CreateDirectoryInput;
+type index_d$h_CreateFileInput = CreateFileInput;
+type index_d$h_DirectoryAdminService = DirectoryAdminService;
+declare const index_d$h_DirectoryAdminService: typeof DirectoryAdminService;
+type index_d$h_DirectoryDescriptorDto = DirectoryDescriptorDto;
+type index_d$h_DirectoryDescriptorInfoDto = DirectoryDescriptorInfoDto;
+type index_d$h_FileAdminService = FileAdminService;
+declare const index_d$h_FileAdminService: typeof FileAdminService;
+type index_d$h_FileContainerConfigurationDto = FileContainerConfigurationDto;
+type index_d$h_FileDescriptorDto = FileDescriptorDto;
+type index_d$h_GetDirectoriesInput = GetDirectoriesInput;
+type index_d$h_GetFilesInput = GetFilesInput;
+type index_d$h_MoveDirectoryInput = MoveDirectoryInput;
+type index_d$h_UpdateDirectoryInput = UpdateDirectoryInput;
+type index_d$h_UpdateFileInput = UpdateFileInput;
+declare namespace index_d$h {
+  export { index_d$h_DirectoryAdminService as DirectoryAdminService, index_d$h_FileAdminService as FileAdminService };
+  export type { index_d$h_CreateDirectoryInput as CreateDirectoryInput, index_d$h_CreateFileInput as CreateFileInput, index_d$h_DirectoryDescriptorDto as DirectoryDescriptorDto, index_d$h_DirectoryDescriptorInfoDto as DirectoryDescriptorInfoDto, index_d$h_FileContainerConfigurationDto as FileContainerConfigurationDto, index_d$h_FileDescriptorDto as FileDescriptorDto, index_d$h_GetDirectoriesInput as GetDirectoriesInput, index_d$h_GetFilesInput as GetFilesInput, index_d$h_MoveDirectoryInput as MoveDirectoryInput, index_d$h_UpdateDirectoryInput as UpdateDirectoryInput, index_d$h_UpdateFileInput as UpdateFileInput };
+}
+
+/**
+ * Edits the value of a `Seo` field.
+ *
+ * Unlike every built-in field type, this binds a **`FormGroup`** rather than a single control: the
+ * value is a composite object, and the group's shape is exactly `SeoFieldValue`, so what the form
+ * produces round-trips back to the server unchanged.
+ *
+ * **No sub-field is individually required, even when the field usage is.** The server's
+ * `SeoFieldType.Validate` only rejects a *missing bundle*; SEO fields are supplementary and the
+ * platform falls back to defaults for whatever is left blank (总体设计 §5.3). Since a `FormGroup`
+ * always produces an object, a required Seo field is satisfied by being rendered at all - adding
+ * `Validators.required` to the parts would enforce something the server does not.
+ *
+ * **The share image is picked, not typed** (GitHub issue #72): the file library's modal, fixed to the
+ * `images` container, uploads or selects one file and its `url` is what `ogImage` stores - still a
+ * plain string, so a value an MCP client wrote (an external address included) shows and can be replaced
+ * or removed the same way.
+ */
+declare class SeoControlComponent extends FieldTypeControlBase {
+    readonly ogImageContainerName = "images";
+    readonly ogImageWidth = 1200;
+    readonly ogImageHeight = 630;
+    ogImagePickerOpen: boolean;
+    protected configurationDefaults(): object;
+    /**
+     * Untyped on purpose. `FieldTypeControlBase.createControl` is declared to return
+     * `AbstractControl<any, any, any>`, and a typed `FormGroup<{...}>` is not assignable to it - typed
+     * forms fix `TRawValue` to the group's own shape. Every built-in field type returns a single
+     * control, so this is the first one to hit it.
+     */
+    protected createControl(): AbstractControl;
+    /** The bound group, for the template's counters. */
+    get seoGroup(): UntypedFormGroup | null;
+    /** The stored share image address, or '' when there is none. */
+    get ogImage(): string;
+    onOgImagePicked(files: FileDescriptorDto[]): void;
+    removeOgImage(): void;
+    get metaTitleLength(): number;
+    get metaDescriptionLength(): number;
+    get metaTitleCharLimit(): number;
+    get metaDescriptionCharLimit(): number;
+    private setOgImage;
+    /**
+     * A fresh value is a live object; one that has round-tripped through storage arrives as parsed JSON.
+     * Anything else - the base class seeds `''` when there is no value - means "nothing stored yet".
+     */
+    private currentValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeoControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SeoControlComponent, "site-seo-control", never, {}, {}, never, never, true, never>;
+}
+
+/** The registration key. Must equal `SeoFieldNames.FieldTypeName` on the server. */
+declare const SEO_FIELD_TYPE_NAME = "Seo";
+/**
+ * Site's seventh field type, alongside the six the flex-fields library ships. The server registers
+ * `SeoFieldType` through DI automatically; the client has no equivalent discovery, so it is registered
+ * here and wired in through `provideSite()`.
+ *
+ * This is not optional wiring: `seo` is a platform-preset seeded field, so a fresh install already has
+ * one. Without this registration `FieldTypeResolver.get('Seo')` throws and both the field designer and
+ * the content editor break on first use.
+ *
+ * **No search component.** `SeoFieldType.IndexValueType` is null - the value is a composite object with
+ * no typed index column to project into - so a `Seo` field can never be searched and must not offer a
+ * filter control.
+ *
+ * `displayNameKey` reads `FlexFieldsSite::...`, not `Site::...`: `SeoFieldType` moved from
+ * `Dignite.Site.Domain` into `Dignite.FlexFields.Site` alongside Content/Matrix/Table (GitHub issue
+ * #49), and its `LocalizationResource` moved with it.
+ */
+declare const SEO_FIELD_TYPE: FieldTypeDefinition;
+
+/**
+ * The value a `Seo` field stores. Mirrors `SeoFieldValue`
+ * (`src/Dignite.FlexFields.Site/Dignite/FlexFields/Site/Seo/SeoFieldValue.cs`); the server serializes it with
+ * `JsonSerializerDefaults.Web`, so the wire names are camelCase exactly as written here.
+ *
+ * One field, one composite value - a content type opts into the whole bundle with a single reference
+ * rather than pulling in four separate fields.
+ */
+interface SeoFieldValue {
+    /** Overrides `<title>`/`og:title`; empty falls back to the content's own title field. */
+    metaTitle?: string;
+    /** Overrides `<meta name="description">`/`og:description`. */
+    metaDescription?: string;
+    /**
+     * Image URL for social sharing. The admin UI fills it with the (relative) `url` of a file picked from the
+     * `images` file container; any absolute image URL is equally valid (an MCP client may write one).
+     * When emitted as `og:image` a relative address is put on the site's primary domain, and an image from the
+     * site's file library is cropped to 1200x630.
+     */
+    ogImage?: string;
+    /**
+     * The one platform-recognized semantic: when true the content is excluded from the sitemap and gets
+     * a `noindex` robots meta tag.
+     */
+    noIndex?: boolean;
+}
+
+/**
+ * Displays the value of a `Seo` field read-only.
+ *
+ * In a list cell there is room for one thing, so it shows the meta title and flags `noindex` - the one
+ * part of the bundle with a platform-recognized consequence.
+ */
+declare class SeoViewComponent {
+    readonly ogImageWidth = 1200;
+    readonly ogImageHeight = 630;
+    /** Renders bare, without the label wrapper, for use inside a table cell. */
+    showInList: boolean;
+    fields?: FlexFieldValue;
+    /** Registration key of the field type - always `Seo` here. */
+    type?: string;
+    value: unknown;
+    get seo(): SeoFieldValue;
+    get hasValue(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeoViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SeoViewComponent, "site-seo-view", never, { "showInList": { "alias": "showInList"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const MY_FILES_NODE_KEY = "__site-my-files__";
+declare const isMyFilesNode: (node: {
+    key?: string;
+} | null | undefined) => boolean;
+/**
+ * A directory, reshaped in place by {@link FileDirectoryTreeComponent.buildNodeTree} into
+ * what `abp-tree` expects (`title`/`key`/`children`/...), plus the synthetic "My Files" virtual root.
+ */
+interface DirectoryTreeNode extends Partial<DirectoryDescriptorDto> {
+    key: string;
+    title: string;
+    children: DirectoryTreeNode[];
+    expanded: boolean;
+    isLeaf?: boolean;
+    isVirtualRoot?: boolean;
+    isFirstChildOfDirectory?: boolean;
+}
+declare class FileDirectoryTreeComponent implements AfterContentInit {
+    private directoryAdminService;
+    private fb;
+    private confirmation;
+    private localizationService;
+    private readonly hostElement;
+    constructor(directoryAdminService: DirectoryAdminService, fb: FormBuilder, confirmation: ConfirmationService, localizationService: LocalizationService);
+    directoryTree: DirectoryTreeNode[];
+    selectedTreeNode: DirectoryTreeNode | undefined;
+    set theSelectedTreeNode(v: DirectoryTreeNode | undefined);
+    nodeBeingEdited: DirectoryTreeNode | undefined;
+    expandedNodeKeys: string[];
+    set fileContainerName(v: string);
+    get fileContainerName(): string;
+    private _fileContainerName;
+    nodeClick: EventEmitter<DirectoryTreeNode>;
+    treeNodeData: EventEmitter<DirectoryTreeNode[]>;
+    ngAfterContentInit(): void;
+    loadData(): void;
+    private loadDirectoryTree;
+    private createMyFilesNode;
+    isMyFilesNode: (node: {
+        key?: string;
+    } | null | undefined) => boolean;
+    /** Reshapes the flat, parent-referencing directory list into the nested tree `abp-tree` renders. */
+    private buildNodeTree;
+    /** Dragged-directory highlight state, tracked globally so it clears even if the drop lands outside the tree. */
+    isDirectoryDragging: boolean;
+    onDirectoryDragStart(event: DragEvent): void;
+    onDirectoryDragEnd(): void;
+    beforeDrop: (arg: unknown) => rxjs.Observable<boolean>;
+    /**
+     * The node icon itself stops propagation via `(click)="$event.stopPropagation()"`, so a click on
+     * it never reaches here - no need to distinguish where the click came from.
+     */
+    activeNode(node: DirectoryTreeNode): void;
+    isNodeSelected: (node: DirectoryTreeNode) => boolean;
+    onExpandChange(event: {
+        node: DirectoryTreeNode;
+    }): void;
+    directoryFormModalOpen: boolean;
+    directoryFormBusy: boolean;
+    directoryForm: FormGroup | undefined;
+    directoryFormSubmit: ElementRef<HTMLButtonElement>;
+    openDirectoryForm(parentNode?: DirectoryTreeNode, editing?: boolean): void;
+    deleteDirectory(node: DirectoryTreeNode): void;
+    onDirectoryFormVisibleChange(visible: boolean): void;
+    private readonly validatorsService;
+    saveDirectoryForm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileDirectoryTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileDirectoryTreeComponent, "site-file-directory-tree", never, { "theSelectedTreeNode": { "alias": "theSelectedTreeNode"; "required": false; }; "fileContainerName": { "alias": "fileContainerName"; "required": false; }; }, { "nodeClick": "nodeClick"; "treeNodeData": "treeNodeData"; }, never, never, true, never>;
+}
+
+/** A file mid-upload, tracked alongside its outcome for the status toast. */
+interface UploadingFile extends File {
+    status?: 1 | 2;
+}
+declare class FileModalComponent implements OnChanges {
+    private fileService;
+    private toaster;
+    readonly list: ListService;
+    private confirmation;
+    private localizationService;
+    private fileTable?;
+    private tableRecalculationFrame?;
+    readonly tableSortIcons: {
+        sortAscending: string;
+        sortDescending: string;
+    };
+    constructor(fileService: FileAdminService, toaster: ToasterService, list: ListService, confirmation: ConfirmationService, localizationService: LocalizationService);
+    private loadContainerConfiguration;
+    createDirectoryPermissionName: string;
+    /** No default: an unconfigured container is a caller bug, not implicitly "Images". */
+    set fileContainerName(v: string);
+    get fileContainerName(): string;
+    private _fileContainerName;
+    multiple: boolean;
+    sizeLimit: number;
+    set limit(v: number);
+    set visible(v: boolean);
+    visibleChange: EventEmitter<boolean>;
+    modalOpen: boolean;
+    /**
+     * The two secondary dialogs' open/busy flags are signals, not plain fields: they are written after an
+     * HTTP call returns (rename, move), and bound on `<abp-modal>` elements that sit in this component's own
+     * view - under the host layout's OnPush ancestors (`abp-router-outlet`, the LeptonX layouts), where a
+     * plain-field write in a response callback never marks the view for check, so the dialog would stay open
+     * until some unrelated event happened to. What renders *inside* a dialog (header/body/footer) is attached
+     * to the application root by `NgbModal` and refreshed on every tick, so the plain fields it reads
+     * (`data`, `uploadingFiles`, `isRenaming`, ...) are not affected.
+     */
+    readonly fileNameModalOpen: i0.WritableSignal<boolean>;
+    onFileNameModalVisibleChange(visible: boolean): void;
+    onModalVisibleChange(visible: boolean): void;
+    /** Recomputes the table's column widths once the modal has finished its open transition. */
+    onModalInit(): void;
+    private scheduleTableRecalculation;
+    modalSave(): void;
+    selectedTreeNode: DirectoryTreeNode | undefined;
+    private hasQueryHook;
+    loadData(): void;
+    /** Flattened directory list from the tree, for the breadcrumb-style path lookups below. */
+    private flattenedDirectories;
+    private getSelectedDirectoryId;
+    onTreeNodeData(nodes: DirectoryTreeNode[]): void;
+    private getDirectoryPath;
+    getFileDirectoryPath(directoryId: string | undefined): string;
+    private flattenTree;
+    onTreeNodeClick(node: DirectoryTreeNode): void;
+    uploadingFiles: UploadingFile[];
+    onFileInputChange(event: Event): Promise<void>;
+    private setUploadStatus;
+    private uploadFile;
+    data: PagedResultDto<FileDescriptorDto>;
+    filters: GetFilesInput;
+    selectFilefn: EventEmitter<FileDescriptorDto[]>;
+    private hookToQuery;
+    deleteSelectedFiles(): void;
+    private batchDeleteFiles;
+    readonly moveModalOpen: i0.WritableSignal<boolean>;
+    readonly moveModalBusy: i0.WritableSignal<boolean>;
+    moveTargetDirectoryNode: DirectoryTreeNode | undefined;
+    openMoveModal(): void;
+    onMoveTargetDirectoryChange(node: DirectoryTreeNode): void;
+    onMoveModalVisibleChange(visible: boolean): void;
+    moveSelectedFiles(): Promise<void>;
+    closeFileStatusModal(): void;
+    selectedFiles: FileDescriptorDto[];
+    isAllSelected: boolean;
+    selectPickerFile: FileDescriptorDto[];
+    ngOnChanges(changes: SimpleChanges): void;
+    onRowCheckboxChange(event: Event, row: FileDescriptorDto, rows: FileDescriptorDto[]): void;
+    private areAllSelected;
+    onSelectAllChange(event: Event, rows: FileDescriptorDto[]): void;
+    isRowSelected: (id: string) => boolean;
+    private removeDuplicatesById;
+    /** Editing form, one row at a time - opening a second one replaces it. */
+    fileNameForm: FormGroup | undefined;
+    editingFileRow: FileDescriptorDto | undefined;
+    isRenaming: boolean;
+    onSubmitFileName(): void;
+    onEditFileName(row: FileDescriptorDto): void;
+    onCancelFileNameEdit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileModalComponent, "site-file-modal", never, { "fileContainerName": { "alias": "fileContainerName"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "selectPickerFile": { "alias": "selectPickerFile"; "required": false; }; }, { "visibleChange": "visibleChange"; "selectFilefn": "selectFilefn"; }, never, never, true, never>;
+}
+
+declare class FilePickerComponent implements OnChanges {
+    multiple: boolean;
+    /** No default: a caller that never specifies a container has a configuration bug, not an "Images" one. */
+    fileContainerName: string;
+    selectFormFile: FileDescriptorDto[];
+    selectedFileChange: EventEmitter<FileDescriptorDto[]>;
+    /** This component's single source of truth; also passed straight to the modal to reselect what's already picked. */
+    fileShowTable: FileDescriptorDto[];
+    modalOpen: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    onSelectFile(files: FileDescriptorDto[]): void;
+    deleteFileTableItem(index: number): void;
+    drop(event: CdkDragDrop<FileDescriptorDto[]>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilePickerComponent, "site-file-picker", never, { "multiple": { "alias": "multiple"; "required": false; }; "fileContainerName": { "alias": "fileContainerName"; "required": false; }; "selectFormFile": { "alias": "selectFormFile"; "required": false; }; }, { "selectedFileChange": "selectedFileChange"; }, never, never, true, never>;
+}
+
+/**
+ * Creates a short-lived object URL for a Blob so previews can reference the
+ * browser-managed blob instead of holding a base64 copy in memory. Callers own
+ * the returned URL and must revoke it (URL.revokeObjectURL) when it is no longer
+ * needed to avoid leaking the underlying blob.
+ */
+declare class ObjectUrlService {
+    get(file: Blob): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectUrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class FormatFileSizePipe implements PipeTransform {
+    transform(bytes: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatFileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatFileSizePipe, "formatFileSize", true>;
+}
+
+/** A locally-picked `File` awaiting upload, or an already-uploaded file passed in via `fileData`. */
+interface UploadTableItem {
+    id?: string;
+    name?: string;
+    size: number;
+    type?: string;
+    fileSize?: string;
+    src?: string;
+}
+interface FileUploadChangeEvent {
+    theFilesToBeUploaded: UploadTableItem[];
+    deleteTheUploadedFiles: UploadTableItem[];
+    isSubmit: boolean;
+}
+declare class FileUploadComponent implements OnDestroy {
+    private formatFileSizePipe;
+    private objectUrlService;
+    private fileAdminService;
+    constructor(formatFileSizePipe: FormatFileSizePipe, objectUrlService: ObjectUrlService, fileAdminService: FileAdminService);
+    /**
+     * No default: an unconfigured container is not silently treated as any particular one - the
+     * upload input just doesn't render until a container is set (see the template).
+     */
+    set fileContainerName(v: string);
+    get fileContainerName(): string;
+    private _fileContainerName;
+    multiple: boolean;
+    /** Already-uploaded files to show pre-populated in the table, e.g. when editing an existing record. */
+    set fileData(files: UploadTableItem[]);
+    fileDataChange: EventEmitter<FileUploadChangeEvent>;
+    /**
+     * A signal, not a plain field: the container's real limit arrives in an HTTP callback, and a plain-field
+     * write there never marks a host's OnPush ancestors for check, so the "exceeds the maximum size" hint
+     * would keep showing the pre-fetch 1MB default until an unrelated event.
+     */
+    readonly sizeLimit: i0.WritableSignal<number>;
+    set limit(v: number);
+    filesTableData: UploadTableItem[];
+    private readonly previewObjectUrls;
+    private readonly deletedUploadedFiles;
+    fileUploadInput: ElementRef<HTMLInputElement>;
+    onFileInputChange(event: Event): Promise<void>;
+    deleteFileTableItem(index: number, item: UploadTableItem): void;
+    private addFiles;
+    private emitChange;
+    ngOnDestroy(): void;
+    private releasePreviewUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadComponent, "site-file-upload", never, { "fileContainerName": { "alias": "fileContainerName"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "fileData": { "alias": "fileData"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; }, { "fileDataChange": "fileDataChange"; }, never, never, true, never>;
+}
+
+/**
+ * A thumbnail (image) or type icon (anything else) for one file. Site's file containers are publicly
+ * readable, so an image is shown straight from its public address (`/api/site-public/files/...`), asked
+ * for at the thumbnail's size so the browser does not download the full upload. The address is stored
+ * relative; it is shown - and linked - from the `SiteAdmin` API's host (`SiteFileUrlService`).
+ */
+declare class FilePreviewComponent implements OnChanges {
+    private readonly fileUrls;
+    width: string;
+    /** The file's address: the public read endpoint's, or a local `blob:`/`data:` URL for a file not uploaded yet. */
+    src: string;
+    type: string;
+    name: string;
+    className: string;
+    /** Server-side resize for the thumbnail (cropped to fill when both are set). Ignored for a local URL. */
+    resizeWidth?: number;
+    resizeHeight?: number;
+    isImage: boolean;
+    isAudio: boolean;
+    isVideo: boolean;
+    displaySrc: string;
+    /** {@link src} where this UI can reach it - the download link. */
+    linkHref: string;
+    ngOnChanges(): void;
+    private updateFileType;
+    /** Falls back to a generic file icon when the type has no dedicated one. */
+    getFileIconClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilePreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilePreviewComponent, "site-file-preview", never, { "width": { "alias": "width"; "required": false; }; "src": { "alias": "src"; "required": false; }; "type": { "alias": "type"; "required": false; }; "name": { "alias": "name"; "required": false; }; "className": { "alias": "className"; "required": false; }; "resizeWidth": { "alias": "resizeWidth"; "required": false; }; "resizeHeight": { "alias": "resizeHeight"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface FileTypeIcon {
+    type: string;
+    icon: string;
+}
+/** Fallback icon by MIME type (or file extension, for the few types MIME can't distinguish). */
+declare const IMAGE_TYPE_OPTIONS: readonly FileTypeIcon[];
+
+/**
+ * Lets a CKEditor field work with Site's images on the `SiteAdmin` API's host while storing them relative.
+ * A stored address is relative (`<img src="/api/site-public/files/...">`, see `SITE_FILE_PATH`), and this
+ * admin UI is served from another origin, where it does not resolve.
+ *
+ * So the editor's **model** holds the absolute address, and only the data the editor hands out is
+ * relative: a plugin converts an image's `src` (`imageBlock`/`imageInline`) on the way in (upcast:
+ * `setData()`, the initial value, a paste) from relative to absolute, and on the way out (data downcast:
+ * `getData()` - the form value that is saved, the Source view, a copy) from absolute back to relative.
+ * Everything CKEditor itself does with the model's `src` then just works: the editing view shows it, and
+ * `ImageUtils.setImageNaturalSizeAttributes` reads an uploaded image's size from it (`width`/`height`).
+ * HTML and Markdown fields alike: both load images into the same model. Links (`<a href>`) are left alone.
+ * The upload provider hands the editor the absolute address for the same reason.
+ *
+ * Registered by `provideSite()` under `CKEDITOR_CONFIG_CONTRIBUTORS` (with `useFactory`, so it can inject);
+ * the pattern is the one in `@dignite/ng.flex-fields-ckeditor`'s README, "Customizing the editor
+ * configuration".
+ */
+declare function siteCKEditorConfigContributor(): CKEditorConfigContributor;
+
+/**
+ * Lets the read-only rich-text view (`ff-ckeditor-view`: a content list cell, say) show Site's images on the
+ * `SiteAdmin` API's host. The stored HTML holds relative addresses (`<img src="/api/site-public/files/...">`,
+ * see `SITE_FILE_PATH`), which do not resolve when this admin UI is served from another origin. The editor
+ * itself is handled by `siteCKEditorConfigContributor`; this is its counterpart for the view, which has no
+ * editor to convert in.
+ *
+ * Only `src` is rewritten, in the double- and single-quoted spellings; links (`<a href>`) are left alone, as
+ * in the editor. The result is for display only: the view never hands HTML back, so nothing saved carries the
+ * host. When the UI shares its API's origin (`apiBase` empty) the HTML comes back untouched.
+ *
+ * Registered by `provideSite()` under `CKEDITOR_DISPLAY_CONTRIBUTORS` (with `useFactory`, so it can inject);
+ * the pattern is the one in `@dignite/ng.flex-fields-ckeditor`'s README, "Customizing the read-only view".
+ */
+declare function siteCKEditorDisplayContributor(): CKEditorDisplayContributor;
+
+/**
+ * Uploads an image inserted into a CKEditor field into Site's file library and hands the editor the
+ * file's public address to embed - the same `/api/site-public/files/...` address a file field stores, so
+ * the image is served to visitors like any other site file. Registered as the `CKEDITOR_UPLOAD_PROVIDER`
+ * by `provideSite()`; the field's `CKEditor.ImagesContainerName` names the container (normally
+ * `images`).
+ *
+ * The editor gets the address on the `SiteAdmin` API's host: its model holds absolute addresses, so it can
+ * show the image and read its size (`width`/`height`); `siteCKEditorConfigContributor` turns it back into
+ * the relative address the server handed out when the editor's data is read and saved.
+ */
+declare class SiteCKEditorUploadProvider implements CKEditorUploadProvider {
+    private readonly fileAdminService;
+    private readonly fileUrls;
+    upload(file: File, containerName: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteCKEditorUploadProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Site's file containers - the server's `SiteFileContainerNames`. The file library works in these only;
+ * a file field names one of them. `images` takes pictures, `attachments` documents only.
+ */
+declare const SITE_FILE_CONTAINER_NAMES: readonly ["images", "attachments"];
+/** Pictures only (raster formats, no SVG) - what a share image or an image field uses. */
+declare const SITE_IMAGES_CONTAINER_NAME = "images";
+
+/**
+ * The path every Site file is served under - the server's `SiteFileUrl.RoutePrefix`. The admin API hands
+ * out addresses relative to it (`FileDescriptorDto.url`, `/api/site-public/files/...?__tenant=`), and that
+ * relative address is what a field stores: no host is written into content. The public site resolves it
+ * against its own origin; this admin UI, served from another origin, shows it from its `SiteAdmin` API
+ * host (`SiteFileUrlService`).
+ */
+declare const SITE_FILE_PATH = "/api/site-public/files/";
+/** Whether `url` addresses a file Site serves (and so can be resized), as opposed to an external image. */
+declare function isSiteFileUrl(url: string | null | undefined): boolean;
+/**
+ * `url` asked for at `width` x `height` (`?Width=&Height=`, the server crops to fill when both are given),
+ * keeping every other query parameter - `__tenant` in particular. Anything that is not a Site file address
+ * (a local `blob:` URL, an external image) comes back unchanged, as does a call without a size. Mirrors the
+ * server's `SiteFileUrl.Sized`.
+ */
+declare function sizedFileUrl(url: string | null | undefined, width?: number, height?: number): string;
+/**
+ * `url` on `apiBase` when it is a relative Site file address; anything else - an absolute address, a local
+ * `blob:`/`data:` URL, an external image - comes back unchanged, as does every address when `apiBase` is
+ * empty (an admin UI served from its API's own origin). Mirrors the server's `SiteFileUrl.Absolutize`.
+ */
+declare function absoluteFileUrl(url: string | null | undefined, apiBase: string): string;
+
+/**
+ * Where this admin UI shows Site's files from. A stored address is relative (`/api/site-public/files/...`,
+ * see `SITE_FILE_PATH`), and this UI is served from an origin of its own, so the previews
+ * (`site-file-preview`: the file picker and modal, a file field, the SEO share image) put the `SiteAdmin`
+ * API's host - `environment.apis.SiteAdmin.url`, where the file library's admin API lives - in front of it.
+ * The CKEditor field does the same inside the editor (`siteCKEditorConfigContributor`). Nothing that is
+ * saved carries that host.
+ */
+declare class SiteFileUrlService {
+    private readonly environment;
+    /** The `SiteAdmin` API's base URL, with no trailing slash; empty when the UI shares its API's origin. */
+    get apiBase(): string;
+    /** A stored file address as this UI loads it - see `absoluteFileUrl`. */
+    toDisplay(url: string | null | undefined): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteFileUrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class ValidatorsService {
+    private toaster;
+    private localizationService;
+    constructor(toaster: ToasterService, localizationService: LocalizationService);
+    isCheckForm(input: {
+        [key: string]: boolean;
+    }, module?: string): boolean;
+    getFormValidationStatus(formEntity: FormGroup | FormArray): Record<string, boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare enum FlexFieldQueryOperator {
+    Equals = 0,
+    NotEquals = 1,
+    Contains = 2,
+    GreaterThan = 3,
+    GreaterThanOrEqual = 4,
+    LessThan = 5,
+    LessThanOrEqual = 6,
+    In = 7
+}
+declare const flexFieldQueryOperatorOptions: _abp_ng_core.ABP.Option<typeof FlexFieldQueryOperator>[];
+
+declare enum FlexFieldValueType {
+    String = 0,
+    Number = 1,
+    DateTime = 2,
+    Boolean = 3,
+    Guid = 4
+}
+declare const flexFieldValueTypeOptions: _abp_ng_core.ABP.Option<typeof FlexFieldValueType>[];
+
+interface FlexFieldQueryCondition {
+    fieldId?: string;
+    fieldName?: string;
+    operator?: FlexFieldQueryOperator;
+    value?: string;
+    valueType?: FlexFieldValueType;
+}
+
+type index_d$g_FlexFieldQueryCondition = FlexFieldQueryCondition;
+type index_d$g_FlexFieldQueryOperator = FlexFieldQueryOperator;
+declare const index_d$g_FlexFieldQueryOperator: typeof FlexFieldQueryOperator;
+type index_d$g_FlexFieldValueType = FlexFieldValueType;
+declare const index_d$g_FlexFieldValueType: typeof FlexFieldValueType;
+declare const index_d$g_flexFieldQueryOperatorOptions: typeof flexFieldQueryOperatorOptions;
+declare const index_d$g_flexFieldValueTypeOptions: typeof flexFieldValueTypeOptions;
+declare namespace index_d$g {
+  export { index_d$g_FlexFieldQueryOperator as FlexFieldQueryOperator, index_d$g_FlexFieldValueType as FlexFieldValueType, index_d$g_flexFieldQueryOperatorOptions as flexFieldQueryOperatorOptions, index_d$g_flexFieldValueTypeOptions as flexFieldValueTypeOptions };
+  export type { index_d$g_FlexFieldQueryCondition as FlexFieldQueryCondition };
+}
+
+declare namespace index_d$f {
+  export {
+    index_d$g as FlexFields,
+  };
+}
+
+interface CreateContentTypeDto {
+    pageId: string;
+    name: string;
+    displayName: string;
+    description?: string | null;
+    fields?: ContentTypeFieldDto[] | null;
+}
+interface UpdateContentTypeDto {
+    name: string;
+    displayName: string;
+    description?: string | null;
+    fields?: ContentTypeFieldDto[] | null;
+}
+
+declare class ContentTypeAdminService {
+    private restService;
+    apiName: string;
+    create: (input: CreateContentTypeDto, config?: Partial<Rest.Config>) => rxjs.Observable<ContentTypeDto>;
+    delete: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<void>;
+    findByName: (pageId: string, name: string, config?: Partial<Rest.Config>) => rxjs.Observable<ContentTypeDto>;
+    get: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<ContentTypeDto>;
+    getList: (config?: Partial<Rest.Config>) => rxjs.Observable<ListResultDto<ContentTypeDto>>;
+    getListByPage: (pageId: string, config?: Partial<Rest.Config>) => rxjs.Observable<ListResultDto<ContentTypeDto>>;
+    update: (id: string, input: UpdateContentTypeDto, config?: Partial<Rest.Config>) => rxjs.Observable<ContentTypeDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentTypeAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+type index_d$e_ContentTypeAdminService = ContentTypeAdminService;
+declare const index_d$e_ContentTypeAdminService: typeof ContentTypeAdminService;
+type index_d$e_CreateContentTypeDto = CreateContentTypeDto;
+type index_d$e_UpdateContentTypeDto = UpdateContentTypeDto;
+declare namespace index_d$e {
+  export { index_d$e_ContentTypeAdminService as ContentTypeAdminService };
+  export type { index_d$e_CreateContentTypeDto as CreateContentTypeDto, index_d$e_UpdateContentTypeDto as UpdateContentTypeDto };
+}
+
+interface CreateContentDto {
+    contentTypeId: string;
+    cultureName: string;
+    slug?: string;
+    publishTime: string;
+    status?: ContentStatus;
+    fieldValues?: Record<string, object> | null;
+}
+interface GetContentListInput extends PagedAndSortedResultRequestDto {
+    pageId?: string | null;
+    cultureName?: string | null;
+    contentTypeId?: string | null;
+    status?: ContentStatus | null;
+    publishedBefore?: string | null;
+    publishedAfter?: string | null;
+    filter?: string | null;
+    flexFieldConditions?: FlexFieldQueryCondition[] | null;
+}
+interface UpdateContentDto {
+    slug?: string;
+    publishTime: string;
+    status?: ContentStatus;
+    fieldValues?: Record<string, object> | null;
+    contentTypeId?: string | null;
+}
+
+declare class ContentAdminService {
+    private restService;
+    apiName: string;
+    create: (input: CreateContentDto, config?: Partial<Rest.Config>) => rxjs.Observable<ContentDto>;
+    delete: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<void>;
+    findBySlug: (pageId: string, cultureName: string, slug: string, config?: Partial<Rest.Config>) => rxjs.Observable<ContentDto>;
+    get: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<ContentDto>;
+    getList: (input: GetContentListInput, config?: Partial<Rest.Config>) => rxjs.Observable<PagedResultDto<ContentDto>>;
+    update: (id: string, input: UpdateContentDto, config?: Partial<Rest.Config>) => rxjs.Observable<ContentDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+type index_d$d_ContentAdminService = ContentAdminService;
+declare const index_d$d_ContentAdminService: typeof ContentAdminService;
+type index_d$d_CreateContentDto = CreateContentDto;
+type index_d$d_GetContentListInput = GetContentListInput;
+type index_d$d_UpdateContentDto = UpdateContentDto;
+declare namespace index_d$d {
+  export { index_d$d_ContentAdminService as ContentAdminService };
+  export type { index_d$d_CreateContentDto as CreateContentDto, index_d$d_GetContentListInput as GetContentListInput, index_d$d_UpdateContentDto as UpdateContentDto };
+}
+
+interface CreateFieldDto {
+    name: string;
+    displayName: string;
+    fieldTypeName: string;
+    description?: string | null;
+    configuration?: Record<string, object> | null;
+    groupName?: string | null;
+}
+interface GetFieldListInput {
+    filter?: string | null;
+}
+interface RenameFieldDto {
+    newName: string;
+}
+interface UpdateFieldDto {
+    displayName: string;
+    fieldTypeName: string;
+    description?: string | null;
+    configuration?: Record<string, object> | null;
+    groupName?: string | null;
+}
+
+interface FieldDto extends FullAuditedEntityDto<string> {
+    name?: string;
+    displayName?: string;
+    description?: string | null;
+    fieldTypeName?: string;
+    configuration?: Record<string, object>;
+    groupName?: string | null;
+}
+interface FieldTypeDto {
+    name?: string;
+    indexable?: boolean;
+    composite?: boolean;
+    valueShape?: FieldValuePropertyDto[] | null;
+}
+interface FieldValuePropertyDto {
+    name?: string;
+    type?: string;
+    description?: string | null;
+}
+
+declare class FieldAdminService {
+    private restService;
+    apiName: string;
+    create: (input: CreateFieldDto, config?: Partial<Rest.Config>) => rxjs.Observable<FieldDto>;
+    delete: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<void>;
+    findByName: (name: string, config?: Partial<Rest.Config>) => rxjs.Observable<FieldDto>;
+    get: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<FieldDto>;
+    getFieldTypes: (config?: Partial<Rest.Config>) => rxjs.Observable<ListResultDto<FieldTypeDto>>;
+    getList: (input: GetFieldListInput, config?: Partial<Rest.Config>) => rxjs.Observable<ListResultDto<FieldDto>>;
+    rename: (id: string, input: RenameFieldDto, config?: Partial<Rest.Config>) => rxjs.Observable<FieldDto>;
+    update: (id: string, input: UpdateFieldDto, config?: Partial<Rest.Config>) => rxjs.Observable<FieldDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+type index_d$c_CreateFieldDto = CreateFieldDto;
+type index_d$c_FieldAdminService = FieldAdminService;
+declare const index_d$c_FieldAdminService: typeof FieldAdminService;
+type index_d$c_GetFieldListInput = GetFieldListInput;
+type index_d$c_RenameFieldDto = RenameFieldDto;
+type index_d$c_UpdateFieldDto = UpdateFieldDto;
+declare namespace index_d$c {
+  export { index_d$c_FieldAdminService as FieldAdminService };
+  export type { index_d$c_CreateFieldDto as CreateFieldDto, index_d$c_GetFieldListInput as GetFieldListInput, index_d$c_RenameFieldDto as RenameFieldDto, index_d$c_UpdateFieldDto as UpdateFieldDto };
+}
+
+interface CreatePageDto {
+    name: string;
+    displayName: string;
+    route: string;
+    template: string;
+    parentId?: string | null;
+    isActive?: boolean;
+}
+interface GetPageListInput {
+    isActive?: boolean | null;
+    filter?: string | null;
+}
+interface UpdatePageDto {
+    name: string;
+    displayName: string;
+    route: string;
+    template: string;
+    parentId?: string | null;
+    isActive?: boolean;
+}
+
+interface PageDto extends FullAuditedEntityDto<string> {
+    name?: string;
+    displayName?: string;
+    route?: string;
+    template?: string;
+    isHomePage?: boolean;
+    parentId?: string | null;
+    isActive?: boolean;
+    contentTypes?: ContentTypeDto[] | null;
+}
+
+declare class PageAdminService {
+    private restService;
+    apiName: string;
+    create: (input: CreatePageDto, config?: Partial<Rest.Config>) => rxjs.Observable<PageDto>;
+    delete: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<void>;
+    findByName: (name: string, config?: Partial<Rest.Config>) => rxjs.Observable<PageDto>;
+    get: (id: string, config?: Partial<Rest.Config>) => rxjs.Observable<PageDto>;
+    getList: (input: GetPageListInput, config?: Partial<Rest.Config>) => rxjs.Observable<ListResultDto<PageDto>>;
+    update: (id: string, input: UpdatePageDto, config?: Partial<Rest.Config>) => rxjs.Observable<PageDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+type index_d$b_CreatePageDto = CreatePageDto;
+type index_d$b_GetPageListInput = GetPageListInput;
+type index_d$b_PageAdminService = PageAdminService;
+declare const index_d$b_PageAdminService: typeof PageAdminService;
+type index_d$b_UpdatePageDto = UpdatePageDto;
+declare namespace index_d$b {
+  export { index_d$b_PageAdminService as PageAdminService };
+  export type { index_d$b_CreatePageDto as CreatePageDto, index_d$b_GetPageListInput as GetPageListInput, index_d$b_UpdatePageDto as UpdatePageDto };
+}
+
+interface SiteSchemaContentTypeDto {
+    name?: string;
+    displayName?: string;
+    description?: string | null;
+    fields?: SiteSchemaFieldDto[];
+}
+interface SiteSchemaDto {
+    enabledLanguages?: string[];
+    defaultLanguage?: string;
+    primaryDomain?: string;
+    pages?: SiteSchemaPageDto[];
+}
+interface SiteSchemaFieldDto {
+    name?: string;
+    displayName?: string;
+    description?: string | null;
+    fieldTypeName?: string;
+    configuration?: Record<string, object>;
+    required?: boolean;
+    searchable?: boolean;
+    order?: number;
+    showInList?: boolean;
+}
+interface SiteSchemaPageDto {
+    name?: string;
+    displayName?: string;
+    route?: string;
+    isHomePage?: boolean;
+    isActive?: boolean;
+    parent?: string | null;
+    contentTypes?: SiteSchemaContentTypeDto[];
+}
+
+declare class SiteSchemaAdminService {
+    private restService;
+    apiName: string;
+    get: (config?: Partial<Rest.Config>) => rxjs.Observable<SiteSchemaDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteSchemaAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+type index_d$a_SiteSchemaAdminService = SiteSchemaAdminService;
+declare const index_d$a_SiteSchemaAdminService: typeof SiteSchemaAdminService;
+type index_d$a_SiteSchemaContentTypeDto = SiteSchemaContentTypeDto;
+type index_d$a_SiteSchemaDto = SiteSchemaDto;
+type index_d$a_SiteSchemaFieldDto = SiteSchemaFieldDto;
+type index_d$a_SiteSchemaPageDto = SiteSchemaPageDto;
+declare namespace index_d$a {
+  export { index_d$a_SiteSchemaAdminService as SiteSchemaAdminService };
+  export type { index_d$a_SiteSchemaContentTypeDto as SiteSchemaContentTypeDto, index_d$a_SiteSchemaDto as SiteSchemaDto, index_d$a_SiteSchemaFieldDto as SiteSchemaFieldDto, index_d$a_SiteSchemaPageDto as SiteSchemaPageDto };
+}
+
+declare namespace index_d$9 {
+  export {
+    index_d$e as ContentTypes,
+    index_d$d as Contents,
+    index_d$c as Fields,
+    index_d$h as Files,
+    index_d$b as Pages,
+    index_d$a as Schema,
+  };
+}
+
+type index_d$8_ContentTypeDto = ContentTypeDto;
+type index_d$8_ContentTypeFieldDto = ContentTypeFieldDto;
+declare namespace index_d$8 {
+  export type { index_d$8_ContentTypeDto as ContentTypeDto, index_d$8_ContentTypeFieldDto as ContentTypeFieldDto };
+}
+
+type index_d$7_ContentDto = ContentDto;
+type index_d$7_ContentStatus = ContentStatus;
+declare const index_d$7_ContentStatus: typeof ContentStatus;
+declare const index_d$7_contentStatusOptions: typeof contentStatusOptions;
+declare namespace index_d$7 {
+  export { index_d$7_ContentStatus as ContentStatus, index_d$7_contentStatusOptions as contentStatusOptions };
+  export type { index_d$7_ContentDto as ContentDto };
+}
+
+type index_d$6_FieldDto = FieldDto;
+type index_d$6_FieldTypeDto = FieldTypeDto;
+type index_d$6_FieldValuePropertyDto = FieldValuePropertyDto;
+declare namespace index_d$6 {
+  export type { index_d$6_FieldDto as FieldDto, index_d$6_FieldTypeDto as FieldTypeDto, index_d$6_FieldValuePropertyDto as FieldValuePropertyDto };
+}
+
+type index_d$5_PageDto = PageDto;
+declare namespace index_d$5 {
+  export type { index_d$5_PageDto as PageDto };
+}
+
+declare namespace index_d$4 {
+  export {
+    index_d$9 as Admin,
+    index_d$8 as ContentTypes,
+    index_d$7 as Contents,
+    index_d$6 as Fields,
+    index_d$5 as Pages,
+  };
+}
+
+declare namespace index_d$3 {
+  export {
+    index_d$f as Abp,
+    index_d$4 as Site,
+  };
+}
+
+type index_d$2_IRemoteStreamContent = IRemoteStreamContent;
+declare namespace index_d$2 {
+  export type { index_d$2_IRemoteStreamContent as IRemoteStreamContent };
+}
+
+declare namespace index_d$1 {
+  export {
+    index_d$2 as Content,
+  };
+}
+
+declare namespace index_d {
+  export {
+    index_d$1 as Abp,
+  };
+}
+
+/**
+ * Flattens a content-list query into the shape ASP.NET Core's model binder actually reads.
+ *
+ * `GET /api/site-admin/contents` binds `GetContentListInput` from the query string, and that input
+ * carries `FlexFieldConditions: List<FlexFieldQueryCondition>` - a collection of complex objects.
+ * ASP.NET Core binds those only from indexed keys (`flexFieldConditions[0].fieldId=...`), whereas the
+ * generated proxy hands the array straight to `RestService`, which builds an `HttpParams` via
+ * `{ fromObject }`. Angular stringifies each element, so the server receives
+ * `flexFieldConditions=[object Object]` and every condition is silently dropped - no error, just
+ * unfiltered results. Hence this translation rather than using the generated `getList`.
+ *
+ * The flex-fields demo does not need an equivalent because its list endpoint is a POST with a body
+ * (`/api/app/product/search`); Site's is a GET, so the conditions have to survive the query string.
+ */
+declare function toContentListParams(input: GetContentListInput): Record<string, unknown>;
+
+interface ContentListState {
+    filters: GetContentListInput;
+    appliedConditions: FlexFieldQueryCondition[];
+    /** Raw `flexFieldSearch` form value, keyed by field name - what each search widget should redisplay. */
+    searchValues: Record<string, unknown>;
+    page: number;
+    sortKey: string | number;
+    sortOrder: string;
+    maxResultCount: number;
+}
+/**
+ * Remembers the content list's filters, search conditions and paging across a round trip to the
+ * create/edit page and back.
+ *
+ * `ContentsComponent` is destroyed on every route change - editing a content is a full page
+ * (`content-editor.component.ts`), not a dialog - so without this, `filters`, the applied flex-field
+ * search and the `ListService` it owns would all reset to their defaults every time an admin finishes
+ * editing and returns to the list.
+ *
+ * In-memory rather than the URL: `flexFieldConditions` covers arbitrary per-content-type fields, and
+ * round-tripping that shape through query params would need close to as much code as the search feature
+ * itself. Losing the snapshot on a hard refresh is an acceptable trade for an admin filter, unlike a
+ * shareable resource link.
+ */
+declare class ContentListStateService {
+    private snapshot?;
+    save(state: ContentListState): void;
+    restore(): ContentListState | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentListStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Stands in for `ContentAdminService.getList` alone. Everything else on the generated proxy is used
+ * directly - only the list call needs `flexFieldConditions` flattened before it reaches `RestService`
+ * (see {@link toContentListParams}). Kept here rather than patched into `proxy/` so that re-running
+ * `abp generate-proxy` cannot quietly revert the fix.
+ */
+declare class ContentQueryService {
+    private readonly restService;
+    readonly apiName = "SiteAdmin";
+    getList: (input: GetContentListInput, config?: Partial<Rest.Config>) => rxjs.Observable<PagedResultDto<ContentDto>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentQueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * The reference data every screen needs but none of them owns: the site's enabled languages, the whole
+ * field library, and which field types can be indexed. Each is fetched once and replayed; call the
+ * matching `invalidate*` after a write that would change it.
+ *
+ * **On the schema endpoint.** `GET /api/site-admin/schema` is keyed by *name* all the way down -
+ * `SiteSchemaContentTypeDto` and `SiteSchemaFieldDto` carry no id. That shape exists for MCP, which
+ * addresses everything by name. The admin UI cannot resolve a content type's fields through it, because
+ * a `ContentDto` identifies its type only by `contentTypeId` (a Guid) and there is nothing to join a
+ * Guid to a name on. So the schema is used here for site-level settings only; field resolution goes
+ * through {@link getFieldsById}, joined against `ContentTypeDto.fields[].fieldId`.
+ */
+declare class SiteReferenceDataService {
+    private readonly schemaService;
+    private readonly fieldService;
+    private readonly contentTypeService;
+    private schemaCache?;
+    private fieldsCache?;
+    private indexableCache?;
+    private contentTypesCache?;
+    /** Site-level settings. `enabledLanguages[0]` is the default language. */
+    getSchema(): Observable<SiteSchemaDto>;
+    /** The whole field library keyed by id - `ContentTypeFieldDto` carries only `fieldId`. */
+    getFieldsById(): Observable<Map<string, FieldDto>>;
+    /**
+     * Whether a field type has a query-index slot at all, keyed by field type name. Straight from the
+     * server: the answer is `IFieldType.IndexValueType`, and the Angular flex-fields library deliberately
+     * does not restate it. A type that answers `false` can never be searched however its `searchable` flag
+     * is set - `FlexFieldIndexManagerBase.GetIndexableFieldsAsync` skips it regardless.
+     */
+    getIndexableByFieldType(): Observable<Map<string, boolean>>;
+    /**
+     * Every content type, across every page, keyed by id - `ContentDto` carries only `contentTypeId`, and
+     * `ContentTypeAdminService.getListByPage` alone cannot resolve a name for a row whose page is not the
+     * one currently selected in a filter.
+     */
+    getContentTypesById(): Observable<Map<string, ContentTypeDto>>;
+    invalidateFields(): void;
+    invalidateSchema(): void;
+    invalidateContentTypes(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteReferenceDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * No `admin` path segment (unlike Dignite.Cms's `/cms/admin/...`): the public tier has no Angular UI,
+ * so every route here is an admin route and the extra segment would carry no information.
+ *
+ * The parent deliberately has no `pathMatch: 'full'`. It did while this library was a stub, which
+ * would have stopped any child route from ever matching.
+ */
+declare const SITE_ROUTES: Routes;
+
+export { CONTENT_FIELD_TYPE, CONTENT_FIELD_TYPE_NAME, ContentConfigComponent, ContentConfiguration, ContentControlComponent, ContentListStateService, ContentQueryService, ContentViewComponent, index_d$3 as Dignite, FILE_FIELD_CONFIGURATION_NAMES, FILE_FIELD_TYPE, FILE_FIELD_TYPE_NAME, FileConfigComponent, FileControlComponent, FileDirectoryTreeComponent, FileFieldConfiguration, FileModalComponent, FilePickerComponent, FilePreviewComponent, FileUploadComponent, FileViewComponent, FormatFileSizePipe, IMAGE_TYPE_OPTIONS, MY_FILES_NODE_KEY, ObjectUrlService, SEO_FIELD_TYPE, SEO_FIELD_TYPE_NAME, SITE_FILE_CONTAINER_NAMES, SITE_FILE_PATH, SITE_IMAGES_CONTAINER_NAME, SITE_ROUTES, SeoConfigComponent, SeoConfiguration, SeoControlComponent, SeoViewComponent, SiteCKEditorUploadProvider, SiteFileUrlService, SiteReferenceDataService, ValidatorsService, index_d as Volo, absoluteFileUrl, eSitePolicyNames, isMyFilesNode, isSiteFileUrl, siteCKEditorConfigContributor, siteCKEditorDisplayContributor, sizedFileUrl, toContentListParams };
+export type { ContentListState, DirectoryTreeNode, FileTypeIcon, FileUploadChangeEvent, SeoFieldValue };