import * as _angular_core from '@angular/core';
import { TemplateRef, OnInit, AfterViewInit, OnDestroy } from '@angular/core';
import { Situation, ObjectTypeField, ObjectFormControl } from '@yuuvis/client-core';
import { AbstractControl } from '@angular/forms';
import { Subject } from 'rxjs';
import * as i1 from '@yuuvis/client-framework/common';

/**
 * Object forms are used to render and edit metadata of DMS objects. Each property
 * of an object can be rendered in a diffenrent way, depending on the type of the property.
 * This service allows to register and retrieve templates for rendering these form elements.
 *
 * You can register templates for different situations like EDIT, SEARCH, and CREATE.
 * The templates will then be used to render the form elements in the object form component.
 *
 * So based on the property type you can register custom templates for rendering certain
 * form elements. This is useful if you want to render a property in a different way.
 *
 * Example:
 * Having a number property representing a rating, you might want to render it as
 * a list of stars instead of a simple input field.
 */
declare class MetadataFormElementRegistry {
    private _defaults;
    private _edit;
    private _search;
    private _create;
    private _rawDefaults;
    private _rawEdit;
    private _rawSearch;
    private _rawCreate;
    NAME_PROPERTY_PREFIX: string;
    /**
     * Get a template to render a certain form element
     * @param propertyType The internal type to get the template for
     * @param situation Form situation
     * @returns TemplateRef or undefined
     */
    getElementTemplate(propertyType: string, situation?: string): TemplateRef<any> | undefined;
    /**
     * Register an object form element for a certain internal type. You might add a new component
     * or overwrite an existung one.
     * @param propertyType The internal type to provide the component for
     * @param component The component
     * @param situation Form situation to provide thew form element for (defaults to EDIT)
     */
    addElementTemplate(propertyType: string, templateRef: TemplateRef<any>, situation?: Situation): void;
    /**
     * Remove a registered form element.
     * @param propertyType The internal type to remove the component for
     * @param situation Form situation to provide thew form element for (defaults to EDIT)
     */
    removeElementTemplate(propertyType: string, situation?: Situation): void;
    /**
     * Register default form element component. Usually this will be done by the object
     * form component itself.
     * @param propertyType The internal type to provide the component for
     * @param component The default component
     */
    _addDefaultElementTemplate(propertyType: string, templateRef: TemplateRef<any>): void;
    /**
     * Remove a registered default form element.
     * @param propertyType The internal type to remove the component for
     */
    _removeDefaultElementTemplate(propertyType: string): void;
    /**
     * Get a raw (unwrapped) form element template — only the inner widget,
     * without the surrounding `mat-form-field` / label / hint / error shell.
     * Use this when composing the widget into a custom layout (e.g. smart-search).
     * @param propertyType The internal type to get the template for
     * @param situation Form situation
     * @returns TemplateRef or undefined
     */
    getRawElementTemplate(propertyType: string, situation?: string): TemplateRef<any> | undefined;
    /**
     * Register a raw form element template for a certain internal type.
     * @param propertyType The internal type to provide the template for
     * @param templateRef The template
     * @param situation Form situation to provide the form element for (defaults to EDIT)
     */
    addRawElementTemplate(propertyType: string, templateRef: TemplateRef<any>, situation?: Situation): void;
    /**
     * Remove a registered raw form element template.
     * @param propertyType The internal type to remove the template for
     * @param situation Form situation
     */
    removeRawElementTemplate(propertyType: string, situation?: Situation): void;
    /**
     * Register a default raw form element template (used across all situations).
     * @param propertyType The internal type to provide the template for
     * @param templateRef The default template
     */
    _addDefaultRawElementTemplate(propertyType: string, templateRef: TemplateRef<any>): void;
    /**
     * Remove a registered default raw form element template.
     * @param propertyType The internal type to remove the template for
     */
    _removeDefaultRawElementTemplate(propertyType: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MetadataFormElementRegistry, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MetadataFormElementRegistry>;
}

/**
 * Context provided to each metadata form field.
 */
interface MetadataFormFieldContext {
    label?: string;
    situation: string;
    field: ObjectTypeField;
    ctrl?: AbstractControl<any, any>;
    formChangedSubject?: Subject<ParentFormChangedEvent>;
}
interface ParentFormChangedEvent {
    invalid: boolean;
    dirty: boolean;
    indexdataChanged: boolean;
    data?: any;
}

/**
 * Directive to apply styles to an object metadata element label based on its control status.
 * Depending on the state of the control (dirty, error, required), it will add or remove specific classes
 * to the label element. These classes could then be used to style the label accordingly.
 *
 * Could be placed on any HTML element, but is primarily intended for use on `<mat-label>` or `<label>` elements.
 * If you would like to use it on any other element, make sure to add the class 'label' to it.
 *
 * @example
 * <mat-label [yuvObjectMetadataElementLabel]="ctx">My Label</mat-label>
 * <label [yuvObjectMetadataElementLabel]="ctx">My Label</label>
 * <div class="label" [yuvObjectMetadataElementLabel]="ctx">My Label</div>
 */
declare class ObjectMetadataElementLabelDirective implements OnInit, AfterViewInit {
    #private;
    state: _angular_core.WritableSignal<{
        dirty: boolean;
        required: boolean;
        invalid: boolean;
    }>;
    yuvObjectMetadataElementLabel: _angular_core.InputSignal<MetadataFormFieldContext | undefined>;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectMetadataElementLabelDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ObjectMetadataElementLabelDirective, "[yuvObjectMetadataElementLabel]", never, { "yuvObjectMetadataElementLabel": { "alias": "yuvObjectMetadataElementLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Directive to apply an object-form related error to as inner text to an element.
 * This could be used to render objec tform related errors in a custom element like <mat-error>.
 *
 * @example
 * <mat-error [yuvObjectMetadataElementError]="myControl"></mat-error>
 */
declare class ObjectMetadataElementErrorDirective implements OnInit {
    #private;
    yuvObjectMetadataElementError: _angular_core.InputSignal<ObjectFormControl | undefined>;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectMetadataElementErrorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ObjectMetadataElementErrorDirective, "[yuvObjectMetadataElementError]", never, { "yuvObjectMetadataElementError": { "alias": "yuvObjectMetadataElementError"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Directive to be applied to a `ng-template`. It will register the template as a
 * form element used by object-form component.
 *
 * Context is provided with the following fields:
 * - situation: form situation 'EDIT', 'CREATE', 'SEARCH'
 * - field: ObjectTypeField
 * - ngControl: Reactive FormControl
 *
 * @example
 * <ng-template yuvMetadataElementTemplate propertyType="boolean:switch" let-ctx>...</ng-template>
 *
 */
declare class ObjectMetadataElementTemplateDirective implements OnInit, OnDestroy {
    #private;
    /**
     * Bucket to register the template. Use 'default' for templates that should be
     * used across all situations.
     */
    yuvMetadataElementTemplate: _angular_core.InputSignal<string | undefined>;
    /**
     * Situation to register the template for. So only object forms for that
     * situation (CREATE, EDIT, SEARCH) will use the template. Defaults to `EDIT`.
     */
    situation: _angular_core.InputSignal<Situation>;
    /**
     * Internal property type to get the registered template. You need to set either
     * `propertyType` or `propertyName` to get a template. Setting a name and
     * a type, the name will be used because it is more precise.
     */
    propertyType: _angular_core.InputSignal<string | undefined>;
    /**
     * Pick registered metadata element by name. You need to set either
     * `propertyType` or `propertyName` to get a template. Setting a name and
     * a type, the name will be used because it is more precise.
     */
    propertyName: _angular_core.InputSignal<string | undefined>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectMetadataElementTemplateDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ObjectMetadataElementTemplateDirective, "[yuvMetadataElementTemplate]", never, { "yuvMetadataElementTemplate": { "alias": "yuvMetadataElementTemplate"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; "propertyType": { "alias": "propertyType"; "required": false; "isSignal": true; }; "propertyName": { "alias": "propertyName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Directive to be applied to an `ng-template` that renders only the raw form
 * widget for a metadata property (without the surrounding `mat-form-field`
 * label/hint/error shell). The template is registered in the raw bucket of
 * `MetadataFormElementRegistry`, parallel to the wrapped templates registered
 * via `yuvMetadataElementTemplate`.
 *
 * Use this to expose a type-aware input that can be composed into custom
 * layouts — for example smart-search, where conditions are built inline as
 * a pill chain and a full form-field shell would be visually wrong.
 *
 * @example
 * <ng-template #rawString yuvMetadataElementRaw="default" propertyType="string" let-ctx>
 *   <yuv-string [formControl]="ctx.ctrl" [required]="ctx.field.required" />
 * </ng-template>
 */
declare class ObjectMetadataElementRawDirective implements OnInit, OnDestroy {
    #private;
    /**
     * Bucket to register the template. Use 'default' for templates that should be
     * used across all situations.
     */
    yuvMetadataElementRaw: _angular_core.InputSignal<string | undefined>;
    /**
     * Situation to register the template for. Defaults to `EDIT`.
     */
    situation: _angular_core.InputSignal<Situation>;
    /**
     * Internal property type to register the template under. You need to set
     * either `propertyType` or `propertyName`. When both are set, `propertyName`
     * wins because it is more precise.
     */
    propertyType: _angular_core.InputSignal<string | undefined>;
    /**
     * Register the raw template by metadata field name.
     */
    propertyName: _angular_core.InputSignal<string | undefined>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectMetadataElementRawDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ObjectMetadataElementRawDirective, "[yuvMetadataElementRaw]", never, { "yuvMetadataElementRaw": { "alias": "yuvMetadataElementRaw"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; "propertyType": { "alias": "propertyType"; "required": false; "isSignal": true; }; "propertyName": { "alias": "propertyName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Component to render a metadata form field within an object form. These forms are
 * created to render and edit metadata of DMS objects. This component is used as a wrapper
 * for the actual form element, which is defined by the `formField` input.
 */
declare class MetadataFormFieldComponent {
    #private;
    readonly: boolean;
    formChangedSubject: _angular_core.InputSignal<Subject<ParentFormChangedEvent> | undefined>;
    formField: _angular_core.InputSignal<ObjectTypeField>;
    /**
     * Which template variant to render. `default` renders the wrapped form field
     * (mat-form-field with label, hint, error). `raw` renders only the inner
     * widget — useful for composing into custom layouts such as smart-search.
     */
    variant: _angular_core.InputSignal<"default" | "raw">;
    elementTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
    context: _angular_core.Signal<MetadataFormFieldContext>;
    /**
     * Form situation, if not set default will be 'EDIT'
     */
    situation: _angular_core.InputSignal<string | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MetadataFormFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MetadataFormFieldComponent, "yuv-metadata-form-field", never, { "formChangedSubject": { "alias": "formChangedSubject"; "required": false; "isSignal": true; }; "formField": { "alias": "field"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

export { MetadataFormElementRegistry, MetadataFormFieldComponent, ObjectMetadataElementErrorDirective, ObjectMetadataElementLabelDirective, ObjectMetadataElementRawDirective, ObjectMetadataElementTemplateDirective };
export type { MetadataFormFieldContext, ParentFormChangedEvent };