import * as _angular_forms from '@angular/forms';
import { FormGroup, FormControl, FormBuilder, FormArray, AbstractControl } from '@angular/forms';
import * as ichec_angular_core from 'ichec-angular-core';
import { BehaviorSubject, Observable } from 'rxjs';
import { HttpClient, HttpParams, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
import * as _angular_core from '@angular/core';
import { InjectionToken, OnInit, TemplateRef, AfterViewInit } from '@angular/core';
import { CookieService } from 'ngx-cookie-service';
import { Location } from '@angular/common';
import { ActivatedRoute, UrlSerializer } from '@angular/router';
import { MatDialog } from '@angular/material/dialog';
import { MatSnackBar } from '@angular/material/snack-bar';
import { MatTable } from '@angular/material/table';
import { MatSort } from '@angular/material/sort';
import { MatButtonToggleChange } from '@angular/material/button-toggle';
import { DataSource, CollectionViewer, ListRange } from '@angular/cdk/collections';
import { MatPaginator } from '@angular/material/paginator';
import { MatSidenavContent } from '@angular/material/sidenav';

interface Identifiable {
    id: number;
    url: string;
}
interface IPaginated<T extends Identifiable> {
    count: number;
    next: string | null;
    previous: string | null;
    results: T[];
}
declare class Paginated<T extends Identifiable> implements IPaginated<T> {
    count: number;
    next: null;
    previous: null;
    results: T[];
}
interface IPermission extends Identifiable {
    codename: string;
}
declare class Permission {
    static typename: string;
    static plural: string;
}
interface IForm<C, D, U = D> {
    form: FormGroup;
    setValue(item: D): void;
    createItem(): C;
    updateItem(item: D): U;
}

interface IMemberIdentifierBase {
    id_type: string;
    value: string;
}
type IMemberIdentifierCreate = IMemberIdentifierBase;
interface IMemberIdentifierDetail extends IMemberIdentifierBase {
    id: number;
}
interface IPreferences {
    notifications: string;
}
interface IFeedbackCreate {
    comments: string;
}
interface IFeedbackDetail extends Identifiable {
    comments: string;
}
declare class Feedback {
    static typename: string;
    static plural: string;
}
interface IPortalMemberBase {
    username: string;
    email: string;
    first_name: string;
    last_name: string;
    phone: string;
    preferences: IPreferences | null;
}
interface IPortalMemberCreate extends IPortalMemberBase {
    identifiers: IMemberIdentifierCreate[];
}
interface IPortalMemberList extends IPortalMemberBase, Identifiable {
    organization: string;
    profile: string | null;
    profile_thumbnail: string | null;
    permissions: string[];
    identifiers: IMemberIdentifierDetail[];
    verified: boolean;
}
interface IMemberInvitation {
    user_first_name: string;
    user_last_name: string;
    user_email: string;
    invite_type: string;
    resource_id: number | null;
    action_url: string;
}
type IPortalMemberDetail = IPortalMemberList;
declare class PortalMember {
    static typename: string;
    static plural: string;
    static getInitials(member: IPortalMemberDetail): string;
}

interface IGroupBase {
    name: string;
    user_set: string[];
}
type IGroupCreate = IGroupBase;
interface IGroupList extends IGroupBase, Identifiable {
}
type IGroupDetail = IGroupList;
declare class Group {
    static typename: string;
    static plural: string;
}

interface ICountry {
    name: string;
    code: string;
    flag: string;
}
interface IAddressBase {
    line1: string;
    line2: string | null;
    line3: string | null;
    city: string | null;
    region: string;
    postcode: string | null;
    country: string;
}
type IAddressCreate = IAddressBase;
interface IAddressList extends IAddressBase, Identifiable {
    country_name: string;
    country_flag: string;
}
type IAddressDetail = IAddressList;
declare class Address {
    static typename: string;
    static plural: string;
}

interface IOrganizationBase {
    name: string;
    acronym: string;
    description: string;
    website: string;
    members: string[];
    public: boolean;
}
interface IOrganizationCreate extends IOrganizationBase {
    address: IAddressCreate;
}
interface IOrganizationList extends IOrganizationBase, Identifiable {
    address: string;
}
interface IOrganizationDetail extends IOrganizationBase, Identifiable {
    address: IAddressDetail;
}
declare class Organization {
    static typename: string;
    static plural: string;
}

interface IItemQuery {
    queries: Map<string, string>;
    page: number;
    page_size: number;
    sort_field: string;
    sort_order: string;
    filter: string;
}
declare class ItemQuery {
    queries: Map<string, string>;
    page: number;
    page_size: number;
    sort_field: string;
    sort_order: string;
    filter: string;
    constructor(params?: Partial<IItemQuery>);
}
declare enum ErrorCode {
    UnknownError = 1
}
declare class ApiError {
    code: ErrorCode;
    text: string;
}
interface OptionActionChoice {
    value: string;
    display_name: string;
}
interface OptionAction {
    label: string;
    type: string;
    required: boolean;
    read_only: boolean;
    max_length?: number;
    choices?: OptionActionChoice[];
    children: OptionAction[];
}
interface IRestOptions {
    name: string;
    description: string;
    renders: string[];
    parses: string[];
    actions?: Record<string, Record<string, OptionAction>>;
}

interface IFileRecord {
    name: string;
    display_name: string;
    file_type: string;
    file: File | null;
    remote: string;
    local: string | ArrayBuffer;
}
declare class FileRecord {
    name: string;
    display_name: string;
    file_type: string;
    file: File | null;
    remote: string;
    local: string | ArrayBuffer;
    constructor(params?: Partial<IFileRecord>);
}

interface TypeChoice {
    value: string;
    display_name: string;
}
declare enum FieldType {
    Boolean = 0,
    Char = 1,
    Text = 2,
    RichText = 3,
    Selection = 4,
    Integer = 5,
    File = 6,
    Undefined = 7
}
declare const FORM_FIELD_CHOICES: TypeChoice[];
declare function getFieldTypeFromKey(key: string): FieldType;
interface IFormFieldBase {
    label: string;
    key: string;
    required: boolean;
    order: number;
    field_type: string;
    description: string;
    tooltip: string;
    default: string;
    options: string | null;
}
type IFormFieldCreate = IFormFieldBase;
interface IFormFieldDetail extends IFormFieldBase {
    id: number;
    template: string | null;
}
interface IFormGroupBase {
    label: string | null;
    description: string | null;
    order: number;
}
interface IFormGroupCreate extends IFormGroupBase {
    fields: IFormFieldCreate[];
}
interface IFormGroupDetail extends IFormGroupBase {
    id: number;
    fields: IFormFieldDetail[];
}
interface IFormGroupUpdate extends IFormGroupBase {
    id: number;
    fields: IFormFieldBase[];
}
interface IFormCreate {
    groups: IFormGroupCreate[];
}
interface IFormDetail {
    id: number;
    groups: IFormGroupDetail[];
}
interface IFormUpdate {
    id: number;
    groups: IFormGroupBase[];
}
interface IFileField {
    id: number;
    file: IFileRecord;
}
declare function getFileFieldIds(form: IFormDetail): number[];
interface IFormFieldValueBase {
    value: string;
    asset: string | null;
}
interface IFormFieldValueCreate extends IFormFieldValueBase {
    field: number;
}
interface IFormFieldValueUpdate extends IFormFieldValueBase {
    id: number;
    field: number;
}
interface IFormFieldValueDetail extends IFormFieldValueBase {
    id: number;
    field: IFormFieldDetail;
}
interface IPopulatedFormCreate {
    values: IFormFieldValueCreate[];
}
interface IPopulatedFormDetail {
    id: number;
    values: IFormFieldValueDetail[];
}
interface IPopulatedFormUpdate {
    id: number;
    values: IFormFieldValueUpdate[];
}
interface IFilterChoice {
    display_name: string;
    value: string;
}
interface ISortField {
    display_name: string;
    value: string;
}
interface IFilter {
    display_name: string;
    key: string;
    type: string;
    tooltip: string;
    choices: IFilterChoice[];
    default: string | null;
    include_if_null: boolean;
}
interface IFilterRow {
    filters: IFilter[];
}
interface IFilters {
    rows: IFilterRow[];
}
interface IQuery {
    key: string;
    value: string;
}
interface ISearchFields {
    filter: IFilters;
    sortFields: ISortField[];
    defaultQueries: IQuery[];
    pageSize: number;
    pageSizeOptions: number[];
}
declare class SearchFields {
    filter: {
        rows: never[];
    };
    sortFields: never[];
    defaultQueries: never[];
    pageSize: number;
    pageSizeOptions: number[];
    constructor(params?: Partial<ISearchFields>);
}
declare function getFilter(filters: IFilters, key: string): IFilter | null;

interface LeftNavOption {
    name: string;
    route: string;
}
interface LeftNavCategory {
    name: string;
    options: LeftNavOption[];
}

interface RestServiceConfig {
    endpoint_url: string;
    self_url: string;
    auth_type: string;
}
interface IRequestBase {
    headers: HttpHeaders;
    credentials: RequestCredentials;
    params: HttpParams;
}
interface IServerManifest {
    login_url: string;
    logout_url: string;
    docs_url: string;
    supports_cors: boolean;
}
declare const REST_SERVICE_CONFIG: InjectionToken<RestServiceConfig>;
declare class RestService<D extends Identifiable, L extends Identifiable = D, C = D, U extends Identifiable = D> {
    manifest: BehaviorSubject<IServerManifest | null>;
    loggedInUser: BehaviorSubject<ichec_angular_core.IPortalMemberList | null>;
    loginFailed: BehaviorSubject<boolean>;
    readonly _url: string;
    readonly userQuery = "user";
    config: RestServiceConfig;
    protected document: Document;
    protected _http: HttpClient;
    protected cookieService: CookieService;
    deleteItem(id: number): Observable<void>;
    getForUser(user: IPortalMemberDetail, query?: IItemQuery): Observable<IPaginated<L>>;
    protected _getServiceManifest(): Observable<IServerManifest>;
    get(query?: IItemQuery): Observable<IPaginated<L>>;
    getItem(id: number): Observable<D>;
    getUrl(url: string): Observable<D>;
    getPaginatedUrl(url: string): Observable<IPaginated<L>>;
    getOptions(): Observable<IRestOptions>;
    putItem(item: U, content_type?: string): Observable<D>;
    patchItemMedia(id: number, form: FormData): Observable<D>;
    postFile(id: number, field: string, file: File): Observable<D>;
    putFile(id: number, field: string, file: File): Observable<D>;
    putFileStandalone(url: string, file: File): Observable<void>;
    patchItem(item: U, include_keys: string[], exclude_keys: string[]): Observable<D>;
    postItem(item: C): Observable<D>;
    private getHeaders;
    protected get baseUrl(): string;
    private get mediaUrl();
    protected getRequestBase(content_type?: string, params?: HttpParams, file?: string, xhr?: boolean): IRequestBase;
    handleError(error: HttpErrorResponse): Observable<never>;
}

declare class ItemService<D extends Identifiable, L extends Identifiable = D, C = D, U extends Identifiable = D> extends RestService<D, L, C, U> {
    typenamePlural: string;
    typename: string;
    canEdit(): boolean;
    canCreate(): boolean;
    canDelete(): boolean;
    canView(): boolean;
    typePlural(): string;
    get typeTitleCase(): string;
}

declare class ResolvedPermission {
    canEdit: boolean;
    canAdd: boolean;
    canView: boolean;
    canDelete: boolean;
}
interface ILogoutManifest {
    url: string;
}
declare class UserService extends ItemService<IPortalMemberDetail, IPortalMemberList, IPortalMemberCreate> {
    /**
    Service to handle IPortalMember via REST and also handle logins.
    */
    readonly _url: string;
    typename: string;
    private permissions;
    login(next?: string): void;
    logout(next?: string): void;
    _logout_redirect(manifest: ILogoutManifest): void;
    getSelf(): Observable<IPortalMemberDetail | null>;
    canCreate(): boolean;
    inviteMember(invite: IMemberInvitation): Observable<IPortalMemberDetail>;
    private _getSelf;
    private _selfFetchFailed;
    private _do_login;
    hasAddPermission(feature: string): boolean;
    hasDeletePermission(feature: string): boolean;
    hasEditPermission(feature: string): boolean;
    hasViewPermission(feature: string): boolean;
    private onSelf;
    private parsePermission;
    private processPermissions;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UserService>;
}

declare class ItemWithUserService<D extends Identifiable, L extends Identifiable = D, C = D, U extends Identifiable = D> extends ItemService<D, L, C, U> {
    protected userService: UserService;
    userItems: BehaviorSubject<L[]>;
    constructor();
    canCreate(): boolean;
    canView(): boolean;
    canEdit(): boolean;
    canDelete(): boolean;
    private permissionName;
    getUserItems(): Observable<IPaginated<L>>;
    protected refreshUserItems(user: IPortalMemberDetail | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemWithUserService<any, any, any, any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ItemWithUserService<any, any, any, any>>;
}

interface IFieldFile {
    id: number;
    asset: IFileRecord;
}
declare class FormService {
    static getBaseTemplate(): IFileRecord;
    toFormGroup(form: IFormDetail): FormGroup<any>;
    createFieldValue(key: string, control: FormControl, input: IFormDetail): IFormFieldValueCreate;
    createItem(form: FormGroup, input: IFormDetail): IPopulatedFormCreate;
    getValueId(field_id: number, populated: IPopulatedFormDetail): number;
    getFiles(form: FormGroup, input: IFormDetail, populated: IPopulatedFormDetail): IFieldFile[];
    hasRequiredFiles(form: FormGroup, input: IFormDetail): boolean;
    updateFieldValue(control: FormControl, item: IFormFieldValueDetail): IFormFieldValueUpdate;
    getType(key: string, input: IFormDetail): string;
    isRequired(key: string, input: IFormDetail): boolean;
    getValue(key: string, item: IPopulatedFormDetail): IFormFieldValueDetail | null;
    updateItem(form: FormGroup, item: IPopulatedFormDetail): IPopulatedFormUpdate;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FormService>;
}

interface NavOption {
    name: string;
    route: string;
    icon: string;
}
interface NavGrouping {
    name: string;
    options: NavOption[];
}
interface NavGroup {
    name: string;
    groupings: NavGrouping[];
}
declare class LeftNavService {
    activeGroupings: _angular_core.WritableSignal<Set<NavGrouping>>;
    wide: _angular_core.WritableSignal<boolean>;
    private _defaultGroupings;
    private _groups;
    private _groupService;
    constructor();
    onGroupsUpdated(groups: IGroupList[]): void;
    setDefaultGroupings(groupings: NavGrouping[]): void;
    setGroups(groups: NavGroup[]): void;
    toggle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeftNavService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LeftNavService>;
}

declare class GroupService extends ItemWithUserService<IGroupDetail, IGroupList, IGroupCreate> {
    readonly _url: string;
    typename: string;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GroupService>;
}

declare class OrganizationService extends ItemWithUserService<IOrganizationDetail, IOrganizationList, IOrganizationCreate> {
    readonly _url: string;
    typename: string;
    countryOptions: _angular_core.WritableSignal<ICountry[]>;
    refreshCountryOptions(): void;
    protected onOptions(options: IRestOptions): void;
    protected onAddressOption(option: OptionAction): void;
    protected onPostActions(actions: Record<string, OptionAction>): void;
    protected onCountryChoices(choices: OptionActionChoice[]): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrganizationService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OrganizationService>;
}

declare class MockItemService {
    canEdit(): boolean;
    canDelete(): boolean;
    canCreate(): boolean;
    typePlural(): string;
}

declare abstract class DetailView<D extends Identifiable, L extends Identifiable, C = D, U extends Identifiable = D> {
    protected item: _angular_core.WritableSignal<D | null>;
    protected route: ActivatedRoute;
    protected userService: UserService;
    protected itemService: ItemService<D, L, C, U>;
    protected location: Location;
    protected urlSerializer: UrlSerializer;
    readonly deleteDialog: MatDialog;
    protected requiresLogin: boolean;
    constructor(itemService: ItemService<D, L, C, U>);
    onInit(embedded?: boolean, requiresLogin?: boolean): void;
    onLoginFailed(): void;
    onSelection(id: number | null): void;
    title(): string;
    onItemAvailable(item: D): void;
    onItemAndUserAvailable(_item: D, _user: IPortalMemberDetail): void;
    onDeleteClicked(): void;
    onDelete(): void;
    goBack(): void;
    protected canEdit(): boolean;
    protected canDelete(): boolean;
    private _getItem;
}

declare class FeedbackService extends ItemWithUserService<IFeedbackDetail, IFeedbackDetail, IFeedbackCreate> {
    readonly _url: string;
    typename: string;
    sendError(e: HttpErrorResponse): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeedbackService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FeedbackService>;
}

declare abstract class EditView<D extends Identifiable, L extends Identifiable, C = D, U extends Identifiable = D> {
    createMode: _angular_core.WritableSignal<boolean>;
    heading: _angular_core.Signal<string>;
    submitting: _angular_core.WritableSignal<boolean>;
    errorType: _angular_core.WritableSignal<string>;
    protected item: _angular_core.WritableSignal<D | null>;
    protected fileKeys: string[];
    protected _route: ActivatedRoute;
    protected _location: Location;
    protected _userService: UserService;
    protected feedbackService: FeedbackService;
    protected form: IForm<C, D, U>;
    protected itemService: ItemService<D, L, C, U>;
    protected snackBar: MatSnackBar;
    private uploadedFiles;
    constructor(itemService: ItemService<D, L, C, U>, form: IForm<C, D, U>);
    onInit(): void;
    onItemAvailable(item: D): void;
    onItemAndUserAvailable(_item: D, _user: IPortalMemberDetail): void;
    goBack(): void;
    submit(): void;
    save(): void;
    cancel(): void;
    getTitle(): string;
    protected fetchRestOptions(): void;
    protected onUploadedFileReady(_file: File): void;
    protected onFileRead(_content: string | ArrayBuffer): void;
    protected createItem(): C;
    protected updateItem(item: D): U;
    protected postItem(): void;
    protected onPostError(e: HttpErrorResponse): void;
    protected onPostErrorSnackBar(_e: HttpErrorResponse): void;
    protected putItem(item: D): void;
    protected onPutError(e: HttpErrorResponse): void;
    protected onPutErrorSnackBar(_e: HttpErrorResponse): void;
    protected saveFiles(item: D): void;
    saveFile(item: D, record: IFileRecord): void;
    getNextFileForUpload(): IFileRecord | null;
    onPutFileError(e: HttpErrorResponse): void;
    onPutFileErrorSnackbar(_e: HttpErrorResponse): void;
    private isCreateRoute;
    private getItem;
    protected onItemUpdated(item: D): void;
    protected postItemUpdated(): void;
    protected onOptions(options: IRestOptions): void;
    protected onPostActions(_actions: Record<string, OptionAction>): void;
}

interface TableColumn {
    name: string;
    title: string;
    element_type: string;
}

interface Selectable<T extends Identifiable> {
    title: string;
    item: T;
}
declare class SelectTableComponent<T extends Identifiable> implements OnInit {
    itemType: _angular_core.InputSignal<string>;
    selected: _angular_core.InputSignal<T[]>;
    options: _angular_core.InputSignal<Selectable<T>[]>;
    columns: _angular_core.InputSignal<TableColumn[]>;
    itemAdded: _angular_core.OutputEmitterRef<string>;
    itemRemoved: _angular_core.OutputEmitterRef<number>;
    searchChanged: _angular_core.OutputEmitterRef<string | null>;
    itemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null | undefined>;
    columnNames: _angular_core.Signal<string[]>;
    searchControl: FormControl<string | null>;
    table: _angular_core.Signal<MatTable<any> | undefined>;
    ngOnInit(): void;
    remove(id: number): void;
    add(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectTableComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectTableComponent<any>, "lib-select-table", never, { "itemType": { "alias": "itemType"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; }, { "itemAdded": "itemAdded"; "itemRemoved": "itemRemoved"; "searchChanged": "searchChanged"; }, never, never, true, never>;
}

declare abstract class SelectionManager<D extends Identifiable, L extends Identifiable = D, C = D, U extends Identifiable = D> {
    candidates: _angular_core.WritableSignal<Selectable<L>[]>;
    dirty: _angular_core.WritableSignal<boolean>;
    selected: _angular_core.WritableSignal<L[]>;
    columns: TableColumn[];
    itemService: ItemService<D, L, C, U>;
    constructor(itemService: ItemService<D, L, C, U>);
    fetchCandidates(item: string, id: number): void;
    protected updateCandidates(items: IPaginated<L>): void;
    abstract toSelectable(item: L): Selectable<L>;
    onRemoved(id: number): string;
    onAdded(title: string): string;
    abstract hasTitle(item: L, title: string): boolean;
    onSearchChanged(searchTerm: string | null): void;
}
declare class MemberSelectionManager extends SelectionManager<IPortalMemberDetail> {
    columns: TableColumn[];
    constructor();
    toSelectable(item: IPortalMemberDetail): Selectable<IPortalMemberDetail>;
    hasTitle(item: IPortalMemberDetail, title: string): boolean;
}

declare class BackButtonComponent {
    protected location: Location;
    protected goBack(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BackButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BackButtonComponent, "lib-back-button", never, {}, {}, never, never, true, never>;
}

declare class DetailHeaderComponent {
    id: _angular_core.InputSignal<number>;
    text: _angular_core.InputSignal<string>;
    route: _angular_core.InputSignal<string>;
    canEdit: _angular_core.InputSignal<boolean>;
    canDelete: _angular_core.InputSignal<boolean>;
    deleteClicked: _angular_core.OutputEmitterRef<void>;
    fullRoute: _angular_core.Signal<string>;
    deleteClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DetailHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DetailHeaderComponent, "lib-detail-header", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "route": { "alias": "route"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "canDelete": { "alias": "canDelete"; "required": false; "isSignal": true; }; }, { "deleteClicked": "deleteClicked"; }, never, never, true, never>;
}

interface ISearchForm {
    sortAscending: FormControl<boolean | null>;
    sortField: FormControl<string | null>;
    search: FormControl<string | null>;
    pageSize: FormControl<number | null>;
    filters: FormGroup;
}
declare class SearchForm {
    form: FormGroup<ISearchForm>;
    searchFields: ISearchFields;
    constructor(searchFields: ISearchFields, fb: FormBuilder);
    get filterControls(): {
        [key: string]: _angular_forms.AbstractControl<any, any, any>;
    };
    resetFilters(): void;
    toQuery(): IItemQuery;
}

declare class SearchBarComponent {
    itemType: _angular_core.InputSignal<string>;
    showFilters: _angular_core.WritableSignal<boolean>;
    form: _angular_core.InputSignal<SearchForm>;
    get searchControl(): FormControl;
    get sortControl(): FormControl;
    clearFilters(): void;
    toggleFilterVisibility(): void;
    clearSearch(): void;
    toggleSortOrder(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchBarComponent, "lib-search-bar", never, { "itemType": { "alias": "itemType"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FileUploadComponent {
    control: _angular_core.InputSignal<FormControl<IFileRecord>>;
    uploadCategory: _angular_core.InputSignal<string>;
    allowedSizeMb: _angular_core.InputSignal<number>;
    showHeading: _angular_core.InputSignal<boolean>;
    error: _angular_core.WritableSignal<string>;
    get accepts(): string;
    get acceptTitle(): string;
    get maxSize(): string;
    protected onFileUpload(event: Event): void;
    isImage(): boolean;
    protected onFileUploaded(file: File): void;
    protected onPreviewLoaded(preview: string | ArrayBuffer): void;
    protected onClearLocal(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploadComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploadComponent, "lib-file-upload", never, { "control": { "alias": "control"; "required": true; "isSignal": true; }; "uploadCategory": { "alias": "uploadCategory"; "required": false; "isSignal": true; }; "allowedSizeMb": { "alias": "allowedSizeMb"; "required": false; "isSignal": true; }; "showHeading": { "alias": "showHeading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IOption {
    key: string;
    value: string;
}
interface IFormFieldForm {
    label: FormControl<string | null>;
    key: FormControl<string | null>;
    required: FormControl<boolean | null>;
    description: FormControl<string | null>;
    tooltip: FormControl<string | null>;
    template: FormControl<IFileRecord | null>;
    options: FormControl<IOption[] | null>;
    default: FormControl<string | null>;
    field_type: FormControl<string | null>;
    order: FormControl<number | null>;
    id: FormControl<number | null>;
}

declare class FormFieldDetailComponent {
    readonly field: _angular_core.InputSignal<IFormFieldDetail>;
    form: _angular_core.InputSignal<FormGroup<any>>;
    resolveOptions(options: string | null): IOption[];
    get key(): string;
    get control(): FormControl<IFileRecord>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldDetailComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldDetailComponent, "lib-form-field-detail", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FormFieldEditComponent {
    availableTypes: ichec_angular_core.TypeChoice[];
    readonly FieldType: typeof FieldType;
    readonly deleteDialog: MatDialog;
    protected table: _angular_core.Signal<MatTable<any> | undefined>;
    protected keyControl: FormControl<string | null>;
    protected valueControl: FormControl<string | null>;
    form: _angular_core.InputSignal<FormGroup<IFormFieldForm>>;
    canOrderUp: _angular_core.InputSignal<boolean>;
    canOrderDown: _angular_core.InputSignal<boolean>;
    orderUp: _angular_core.OutputEmitterRef<void>;
    orderDown: _angular_core.OutputEmitterRef<void>;
    deleted: _angular_core.OutputEmitterRef<void>;
    get templateControl(): FormControl<IFileRecord>;
    get optionsControl(): FormControl<IOption[]>;
    get fieldType(): FieldType;
    onOrderUp(): void;
    onOrderDown(): void;
    onDelete(): void;
    onDeleteClicked(): void;
    addChoice(): void;
    removeOption(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldEditComponent, "lib-form-field-edit", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "canOrderUp": { "alias": "canOrderUp"; "required": false; "isSignal": true; }; "canOrderDown": { "alias": "canOrderDown"; "required": false; "isSignal": true; }; }, { "orderUp": "orderUp"; "orderDown": "orderDown"; "deleted": "deleted"; }, never, never, true, never>;
}

interface IFormGroupForm {
    label: FormControl<string | null>;
    description: FormControl<string | null>;
    order: FormControl<number | null>;
    id: FormControl<number | null>;
    fields: FormArray<FormGroup<IFormFieldForm>>;
}

interface IDynamicFormForm {
    groups: FormArray<FormGroup<IFormGroupForm>>;
}
declare class DynamicFormForm {
    fb: FormBuilder;
    form: FormGroup<IDynamicFormForm>;
    constructor();
    get groups(): FormArray<FormGroup<IFormGroupForm>>;
    groupSize(id: number): number;
    getFileFields(form: IFormDetail): IFileField[];
    orderUp(id: number): void;
    orderDown(id: number): void;
    reorder(id: number, newIndex: number): void;
    fieldOrderUp(group_id: number, id: number): void;
    fieldOrderDown(group_id: number, id: number): void;
    reorderField(group_id: number, id: number, newIndex: number): void;
    createGroup(group: FormGroup<IFormGroupForm>): void;
    deleteGroup(id: number): void;
    deleteField(group_id: number, field_id: number): void;
    reset(): void;
    setValue(item: IFormDetail): void;
    createItem(): IFormCreate;
    createOrUpdateGroup(form: FormGroup<IFormGroupForm>, items: IFormGroupBase[]): IFormGroupCreate | IFormGroupUpdate;
    updateItem(item: IFormDetail): IFormCreate | IFormUpdate;
}

interface IFormFieldValueForm {
    value: FormControl<string | null>;
    id: FormControl<number | null>;
    field: FormControl<number | null>;
}
declare class FormFieldValueForm {
    static createForm(fb: FormBuilder): FormGroup<IFormFieldValueForm>;
    static fromItem(item: IFormFieldValueDetail, builder: FormBuilder): FormGroup<IFormFieldValueForm>;
    static setValue(form: FormGroup<IFormFieldValueForm>, item: IFormFieldValueDetail): void;
    static createItem(form: FormGroup<IFormFieldValueForm>): IFormFieldValueCreate;
    static updateItem(form: FormGroup<IFormFieldValueForm>, item: IFormFieldValueDetail): IFormFieldValueDetail;
}

interface IPopulatedFormForm {
    values: FormArray<FormGroup<IFormFieldValueForm>>;
}
declare class PopulatedFormForm {
    fb: FormBuilder;
    form: FormGroup;
    constructor();
    get values(): FormArray<FormGroup<IFormFieldValueForm>>;
    reset(): void;
    setValue(item: IPopulatedFormDetail): void;
    createItem(): IPopulatedFormCreate;
    updateValue(form: FormGroup<IFormFieldValueForm>, items: IFormFieldValueBase[]): IFormFieldValueDetail;
    updateItem(item: IPopulatedFormDetail): IPopulatedFormDetail;
}

declare class DynamicFormComponent {
    private readonly formService;
    readonly inputForm: _angular_core.InputSignal<IFormDetail>;
    readonly form: _angular_core.Signal<FormGroup<any>>;
    payLoad: string;
    onSubmit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicFormComponent, "lib-dynamic-form", never, { "inputForm": { "alias": "inputForm"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IActiveGroup {
    index: number;
    group: FormGroup<IFormGroupForm>;
}
interface IActiveField {
    index: number;
    group_index: number;
    field: FormGroup<IFormFieldForm>;
}
declare class DynamicFormBuilderComponent {
    form: _angular_core.InputSignal<DynamicFormForm>;
    handleSubmit: _angular_core.InputSignal<boolean>;
    submitted: _angular_core.OutputEmitterRef<void>;
    dirty: _angular_core.WritableSignal<boolean>;
    activeGroup: _angular_core.WritableSignal<IActiveGroup | null>;
    activeField: _angular_core.WritableSignal<IActiveField | null>;
    fb: FormBuilder;
    onGroupClick(index: number, group: FormGroup<IFormGroupForm>): void;
    onFieldClick(index: number, group_index: number, field: FormGroup<IFormFieldForm>): void;
    protected getFields(group: FormGroup<IFormGroupForm>): FormArray<FormGroup<IFormFieldForm>>;
    isGroupSelected(id: number): boolean;
    isFieldSelected(group_id: number, id: number): boolean;
    getGroupLabel(control: AbstractControl): string;
    getFieldLabel(control: AbstractControl): string;
    allowOrderUp(): boolean;
    allowOrderDown(): boolean;
    allowGroupOrderUp(): boolean;
    allowGroupOrderDown(): boolean;
    onOrderUp(id: number): void;
    onOrderDown(id: number): void;
    addGroup(): void;
    addField(group: FormGroup<IFormGroupForm>): void;
    deleteGroup(id: number): void;
    deleteField(): void;
    onFieldOrderUp(): void;
    onFieldOrderDown(): void;
    onGroupOrderUp(): void;
    onGroupOrderDown(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicFormBuilderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicFormBuilderComponent, "lib-dynamic-form-builder", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "handleSubmit": { "alias": "handleSubmit"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, never, true, never>;
}

declare class PopulatedFormComponent {
    form: _angular_core.InputSignal<IPopulatedFormDetail>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopulatedFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopulatedFormComponent, "lib-populated-form", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ListDataSource<D extends Identifiable, L extends Identifiable, C = D, U extends Identifiable = D> extends DataSource<L> {
    length: _angular_core.WritableSignal<number>;
    loading: _angular_core.WritableSignal<boolean>;
    activeQuery: _angular_core.WritableSignal<IItemQuery>;
    hasFetched: _angular_core.WritableSignal<boolean>;
    sourceIsEmpty: _angular_core.Signal<boolean>;
    private consumerType;
    items: BehaviorSubject<L[]>;
    itemService: ItemService<D, L, C, U>;
    private subscription;
    private fetchedPages;
    private defaultQueries;
    constructor(itemService: ItemService<D, L, C, U>, consumerType?: string, defaultQueries?: IQuery[]);
    connect(collectionViewer: CollectionViewer): Observable<L[]>;
    hasTableConsumer(): boolean;
    onRange(range: ListRange): void;
    reset(query: IItemQuery): void;
    fetchPage(idx: number): void;
    fetch(query: IItemQuery): void;
    onResponse(response: IPaginated<L>): void;
    disconnect(): void;
}

declare class ListScrollViewComponent {
    itemHeight: _angular_core.InputSignal<number>;
    itemWidth: _angular_core.InputSignal<string>;
    dataSource: _angular_core.InputSignal<ListDataSource<any, any, any, any> | undefined>;
    listItemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null | undefined>;
    routerMode: _angular_core.InputSignal<boolean>;
    selection: _angular_core.WritableSignal<number | null>;
    selected: _angular_core.OutputEmitterRef<number | null>;
    onSelected(id: number | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListScrollViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListScrollViewComponent, "lib-list-scroll-view", never, { "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "itemWidth": { "alias": "itemWidth"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "listItemTemplate": { "alias": "listItemTemplate"; "required": false; "isSignal": true; }; "routerMode": { "alias": "routerMode"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
}

declare class ListViewComponent<D extends Identifiable, L extends Identifiable, C = D, U extends Identifiable = D> implements OnInit, AfterViewInit {
    viewType: _angular_core.InputSignal<string>;
    itemService: _angular_core.InputSignal<ItemService<D, L, C, U> | undefined>;
    listItemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    itemDetailTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    itemHeight: _angular_core.InputSignal<number>;
    itemWidth: _angular_core.InputSignal<number>;
    columns: _angular_core.InputSignal<TableColumn[]>;
    canCreateForceOff: _angular_core.InputSignal<boolean>;
    noSelfItemsMessage: _angular_core.InputSignal<string | undefined>;
    noItemsCanCreateMessage: _angular_core.InputSignal<string | undefined>;
    noItemsMessage: _angular_core.InputSignal<string | undefined>;
    searchFields: _angular_core.InputSignal<ISearchFields>;
    embeddedMode: _angular_core.InputSignal<boolean>;
    selectedViewType: _angular_core.WritableSignal<string>;
    selected: _angular_core.OutputEmitterRef<number | null>;
    protected route: ActivatedRoute;
    dataSource: ListDataSource<D, L, C, U> | undefined;
    sort: _angular_core.Signal<MatSort | undefined>;
    columnNames: _angular_core.Signal<string[]>;
    fb: FormBuilder;
    searchForm: _angular_core.WritableSignal<SearchForm>;
    scrollView: _angular_core.Signal<ListScrollViewComponent | undefined>;
    get resolvedItemWidth(): string;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    showControls(): boolean;
    canCreate(): boolean;
    itemType(): string;
    title(): string;
    isTableView(): boolean;
    resetDataSource(): void;
    onSearchItems(items: L[]): void;
    reset(): void;
    viewChanged(event: MatButtonToggleChange): void;
    onSelection(id: number | null): void;
    protected isSelfList(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListViewComponent<any, any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListViewComponent<any, any, any, any>, "lib-list-view", never, { "viewType": { "alias": "viewType"; "required": false; "isSignal": true; }; "itemService": { "alias": "itemService"; "required": false; "isSignal": true; }; "listItemTemplate": { "alias": "listItemTemplate"; "required": false; "isSignal": true; }; "itemDetailTemplate": { "alias": "itemDetailTemplate"; "required": false; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "itemWidth": { "alias": "itemWidth"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "canCreateForceOff": { "alias": "canCreateForceOff"; "required": false; "isSignal": true; }; "noSelfItemsMessage": { "alias": "noSelfItemsMessage"; "required": false; "isSignal": true; }; "noItemsCanCreateMessage": { "alias": "noItemsCanCreateMessage"; "required": false; "isSignal": true; }; "noItemsMessage": { "alias": "noItemsMessage"; "required": false; "isSignal": true; }; "searchFields": { "alias": "searchFields"; "required": true; "isSignal": true; }; "embeddedMode": { "alias": "embeddedMode"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
}

declare class ListTableViewComponent implements AfterViewInit {
    itemType: _angular_core.InputSignal<string>;
    columns: _angular_core.InputSignal<TableColumn[]>;
    dataSource: _angular_core.InputSignal<ListDataSource<any, any, any, any> | undefined>;
    searchFilter: _angular_core.InputSignal<string>;
    pageSizeOptions: number[];
    initialPageSize: number;
    columnNames: _angular_core.Signal<string[]>;
    sort: _angular_core.Signal<MatSort | undefined>;
    paginator: _angular_core.Signal<MatPaginator | undefined>;
    ngAfterViewInit(): void;
    reset(): void;
    fetch(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListTableViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListTableViewComponent, "lib-list-table-view", never, { "itemType": { "alias": "itemType"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "searchFilter": { "alias": "searchFilter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TopBarComponent {
    readonly title: _angular_core.InputSignal<string | undefined>;
    readonly logo: _angular_core.InputSignal<string | undefined>;
    readonly background: _angular_core.InputSignal<string | undefined>;
    readonly user: _angular_core.WritableSignal<ichec_angular_core.IPortalMemberList | null>;
    readonly loginRoute: _angular_core.InputSignal<string>;
    private userService;
    protected leftNavService: LeftNavService;
    constructor();
    onLogout(): void;
    onLogin(): void;
    get initials(): string;
    get backgroundStyle(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TopBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TopBarComponent, "lib-top-bar", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "logo": { "alias": "logo"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; "loginRoute": { "alias": "loginRoute"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LeftNavComponent {
    readonly background: _angular_core.InputSignal<string | undefined>;
    user: _angular_core.WritableSignal<ichec_angular_core.IPortalMemberList | null>;
    width: _angular_core.Signal<"200px" | "100px">;
    protected userService: UserService;
    protected leftNavService: LeftNavService;
    sideNavContent: _angular_core.Signal<MatSidenavContent | undefined>;
    constructor();
    getGroupings(): _angular_core.WritableSignal<Set<ichec_angular_core.NavGrouping>>;
    get backgroundStyle(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeftNavComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LeftNavComponent, "lib-left-nav", never, { "background": { "alias": "background"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FeedbackComponent extends EditView<IFeedbackDetail, IFeedbackDetail, IFeedbackCreate> implements OnInit {
    helpLink: _angular_core.WritableSignal<string>;
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeedbackComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FeedbackComponent, "lib-feedback", never, {}, {}, never, never, true, never>;
}

declare class AvatarComponent {
    text: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "lib-avatar", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class UserDetailComponent extends DetailView<IPortalMemberDetail, IPortalMemberList, IPortalMemberCreate> implements OnInit {
    showBack: _angular_core.InputSignal<boolean>;
    constructor();
    ngOnInit(): void;
    protected canEdit(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserDetailComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserDetailComponent, "lib-user-detail", never, { "showBack": { "alias": "showBack"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class UserEditComponent extends EditView<IPortalMemberDetail, IPortalMemberList, IPortalMemberCreate> implements OnInit {
    protected fileKeys: string[];
    constructor();
    ngOnInit(): void;
    get profileControl(): FormControl<IFileRecord>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserEditComponent, "lib-user-edit", never, {}, {}, never, never, true, never>;
}

interface IUserCreateForm {
    user_email: FormControl<string | null>;
    user_first_name: FormControl<string | null>;
    user_last_name: FormControl<string | null>;
}
declare class UserCreateForm {
    private type;
    private resource_id;
    private action_url;
    constructor(type?: string, resource_id?: number | null, action_url?: string);
    private fb;
    form: _angular_forms.FormGroup<{
        user_email: FormControl<string | null>;
        user_first_name: FormControl<string | null>;
        user_last_name: FormControl<string | null>;
    }>;
    createItem(): IMemberInvitation;
}

declare class UserCreateComponent {
    form: _angular_core.InputSignal<UserCreateForm>;
    embedded: _angular_core.InputSignal<boolean>;
    userService: UserService;
    submitted: _angular_core.OutputEmitterRef<void>;
    protected _location: Location;
    submit(): void;
    goBack(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserCreateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserCreateComponent, "lib-user-create", never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; "embedded": { "alias": "embedded"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, never, true, never>;
}

declare class UserComponent {
    itemService: UserService;
    detailView: _angular_core.Signal<UserDetailComponent | undefined>;
    searchFields: ISearchFields;
    onSelected(id: number | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserComponent, "lib-user", never, {}, {}, never, never, true, never>;
}

declare class GroupDetailComponent extends DetailView<IGroupDetail, IGroupList, IGroupCreate> implements OnInit {
    showBack: _angular_core.InputSignal<boolean>;
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupDetailComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupDetailComponent, "lib-group-detail", never, { "showBack": { "alias": "showBack"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GroupEditComponent extends EditView<IGroupDetail, IGroupList, IGroupCreate> implements OnInit {
    selectionManager: MemberSelectionManager;
    constructor();
    ngOnInit(): void;
    get showSubmit(): boolean;
    createItem(): IGroupCreate;
    protected updateItem(item: IGroupDetail): IGroupDetail;
    onItemAndUserAvailable(item: IGroupDetail, _: IPortalMemberDetail): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupEditComponent, "lib-group-edit", never, {}, {}, never, never, true, never>;
}

declare class GroupComponent {
    itemService: GroupService;
    detailView: _angular_core.Signal<GroupDetailComponent | undefined>;
    searchFields: ISearchFields;
    onSelected(id: number | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupComponent, "lib-group", never, {}, {}, never, never, true, never>;
}

declare class AddressEditComponent {
    countryOptions: _angular_core.InputSignal<ICountry[]>;
    form: _angular_core.InputSignal<FormGroup<any> | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddressEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddressEditComponent, "lib-address-edit", never, { "countryOptions": { "alias": "countryOptions"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AddressDetailComponent {
    address: _angular_core.InputSignal<ichec_angular_core.IAddressList | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddressDetailComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddressDetailComponent, "lib-address-detail", never, { "address": { "alias": "address"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IAddressForm {
    line1: FormControl<string | null>;
    line2: FormControl<string | null>;
    line3: FormControl<string | null>;
    city: FormControl<string | null>;
    region: FormControl<string | null>;
    postcode: FormControl<string | null>;
    country: FormControl<string | null>;
}
declare class AddressForm {
    static createForm(fb: FormBuilder): FormGroup<IAddressForm>;
    static fromItem(item: IAddressDetail, fb: FormBuilder): FormGroup<IAddressForm>;
    static setValue(form: FormGroup<IAddressForm>, item: IAddressDetail): void;
    static createItem(form: FormGroup<IAddressForm>): IAddressCreate;
    static updateItem(form: FormGroup<IAddressForm>, item: IAddressDetail): IAddressDetail;
}

declare class OrganizationDetailComponent extends DetailView<IOrganizationDetail, IOrganizationList, IOrganizationCreate> implements OnInit {
    showBack: _angular_core.InputSignal<boolean>;
    constructor();
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrganizationDetailComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrganizationDetailComponent, "lib-organization-detail", never, { "showBack": { "alias": "showBack"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OrganizationComponent {
    embedded: _angular_core.InputSignal<boolean>;
    itemService: OrganizationService;
    columns: TableColumn[];
    searchFields: _angular_core.InputSignal<ISearchFields>;
    detailView: _angular_core.Signal<OrganizationDetailComponent | undefined>;
    onSelected(id: number | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrganizationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrganizationComponent, "lib-organization", never, { "embedded": { "alias": "embedded"; "required": false; "isSignal": true; }; "searchFields": { "alias": "searchFields"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OrganizationEditComponent extends EditView<IOrganizationDetail, IOrganizationList, IOrganizationCreate> implements OnInit {
    selectionManager: MemberSelectionManager;
    constructor();
    ngOnInit(): void;
    get organizationService(): OrganizationService;
    addressForm(): FormGroup<IAddressForm>;
    get showSubmit(): boolean;
    createItem(): IOrganizationCreate;
    protected updateItem(item: IOrganizationDetail): IOrganizationDetail;
    onItemAndUserAvailable(item: IOrganizationDetail, _: IPortalMemberDetail): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrganizationEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrganizationEditComponent, "lib-organization-edit", never, {}, {}, never, never, true, never>;
}

export { Address, AddressDetailComponent, AddressEditComponent, AddressForm, ApiError, AvatarComponent, BackButtonComponent, DetailHeaderComponent, DetailView, DynamicFormBuilderComponent, DynamicFormComponent, DynamicFormForm, EditView, ErrorCode, FORM_FIELD_CHOICES, Feedback, FeedbackComponent, FieldType, FileRecord, FileUploadComponent, FormFieldDetailComponent, FormFieldEditComponent, FormFieldValueForm, FormService, Group, GroupComponent, GroupDetailComponent, GroupEditComponent, GroupService, ItemQuery, ItemService, ItemWithUserService, LeftNavComponent, LeftNavService, ListTableViewComponent, ListViewComponent, MemberSelectionManager, MockItemService, Organization, OrganizationComponent, OrganizationDetailComponent, OrganizationEditComponent, OrganizationService, Paginated, Permission, PopulatedFormComponent, PopulatedFormForm, PortalMember, REST_SERVICE_CONFIG, ResolvedPermission, RestService, SearchBarComponent, SearchFields, SelectTableComponent, SelectionManager, TopBarComponent, UserComponent, UserCreateComponent, UserCreateForm, UserDetailComponent, UserEditComponent, UserService, getFieldTypeFromKey, getFileFieldIds, getFilter };
export type { IAddressBase, IAddressCreate, IAddressDetail, IAddressForm, IAddressList, ICountry, IDynamicFormForm, IFeedbackCreate, IFeedbackDetail, IFieldFile, IFileField, IFileRecord, IFilter, IFilterChoice, IFilterRow, IFilters, IForm, IFormCreate, IFormDetail, IFormFieldBase, IFormFieldCreate, IFormFieldDetail, IFormFieldValueBase, IFormFieldValueCreate, IFormFieldValueDetail, IFormFieldValueForm, IFormFieldValueUpdate, IFormGroupBase, IFormGroupCreate, IFormGroupDetail, IFormGroupUpdate, IFormUpdate, IGroupBase, IGroupCreate, IGroupDetail, IGroupList, IItemQuery, IMemberIdentifierBase, IMemberIdentifierCreate, IMemberIdentifierDetail, IMemberInvitation, IOrganizationBase, IOrganizationCreate, IOrganizationDetail, IOrganizationList, IPaginated, IPermission, IPopulatedFormCreate, IPopulatedFormDetail, IPopulatedFormForm, IPopulatedFormUpdate, IPortalMemberBase, IPortalMemberCreate, IPortalMemberDetail, IPortalMemberList, IPreferences, IQuery, IRestOptions, ISearchFields, IServerManifest, ISortField, IUserCreateForm, Identifiable, LeftNavCategory, LeftNavOption, NavGroup, NavGrouping, NavOption, OptionAction, OptionActionChoice, RestServiceConfig, Selectable, TableColumn, TypeChoice };