import * as _angular_core from '@angular/core';
import { Type, InjectionToken, InjectOptions, InputSignal, Injector, ChangeDetectorRef, AfterViewInit, TemplateRef, OnDestroy, TrackByFunction, PipeTransform } from '@angular/core';
import * as i4 from '@ng-bootstrap/ng-bootstrap';
import { Placement, NgbInputDatepicker, NgbTimepicker } from '@ng-bootstrap/ng-bootstrap';
import * as i1 from '@abp/ng.core';
import { ABP, TrackByService, ConfigStateService, TimezoneService, PermissionService, ListService } from '@abp/ng.core';
import { ValidatorFn, AsyncValidatorFn, UntypedFormGroup, ControlValueAccessor, ControlContainer, FormGroupDirective } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import { LinkedList } from '@abp/utils';
import { SelectionType, DatatableComponent } from '@swimlane/ngx-datatable';
import * as i2 from '@abp/ng.theme.shared';
import * as i3 from '@ngx-validate/core';

declare const enum ePropType {
    Boolean = "boolean",
    Date = "date",
    DateTime = "datetime",
    Email = "email",
    Enum = "enum",
    Hidden = "hidden",
    MultiSelect = "multiselect",
    Number = "number",
    Password = "password",
    PasswordInputGroup = "passwordinputgroup",
    String = "string",
    Text = "text",
    Time = "time",
    Typeahead = "typeahead"
}

declare abstract class PropList<R = any, A = Prop<R>> extends LinkedList<A> {
}
declare abstract class PropData<R = any> {
    abstract getInjected: <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, options?: InjectOptions) => T;
    index?: number | InputSignal<number | undefined>;
    abstract record: R | InputSignal<R>;
    get data(): ReadonlyPropData<R>;
}
type ReadonlyPropData<R = any> = Readonly<{
    getInjected: <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, options?: InjectOptions) => T;
    index?: number;
    record: R;
}>;
declare abstract class Prop<R = any> {
    readonly type: ePropType;
    readonly name: string;
    readonly displayName: string;
    readonly permission: string;
    readonly visible: PropPredicate<R>;
    readonly isExtra: boolean;
    readonly template?: Type<any>;
    readonly className?: string;
    readonly formText?: string;
    readonly tooltip?: FormPropTooltip;
    readonly displayTextResolver?: PropDisplayTextResolver<R>;
    constructor(type: ePropType, name: string, displayName: string, permission: string, visible?: PropPredicate<R>, isExtra?: boolean, template?: Type<any>, className?: string, formText?: string, tooltip?: FormPropTooltip, displayTextResolver?: PropDisplayTextResolver<R>);
}
type PropCallback<T, R = any> = (data: ReadonlyPropData<T>, auxData?: any) => R;
type PropPredicate<T> = (data?: ReadonlyPropData<T>, auxData?: any) => boolean;
type PropDisplayTextResolver<T> = (data?: ReadonlyPropData<T>) => string;
declare abstract class PropsFactory<C extends Props<any>> {
    protected abstract _ctor: Type<C>;
    private contributorCallbacks;
    get(name: string): C;
}
declare abstract class Props<L extends PropList<any, InferredProp<L>>> {
    private readonly callbackList;
    protected abstract _ctor: Type<L>;
    get props(): L;
    constructor(callbackList: PropContributorCallback<L>[]);
    addContributor(contributeCallback: PropContributorCallback<L>): void;
    clearContributors(): void;
}
type PropContributorCallbacks<L extends PropList<any, InferredProp<L>>> = Record<string, PropContributorCallback<L>[]>;
type PropContributorCallback<L extends PropList<any, InferredProp<L>>> = (propList: L) => any;
type InferredProp<T> = T extends PropList<any, infer U> ? U : T;

type PartialWithOptions<T, OptionalKeys extends keyof T> = Partial<Pick<T, OptionalKeys>>;
type FilteredWithOptions<T, OptionalKeys extends keyof T> = Omit<T, OptionalKeys>;

declare class FormPropList<R = any> extends PropList<R, FormProp<R>> {
}
declare class FormProps<R = any> extends Props<PropList<R, FormProp<R>>> {
    protected _ctor: Type<FormPropList<R>>;
}
interface FormPropGroup {
    name: string;
    className?: string;
}
interface FormPropTooltip {
    text: string;
    params?: string[];
    placement?: 'top' | 'end' | 'bottom' | 'start';
}
declare class GroupedFormPropList<R = any> {
    readonly items: GroupedFormPropItem[];
    count: number;
    addItem(item: FormProp<R>): void;
}
interface GroupedFormPropItem {
    group?: FormPropGroup;
    formPropList: FormPropList;
}
declare class CreateFormPropsFactory<R = any> extends PropsFactory<FormProps<R>> {
    protected _ctor: Type<FormProps<R>>;
}
declare class EditFormPropsFactory<R = any> extends PropsFactory<FormProps<R>> {
    protected _ctor: Type<FormProps<R>>;
}
declare class FormProp<R = any> extends Prop<R> {
    readonly validators: PropCallback<R, ValidatorFn[]>;
    readonly asyncValidators: PropCallback<R, AsyncValidatorFn[]>;
    readonly disabled: PropPredicate<R>;
    readonly readonly: PropPredicate<R>;
    readonly autocomplete: string;
    readonly defaultValue: boolean | number | string | Date | Array<string>;
    readonly options: PropCallback<R, Observable<ABP.Option<any>[]>> | undefined;
    readonly id: string | undefined;
    readonly template?: Type<any>;
    readonly className?: string;
    readonly group?: FormPropGroup | undefined;
    readonly displayTextResolver?: PropDisplayTextResolver<R>;
    readonly formText?: string;
    readonly tooltip?: FormPropTooltip;
    constructor(options: FormPropOptions<R>);
    static create<R = any>(options: FormPropOptions<R>): FormProp<R>;
    static createMany<R = any>(arrayOfOptions: FormPropOptions<R>[]): FormProp<R>[];
}
declare class FormPropData<R = any> extends PropData<R> {
    readonly record: R;
    getInjected: PropData<R>['getInjected'];
    constructor(injector: Injector, record: R);
}
type OptionalKeys$2 = 'permission' | 'visible' | 'displayName' | 'isExtra' | 'validators' | 'asyncValidators' | 'disabled' | 'readonly' | 'autocomplete' | 'defaultValue' | 'options' | 'id' | 'displayTextResolver' | 'formText' | 'tooltip';
type FormPropOptions<R = any> = PartialWithOptions<FormProp<R>, OptionalKeys$2> & FilteredWithOptions<FormProp<R>, OptionalKeys$2>;
type CreateFormPropDefaults<R = any> = Record<string, FormProp<R>[]>;
type CreateFormPropContributorCallback<R = any> = PropContributorCallback<FormPropList<R>>;
type CreateFormPropContributorCallbacks<R = any> = PropContributorCallbacks<FormPropList<R>>;
type EditFormPropDefaults<R = any> = Record<string, FormProp<R>[]>;
type EditFormPropContributorCallback<R = any> = PropContributorCallback<FormPropList<R>>;
type EditFormPropContributorCallbacks<R = any> = PropContributorCallbacks<FormPropList<R>>;

declare class ExtensibleDateTimePickerComponent {
    readonly cdRef: ChangeDetectorRef;
    prop: _angular_core.InputSignal<FormProp<any>>;
    meridian: _angular_core.InputSignal<boolean>;
    placement: _angular_core.InputSignal<Placement>;
    readonly date: _angular_core.Signal<NgbInputDatepicker>;
    readonly time: _angular_core.Signal<NgbTimepicker>;
    setDate(dateStr: string): void;
    setTime(dateStr: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleDateTimePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExtensibleDateTimePickerComponent, "abp-extensible-date-time-picker", ["abpExtensibleDateTimePicker"], { "prop": { "alias": "prop"; "required": false; "isSignal": true; }; "meridian": { "alias": "meridian"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const enum eExtensibleComponents {
    PasswordComponent = "ThemeShared.Extensions.PasswordComponent"
}

declare class ExtensibleFormPropService {
    #private;
    meridian$: rxjs.Observable<boolean>;
    isRequired(validator: ValidatorFn): boolean;
    getComponent(prop: FormProp): "date" | "hidden" | "multiselect" | "passwordinputgroup" | "time" | "typeahead" | "template" | "checkbox" | "dateTime" | "textarea" | "select" | "input";
    getType(prop: FormProp): "email" | "hidden" | "number" | "password" | "passwordinputgroup" | "text" | "checkbox";
    calcAsterisks(validators: ValidatorFn[]): "" | "*";
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleFormPropService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ExtensibleFormPropService>;
}

declare class ExtensibleFormPropComponent implements AfterViewInit {
    #private;
    protected service: ExtensibleFormPropService;
    readonly cdRef: ChangeDetectorRef;
    readonly track: TrackByService<any>;
    private injector;
    private readonly form;
    readonly data: _angular_core.InputSignal<Readonly<{
        getInjected: <T>(token: _angular_core.Type<T> | _angular_core.InjectionToken<T>, notFoundValue?: T, options?: _angular_core.InjectOptions) => T;
        index?: number;
        record: any;
    }>>;
    readonly prop: _angular_core.InputSignal<FormProp<any>>;
    readonly first: _angular_core.InputSignal<boolean>;
    readonly isFirstGroup: _angular_core.InputSignal<boolean>;
    private readonly fieldRef;
    injectorForCustomComponent?: Injector;
    asterisk: string;
    containerClassName: string;
    showPassword: boolean;
    options$: Observable<ABP.Option<any>[]>;
    validators: ValidatorFn[];
    readonly: boolean;
    typeaheadModel: any;
    passwordKey: eExtensibleComponents;
    disabledFn: (data: ReadonlyPropData) => boolean;
    get disabled(): boolean;
    constructor();
    setTypeaheadValue(selectedOption: ABP.Option<string>): void;
    search: (text$: Observable<string>) => Observable<any[]>;
    typeaheadFormatter: (option: ABP.Option<any>) => string;
    meridian$: Observable<boolean>;
    get isInvalid(): boolean;
    private getTypeaheadControls;
    private setAsterisk;
    ngAfterViewInit(): void;
    getComponent(prop: FormProp): string;
    getType(prop: FormProp): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleFormPropComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExtensibleFormPropComponent, "abp-extensible-form-prop", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "prop": { "alias": "prop"; "required": true; "isSignal": true; }; "first": { "alias": "first"; "required": false; "isSignal": true; }; "isFirstGroup": { "alias": "isFirstGroup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ExtensibleFormComponent<R = any> {
    readonly cdRef: ChangeDetectorRef;
    readonly track: TrackByService<any>;
    private readonly container;
    private readonly extensions;
    private readonly identifier;
    readonly formProps: _angular_core.Signal<readonly ExtensibleFormPropComponent[]>;
    readonly selectedRecord: _angular_core.InputSignal<R>;
    extraPropertiesKey: string;
    readonly groupedPropList: _angular_core.WritableSignal<GroupedFormPropList<any>>;
    groupedPropListOfArray: FormProp<any>[][];
    readonly record: _angular_core.WritableSignal<R>;
    constructor();
    get form(): UntypedFormGroup;
    get extraProperties(): UntypedFormGroup;
    createGroupedList(propList: FormPropList<R>): GroupedFormPropList<any>;
    isAnyGroupMemberVisible(index: number, data: any): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleFormComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExtensibleFormComponent<any>, "abp-extensible-form", ["abpExtensibleForm"], { "selectedRecord": { "alias": "selectedRecord"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare abstract class ActionList<R = any, A = Action<R>> extends LinkedList<A> {
}
declare abstract class ActionData<R = any> {
    abstract getInjected: <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, flags?: InjectOptions) => T;
    index?: number | InputSignal<number | undefined>;
    abstract record: R | InputSignal<R>;
    get data(): ReadonlyActionData<R>;
}
type ReadonlyActionData<R = any> = Readonly<{
    getInjected: <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, flags?: InjectOptions) => T;
    index?: number;
    record: R;
}>;
declare abstract class Action<R = any> {
    readonly permission: string;
    readonly visible: ActionPredicate<R>;
    readonly action: ActionCallback<R>;
    readonly btnClass?: string;
    readonly btnStyle?: string;
    constructor(permission: string, visible?: ActionPredicate<R>, action?: ActionCallback<R>, btnClass?: string, btnStyle?: string);
}
type ActionCallback<T, R = any> = (data: ReadonlyActionData<T>) => R;
type ActionPredicate<T> = (data?: ReadonlyActionData<T>) => boolean;
declare abstract class ActionsFactory<C extends Actions<any>> {
    protected abstract _ctor: Type<C>;
    private contributorCallbacks;
    get(name: string): C;
}
declare abstract class Actions<L extends ActionList<any, InferredAction<L>>> {
    private readonly callbackList;
    protected abstract _ctor: Type<L>;
    get actions(): L;
    constructor(callbackList: ActionContributorCallback<L>[]);
    addContributor(contributeCallback: ActionContributorCallback<L>): void;
    clearContributors(): void;
}
type ActionContributorCallbacks<L extends ActionList<any, InferredAction<L>>> = Record<string, ActionContributorCallback<L>[]>;
type ActionContributorCallback<L extends ActionList<any, InferredAction<L>>> = (actionList: L) => any;
type InferredAction<T> = T extends ActionList<any, infer U> ? U : T;

declare class EntityActionList<R = any> extends ActionList<R, EntityAction<R>> {
}
declare class EntityActions<R = any> extends Actions<EntityActionList<R>> {
    protected _ctor: Type<EntityActionList<R>>;
}
declare class EntityActionsFactory<R = any> extends ActionsFactory<EntityActions<R>> {
    protected _ctor: Type<EntityActions<R>>;
}
declare class EntityAction<R = any> extends Action<R> {
    readonly text: string;
    readonly icon: string;
    readonly btnClass?: string;
    readonly btnStyle?: string;
    readonly showOnlyIcon?: boolean;
    readonly tooltip?: FormPropTooltip;
    constructor(options: EntityActionOptions<R>);
    static create<R = any>(options: EntityActionOptions<R>): EntityAction<R>;
    static createMany<R = any>(arrayOfOptions: EntityActionOptions<R>[]): EntityAction<R>[];
}
type OptionalKeys$1 = 'permission' | 'visible' | 'icon';
type EntityActionOptions<R = any> = PartialWithOptions<EntityAction<R>, OptionalKeys$1> & FilteredWithOptions<EntityAction<R>, OptionalKeys$1>;
type EntityActionDefaults<R = any> = Record<string, EntityAction<R>[]>;
type EntityActionContributorCallback<R = any> = ActionContributorCallback<EntityActionList<R>>;
type EntityActionContributorCallbacks<R = any> = ActionContributorCallbacks<EntityActionList<R>>;

declare class EntityPropList<R = any> extends PropList<R, EntityProp<R>> {
}
declare class EntityProps<R = any> extends Props<EntityPropList<R>> {
    protected _ctor: Type<EntityPropList<R>>;
}
declare class EntityPropsFactory<R = any> extends PropsFactory<EntityProps<R>> {
    protected _ctor: Type<EntityProps<R>>;
}
declare class EntityProp<R = any> extends Prop<R> {
    readonly columnWidth: number | undefined;
    readonly sortable: boolean;
    readonly valueResolver: PropCallback<R, Observable<any>>;
    readonly action?: ActionCallback<R>;
    readonly component?: Type<any>;
    readonly enumList?: Array<ABP.Option<any>>;
    readonly tooltip?: FormPropTooltip;
    readonly columnVisible: ColumnPredicate;
    constructor(options: EntityPropOptions<R>);
    static create<R = any>(options: EntityPropOptions<R>): EntityProp<R>;
    static createMany<R = any>(arrayOfOptions: EntityPropOptions<R>[]): EntityProp<R>[];
}
type OptionalKeys = 'permission' | 'visible' | 'columnVisible' | 'displayName' | 'isExtra' | 'columnWidth' | 'sortable' | 'valueResolver' | 'action' | 'component' | 'enumList';
type EntityPropOptions<R = any> = PartialWithOptions<EntityProp<R>, OptionalKeys> & FilteredWithOptions<EntityProp<R>, OptionalKeys>;
type EntityPropDefaults<R = any> = Record<string, EntityProp<R>[]>;
type EntityPropContributorCallback<R = any> = PropContributorCallback<EntityPropList<R>>;
type EntityPropContributorCallbacks<R = any> = PropContributorCallbacks<EntityPropList<R>>;
type ColumnPredicate = (getInjected: GetInjected, auxData?: any) => boolean;
type GetInjected = <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, options?: InjectOptions) => T;

declare class ExtensibleTableRowDetailComponent<R = any> {
    readonly rowHeight: _angular_core.InputSignal<string | number>;
    readonly template: _angular_core.Signal<TemplateRef<any>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleTableRowDetailComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExtensibleTableRowDetailComponent<any>, "abp-extensible-table-row-detail", never, { "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; }, {}, ["template"], never, true, never>;
}

interface RowDetailContext<R = any> {
    row: R;
    expanded: boolean;
}

declare class ExtensibleTableComponent<R = any> implements AfterViewInit, OnDestroy {
    #private;
    readonly getInjected: any;
    protected readonly cdr: ChangeDetectorRef;
    protected readonly locale: string;
    protected readonly config: ConfigStateService;
    protected readonly timeZoneService: TimezoneService;
    protected readonly entityPropTypeClasses: Partial<{
        boolean: string;
        date: string;
        datetime: string;
        email: string;
        enum: string;
        hidden: string;
        multiselect: string;
        number: string;
        password: string;
        passwordinputgroup: string;
        string: string;
        text: string;
        time: string;
        typeahead: string;
    }>;
    protected readonly permissionService: PermissionService;
    private platformId;
    protected isBrowser: boolean;
    readonly actionsTextInput: _angular_core.InputSignal<string>;
    readonly dataInput: _angular_core.InputSignal<R[]>;
    readonly list: _angular_core.InputSignal<ListService<any>>;
    readonly recordsTotal: _angular_core.InputSignal<number>;
    readonly actionsColumnWidthInput: _angular_core.InputSignal<number>;
    readonly actionsTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    readonly selectable: _angular_core.InputSignal<boolean>;
    readonly selectionTypeInput: _angular_core.InputSignal<"checkbox" | SelectionType | "single" | "multi" | "multiClick" | "cell">;
    readonly selected: _angular_core.InputSignal<any[]>;
    readonly infiniteScroll: _angular_core.InputSignal<boolean>;
    readonly isLoading: _angular_core.InputSignal<boolean>;
    readonly scrollThreshold: _angular_core.InputSignal<number>;
    readonly tableHeight: _angular_core.InputSignal<number>;
    readonly rowDetailTemplate: _angular_core.InputSignal<TemplateRef<RowDetailContext<R>>>;
    readonly rowDetailHeight: _angular_core.InputSignal<string | number>;
    readonly tableActivate: _angular_core.OutputEmitterRef<any>;
    readonly selectionChange: _angular_core.OutputEmitterRef<any[]>;
    readonly loadMore: _angular_core.OutputEmitterRef<void>;
    readonly rowDetailToggle: _angular_core.OutputEmitterRef<R>;
    protected readonly _data: _angular_core.WritableSignal<R[]>;
    private readonly _actionsColumnWidth;
    readonly rowDetailComponent: _angular_core.Signal<ExtensibleTableRowDetailComponent<any>>;
    readonly table: _angular_core.Signal<DatatableComponent<any>>;
    protected readonly actionsText: _angular_core.Signal<string>;
    protected readonly selectionType: _angular_core.Signal<SelectionType>;
    protected get data(): R[];
    protected set data(value: R[]);
    protected get effectiveRowDetailTemplate(): TemplateRef<RowDetailContext<R>> | undefined;
    protected get effectiveRowDetailHeight(): string | number;
    hasAtLeastOnePermittedAction: boolean;
    readonly propList: EntityPropList<R>;
    readonly actionList: EntityActionList<R>;
    readonly trackByFn: TrackByFunction<EntityProp<R>>;
    private readonly loadMoreSubject;
    private readonly loadMoreSubscription;
    readonly columnWidths: _angular_core.Signal<number[]>;
    constructor();
    private prepareRecord;
    private getIcon;
    private getEnum;
    getContent(prop: EntityProp<R>, data: ReadonlyPropData): Observable<string>;
    isVisibleActions(rowData: any): boolean;
    onSelect({ selected }: {
        selected: any[];
    }): void;
    onScroll(scrollEvent: Event): void;
    private shouldHandleScroll;
    private isNearScrollBottom;
    private triggerLoadMore;
    getTableHeight(): string;
    toggleExpandRow(row: R): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleTableComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExtensibleTableComponent<any>, "abp-extensible-table", ["abpExtensibleTable"], { "actionsTextInput": { "alias": "actionsText"; "required": false; "isSignal": true; }; "dataInput": { "alias": "data"; "required": false; "isSignal": true; }; "list": { "alias": "list"; "required": true; "isSignal": true; }; "recordsTotal": { "alias": "recordsTotal"; "required": true; "isSignal": true; }; "actionsColumnWidthInput": { "alias": "actionsColumnWidth"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selectionTypeInput": { "alias": "selectionType"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "infiniteScroll": { "alias": "infiniteScroll"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "scrollThreshold": { "alias": "scrollThreshold"; "required": false; "isSignal": true; }; "tableHeight": { "alias": "tableHeight"; "required": false; "isSignal": true; }; "rowDetailTemplate": { "alias": "rowDetailTemplate"; "required": false; "isSignal": true; }; "rowDetailHeight": { "alias": "rowDetailHeight"; "required": false; "isSignal": true; }; }, { "tableActivate": "tableActivate"; "selectionChange": "selectionChange"; "loadMore": "loadMore"; "rowDetailToggle": "rowDetailToggle"; }, ["rowDetailComponent"], never, true, never>;
}

declare class ToolbarActionList<R = any> extends ActionList<R, ToolbarActionDefault<R>> {
}
declare class ToolbarActions<R = any> extends Actions<ToolbarActionList<R>> {
    protected _ctor: Type<ToolbarActionList<R>>;
}
declare class ToolbarActionsFactory<R = any> extends ActionsFactory<ToolbarActions<R>> {
    protected _ctor: Type<ToolbarActions<R>>;
}
declare class ToolbarAction<R = any> extends Action<R> {
    readonly text: string;
    readonly icon: string;
    readonly btnClass?: string;
    constructor(options: ToolbarActionOptions<R>);
    static create<R = any>(options: ToolbarActionOptions<R>): ToolbarAction<R>;
    static createMany<R = any>(arrayOfOptions: ToolbarActionOptions<R>[]): ToolbarAction<R>[];
}
declare class ToolbarComponent<R = any> extends Action<R> {
    readonly component: Type<any>;
    constructor(options: ToolbarComponentOptions<R>);
    static create<R = any>(options: ToolbarComponentOptions<R>): ToolbarComponent<R>;
    static createMany<R = any>(arrayOfOptions: ToolbarComponentOptions<R>[]): ToolbarComponent<R>[];
}
type OptionalActionKeys = 'permission' | 'visible' | 'icon' | 'btnClass';
type ToolbarActionOptions<R = any> = PartialWithOptions<ToolbarAction<R>, OptionalActionKeys> & FilteredWithOptions<ToolbarAction<R>, OptionalActionKeys>;
type OptionalComponentKeys = 'permission' | 'visible' | 'action';
type ToolbarComponentOptions<R = any> = PartialWithOptions<ToolbarComponent<R>, OptionalComponentKeys> & FilteredWithOptions<ToolbarComponent<R>, OptionalComponentKeys>;
type ToolbarActionDefault<R = any> = ToolbarAction<R> | ToolbarComponent<R>;
type ToolbarActionDefaults<R = any> = Record<string, Array<ToolbarActionDefault<R>>>;
type ToolbarActionContributorCallback<R = any> = ActionContributorCallback<ToolbarActionList<R>>;
type ToolbarActionContributorCallbacks<R = any> = ActionContributorCallbacks<ToolbarActionList<R>>;
type InferredData<L> = ActionData<InferredRecord$1<L>>;
type InferredRecord$1<L> = L extends ActionList<infer R> ? R : any;
interface HasCreateInjectorPipe<R> {
    getData: () => ReadonlyActionData<R>;
    injector: Injector;
    getInjected: InferredData<ToolbarActionList<R>>['getInjected'];
}

declare abstract class AbstractActionsComponent<L extends ActionList<any, InferredAction<L>>> extends ActionData<InferredRecord$1<L>> {
    readonly actionList: L;
    readonly getInjected: InferredData<L>['getInjected'];
    record: _angular_core.InputSignal<InferredRecord$1<L>>;
    protected constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractActionsComponent<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractActionsComponent<any>, never, never, { "record": { "alias": "record"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GridActionsComponent<R = any> extends AbstractActionsComponent<EntityActionList<R>> {
    readonly icon: _angular_core.InputSignal<string>;
    readonly index: _angular_core.InputSignal<number>;
    readonly text: _angular_core.InputSignal<string>;
    readonly trackByFn: TrackByFunction<EntityAction<R>>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridActionsComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridActionsComponent<any>, "abp-grid-actions", ["abpGridActions"], { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PageToolbarComponent<R = any> extends AbstractActionsComponent<ToolbarActionList<R>> implements HasCreateInjectorPipe<R> {
    readonly injector: Injector;
    defaultBtnClass: string;
    getData: () => Readonly<{
        getInjected: <T>(token: _angular_core.Type<T> | _angular_core.InjectionToken<T>, notFoundValue?: T, flags?: _angular_core.InjectOptions) => T;
        index?: number;
        record: R;
    }>;
    readonly trackByFn: TrackByFunction<ToolbarComponent<R>>;
    constructor();
    asToolbarAction(value: ToolbarActionDefault): {
        value: ToolbarAction;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageToolbarComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageToolbarComponent<any>, "abp-page-toolbar", ["abpPageToolbar"], {}, {}, never, never, true, never>;
}

declare class ExtensibleFormMultiselectComponent implements ControlValueAccessor {
    prop: _angular_core.InputSignal<FormProp<any>>;
    options: _angular_core.InputSignal<ABP.Option<any>[]>;
    selectedValues: any[];
    disabled: boolean;
    private onChange;
    private onTouched;
    setDisabledState(isDisabled: boolean): void;
    isChecked(value: any): boolean;
    onCheckboxChange(value: any, checked: boolean): void;
    writeValue(value: any[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleFormMultiselectComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExtensibleFormMultiselectComponent, "abp-extensible-form-multi-select", never, { "prop": { "alias": "prop"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const EXTRA_PROPERTIES_KEY = "extraProperties";

type InferredRecord<L> = L extends PropList<infer R> ? R : never;
declare class PropDataDirective<L extends PropList<any>> extends PropData<InferredRecord<L>> implements OnDestroy {
    private tempRef;
    private vcRef;
    readonly propList: _angular_core.InputSignal<L>;
    readonly record: _angular_core.InputSignal<InferredRecord<L>>;
    readonly index: _angular_core.InputSignal<number>;
    readonly getInjected: PropData<InferredRecord<L>>['getInjected'];
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PropDataDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PropDataDirective<any>, "[abpPropData]", ["abpPropData"], { "propList": { "alias": "abpPropDataFromList"; "required": false; "isSignal": true; }; "record": { "alias": "abpPropDataWithRecord"; "required": true; "isSignal": true; }; "index": { "alias": "abpPropDataAtIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type DisplayNameGeneratorFn = (displayName: LocalizableStringDto, fallback: LocalizableStringDto) => string | undefined;
type EntityExtensions = Record<string, EntityExtensionDto>;
interface EntityExtensionDto {
    properties: EntityExtensionProperties;
    configuration: Record<string, object>;
}
type EntityExtensionProperties = Record<string, ExtensionPropertyDto>;
interface ExtensionEnumDto {
    fields: ExtensionEnumFieldDto[];
    localizationResource?: string;
    transformed?: any;
}
interface ExtensionEnumFieldDto {
    name?: string;
    value: any;
}
interface ExtensionPropertyApiCreateDto {
    isAvailable: boolean;
}
interface ExtensionPropertyApiDto {
    onGet: ExtensionPropertyApiGetDto;
    onCreate: ExtensionPropertyApiCreateDto;
    onUpdate: ExtensionPropertyApiUpdateDto;
}
interface ExtensionPropertyApiGetDto {
    isAvailable: boolean;
}
interface ExtensionPropertyApiUpdateDto {
    isAvailable: boolean;
}
interface ExtensionPropertyAttributeDto {
    typeSimple?: string;
    config: Record<string, any>;
}
interface ExtensionPropertyDto {
    type?: string;
    typeSimple?: ePropType;
    displayName: LocalizableStringDto;
    api: ExtensionPropertyApiDto;
    ui: ExtensionPropertyUiDto;
    attributes: ExtensionPropertyAttributeDto[];
    configuration: Record<string, any>;
    defaultValue: any;
    formText?: string;
    policy?: Policy;
}
interface BaseDefinition {
    requiresAll: boolean;
}
interface FeatureDefinition extends BaseDefinition {
    features?: string[];
}
interface PermissionDefinition extends BaseDefinition {
    permissionNames?: string[];
}
interface Policy {
    globalFeatures: FeatureDefinition;
    features: FeatureDefinition;
    permissions: PermissionDefinition;
}
interface ExtensionPropertyUiDto {
    onTable: ExtensionPropertyUiTableDto;
    onCreateForm: ExtensionPropertyUiFormDto;
    onEditForm: ExtensionPropertyUiFormDto;
    lookup?: ExtensionPropertyUiLookupDto;
}
interface ExtensionPropertyUiFormDto {
    isVisible: boolean;
}
interface ExtensionPropertyUiLookupDto {
    url?: string;
    resultListPropertyName?: string;
    displayPropertyName?: string;
    valuePropertyName?: string;
    filterParamName?: string;
}
interface ExtensionPropertyUiTableDto {
    isSortable?: boolean;
    isVisible: boolean;
}
interface LocalizableStringDto {
    name?: string;
    resource?: string;
}
interface ModuleExtensionDto {
    entities: Record<string, EntityExtensionDto>;
    configuration: Record<string, object>;
}
interface ObjectExtensionsDto {
    modules: Record<string, ModuleExtensionDto>;
    enums: Record<string, ExtensionEnumDto>;
}
interface PropContributors<T = any> {
    prop: PropContributorCallbacks<EntityPropList<T>>;
    createForm: PropContributorCallbacks<FormPropList<T>>;
    editForm: PropContributorCallbacks<FormPropList<T>>;
}

type objectExtensions_d_BaseDefinition = BaseDefinition;
type objectExtensions_d_DisplayNameGeneratorFn = DisplayNameGeneratorFn;
type objectExtensions_d_EntityExtensionDto = EntityExtensionDto;
type objectExtensions_d_EntityExtensionProperties = EntityExtensionProperties;
type objectExtensions_d_EntityExtensions = EntityExtensions;
type objectExtensions_d_ExtensionEnumDto = ExtensionEnumDto;
type objectExtensions_d_ExtensionEnumFieldDto = ExtensionEnumFieldDto;
type objectExtensions_d_ExtensionPropertyApiCreateDto = ExtensionPropertyApiCreateDto;
type objectExtensions_d_ExtensionPropertyApiDto = ExtensionPropertyApiDto;
type objectExtensions_d_ExtensionPropertyApiGetDto = ExtensionPropertyApiGetDto;
type objectExtensions_d_ExtensionPropertyApiUpdateDto = ExtensionPropertyApiUpdateDto;
type objectExtensions_d_ExtensionPropertyAttributeDto = ExtensionPropertyAttributeDto;
type objectExtensions_d_ExtensionPropertyDto = ExtensionPropertyDto;
type objectExtensions_d_ExtensionPropertyUiDto = ExtensionPropertyUiDto;
type objectExtensions_d_ExtensionPropertyUiFormDto = ExtensionPropertyUiFormDto;
type objectExtensions_d_ExtensionPropertyUiLookupDto = ExtensionPropertyUiLookupDto;
type objectExtensions_d_ExtensionPropertyUiTableDto = ExtensionPropertyUiTableDto;
type objectExtensions_d_FeatureDefinition = FeatureDefinition;
type objectExtensions_d_LocalizableStringDto = LocalizableStringDto;
type objectExtensions_d_ModuleExtensionDto = ModuleExtensionDto;
type objectExtensions_d_ObjectExtensionsDto = ObjectExtensionsDto;
type objectExtensions_d_PermissionDefinition = PermissionDefinition;
type objectExtensions_d_Policy = Policy;
type objectExtensions_d_PropContributors<T = any> = PropContributors<T>;
declare namespace objectExtensions_d {
  export type { objectExtensions_d_BaseDefinition as BaseDefinition, objectExtensions_d_DisplayNameGeneratorFn as DisplayNameGeneratorFn, objectExtensions_d_EntityExtensionDto as EntityExtensionDto, objectExtensions_d_EntityExtensionProperties as EntityExtensionProperties, objectExtensions_d_EntityExtensions as EntityExtensions, objectExtensions_d_ExtensionEnumDto as ExtensionEnumDto, objectExtensions_d_ExtensionEnumFieldDto as ExtensionEnumFieldDto, objectExtensions_d_ExtensionPropertyApiCreateDto as ExtensionPropertyApiCreateDto, objectExtensions_d_ExtensionPropertyApiDto as ExtensionPropertyApiDto, objectExtensions_d_ExtensionPropertyApiGetDto as ExtensionPropertyApiGetDto, objectExtensions_d_ExtensionPropertyApiUpdateDto as ExtensionPropertyApiUpdateDto, objectExtensions_d_ExtensionPropertyAttributeDto as ExtensionPropertyAttributeDto, objectExtensions_d_ExtensionPropertyDto as ExtensionPropertyDto, objectExtensions_d_ExtensionPropertyUiDto as ExtensionPropertyUiDto, objectExtensions_d_ExtensionPropertyUiFormDto as ExtensionPropertyUiFormDto, objectExtensions_d_ExtensionPropertyUiLookupDto as ExtensionPropertyUiLookupDto, objectExtensions_d_ExtensionPropertyUiTableDto as ExtensionPropertyUiTableDto, objectExtensions_d_FeatureDefinition as FeatureDefinition, objectExtensions_d_LocalizableStringDto as LocalizableStringDto, objectExtensions_d_ModuleExtensionDto as ModuleExtensionDto, objectExtensions_d_ObjectExtensionsDto as ObjectExtensionsDto, objectExtensions_d_PermissionDefinition as PermissionDefinition, objectExtensions_d_Policy as Policy, objectExtensions_d_PropContributors as PropContributors };
}

declare class CreateInjectorPipe<R> implements PipeTransform {
    transform(_: any, action: ToolbarComponent<R>, context: HasCreateInjectorPipe<R>): Injector;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CreateInjectorPipe<any>, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CreateInjectorPipe<any>, "createInjector", true>;
}

declare class ExtensionsService<R = any> {
    readonly entityActions: EntityActionsFactory<R>;
    readonly toolbarActions: ToolbarActionsFactory<R[]>;
    readonly entityProps: EntityPropsFactory<R>;
    readonly createFormProps: CreateFormPropsFactory<R>;
    readonly editFormProps: EditFormPropsFactory<R>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensionsService<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ExtensionsService<any>>;
}

declare const EXTENSIONS_IDENTIFIER: InjectionToken<string>;
type ActionKeys = Extract<'entityActions' | 'toolbarActions', keyof ExtensionsService>;
declare const EXTENSIONS_ACTION_TYPE: InjectionToken<ActionKeys>;
declare const EXTENSIONS_ACTION_DATA: InjectionToken<Readonly<{
    getInjected: <T>(token: _angular_core.Type<T> | InjectionToken<T>, notFoundValue?: T, flags?: _angular_core.InjectOptions) => T;
    index?: number;
    record: any;
}>>;
declare const EXTENSIONS_ACTION_CALLBACK: InjectionToken<ActionCallback<unknown>>;
declare const PROP_DATA_STREAM: InjectionToken<Observable<any>>;
type EntityPropTypeClassMap = {
    [key in ePropType]: string;
};
declare const ROW_RECORD: InjectionToken<any>;
type EntityPropTypeClass = Partial<EntityPropTypeClassMap>;
declare const ENTITY_PROP_TYPE_CLASSES: InjectionToken<Partial<EntityPropTypeClassMap>>;
declare const EXTENSIONS_FORM_PROP: InjectionToken<FormProp<any>>;
declare const EXTENSIONS_FORM_PROP_DATA: InjectionToken<unknown>;

declare const EXTENSIBLE_FORM_VIEW_PROVIDER: {
    provide: typeof ControlContainer;
    useExisting: typeof FormGroupDirective;
};

declare function mergeWithDefaultActions<F extends ActionsFactory<any>>(extension: F, defaultActions: InferredActionDefaults<F>, ...contributors: InferredActionContributorCallbacks<F>[]): void;
type InferredActionDefaults<F> = F extends EntityActionsFactory<infer RE> ? EntityActionDefaults<RE> : F extends ToolbarActionsFactory<infer RT> ? ToolbarActionDefaults<RT> : never;
type InferredActionContributorCallbacks<F> = F extends EntityActionsFactory<infer RE> ? EntityActionContributorCallbacks<RE> : F extends ToolbarActionsFactory<infer RT> ? ToolbarActionContributorCallbacks<RT> : never;

declare function generateFormFromProps<R = any>(propData: PropData<R>): UntypedFormGroup;

declare function createExtraPropertyValueResolver<T>(name: string): PropCallback<T, Observable<any>>;
declare function mergeWithDefaultProps<F extends PropsFactory<any>>(extension: F, defaultProps: InferredPropDefaults<F>, ...contributors: InferredPropContributorCallbacks<F>[]): void;
declare function checkPolicies(injector: Injector, properties: EntityExtensionProperties): void;
type InferredPropDefaults<F> = F extends EntityPropsFactory<infer RE> ? EntityPropDefaults<RE> : F extends CreateFormPropsFactory<infer RCF> ? CreateFormPropDefaults<RCF> : F extends EditFormPropsFactory<infer REF> ? EditFormPropDefaults<REF> : never;
type InferredPropContributorCallbacks<F> = F extends EntityPropsFactory<infer RE> ? EntityPropContributorCallbacks<RE> : F extends CreateFormPropsFactory<infer RCF> ? CreateFormPropContributorCallbacks<RCF> : F extends EditFormPropsFactory<infer REF> ? EditFormPropContributorCallbacks<REF> : never;

declare function getObjectExtensionEntitiesFromStore(injector: Injector, moduleKey: string): Observable<EntityExtensions>;
declare function mapEntitiesToContributors<T = any>(injector: Injector, resource: string): rxjs.UnaryFunction<Observable<any>, Observable<PropContributors<any>>>;

declare class ExtensibleModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExtensibleModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ExtensibleModule, never, [typeof i1.CoreModule, typeof i2.ThemeSharedModule, typeof i3.NgxValidateCoreModule, typeof i4.NgbDatepickerModule, typeof i4.NgbDropdownModule, typeof i4.NgbTimepickerModule, typeof i4.NgbTypeaheadModule, typeof i4.NgbTooltipModule, typeof i2.DisabledDirective, typeof ExtensibleDateTimePickerComponent, typeof ExtensibleFormPropComponent, typeof GridActionsComponent, typeof PropDataDirective, typeof PageToolbarComponent, typeof CreateInjectorPipe, typeof ExtensibleFormComponent, typeof ExtensibleTableComponent, typeof ExtensibleTableRowDetailComponent, typeof ExtensibleFormMultiselectComponent], [typeof i2.DisabledDirective, typeof ExtensibleDateTimePickerComponent, typeof ExtensibleFormPropComponent, typeof GridActionsComponent, typeof PropDataDirective, typeof PageToolbarComponent, typeof CreateInjectorPipe, typeof ExtensibleFormComponent, typeof ExtensibleTableComponent, typeof ExtensibleTableRowDetailComponent, typeof ExtensibleFormMultiselectComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ExtensibleModule>;
}

export { ActionList, CreateFormPropsFactory, CreateInjectorPipe, ENTITY_PROP_TYPE_CLASSES, EXTENSIBLE_FORM_VIEW_PROVIDER, EXTENSIONS_ACTION_CALLBACK, EXTENSIONS_ACTION_DATA, EXTENSIONS_ACTION_TYPE, EXTENSIONS_FORM_PROP, EXTENSIONS_FORM_PROP_DATA, EXTENSIONS_IDENTIFIER, EXTRA_PROPERTIES_KEY, EditFormPropsFactory, EntityAction, EntityActionList, EntityActions, EntityActionsFactory, EntityProp, EntityPropList, EntityProps, EntityPropsFactory, ExtensibleDateTimePickerComponent, ExtensibleFormComponent, ExtensibleFormMultiselectComponent, ExtensibleFormPropComponent, ExtensibleModule, ExtensibleTableComponent, ExtensibleTableRowDetailComponent, ExtensionsService, FormProp, FormPropData, FormPropList, FormProps, GridActionsComponent, objectExtensions_d as ObjectExtensions, PROP_DATA_STREAM, PageToolbarComponent, PropDataDirective, PropList, ROW_RECORD, ToolbarAction, ToolbarActionList, ToolbarActions, ToolbarActionsFactory, ToolbarComponent, checkPolicies, createExtraPropertyValueResolver, eExtensibleComponents, ePropType, generateFormFromProps, getObjectExtensionEntitiesFromStore, mapEntitiesToContributors, mergeWithDefaultActions, mergeWithDefaultProps };
export type { ActionCallback, ReadonlyActionData as ActionData, ActionKeys, ActionPredicate, CreateFormPropContributorCallback, EditFormPropContributorCallback, EntityActionContributorCallback, EntityActionOptions, EntityPropContributorCallback, EntityPropOptions, EntityPropTypeClass, FilteredWithOptions, FormPropOptions, PartialWithOptions, PropCallback, ReadonlyPropData as PropData, PropPredicate, RowDetailContext, ToolbarActionContributorCallback, ToolbarActionOptions, ToolbarComponentOptions };