/**
 * Indexable Interface
 */
interface Indexable {
    [key: string]: any;
}

/**
 * Helper to get and set Attributes on Objects
 */
declare class ObjectHelper {
    /**
     * Checking if the Element is an Object
     * @param {any} obj
     * @return {boolean}
     */
    static isObject(obj: any): boolean;
    /**
     * Formatting date as German
     * @param {string} date yyyy-mm-dd
     * @return {string} dd.mm.yyyy
     */
    static formatDate(date: string | undefined): string;
    /**
     * Adding Days to Date
     * @param {Date} date
     * @param {number} days
     * @return {Date}
     */
    static addDaysToDate(date: Date, days: number): Date;
    /**
     * Converts a date to a string
     * @param {Date} date
     * @return {string}
     */
    static dateToString(date: Date): string;
    /**
       * Getting Value from JSON-Object
       * @param {Indexable} object
       * @param {string} key
       * @return {any}
       */
    static get(object: Indexable, key: string): any;
    /**
       * Iterating Through Object
       * @param {Indexable} obj
       * @param {string[]} attributes
       * @param {number} depth
       * @return {any}
       * @private
       */
    static _iterateThrough(obj: Indexable, attributes: string[], depth?: number): any;
    /**
       * Setting value for Object
       * @param {Indexable} object
       * @param {string} key
       * @param {any} value
       */
    static set(object: Indexable, key: string, value: any): void;
    /**
     * Converts a string to bool
     * @param {string} v
     * @return {boolean}
     */
    static stringToBool(v: string): boolean;
    /**
       * Object to String
       * @param {Object} obj
       * @return {string}
       */
    static objectToStringDeep(obj: any): string;
}

/**
 * Helpers for View
 */
declare class ViewHelper {
    /**
       * Mark text yellow inside an element.
       * @param {Node} element
       * @param {string} input
       */
    static markElement(element: Node | ChildNode, input: string): void;
    /**
     * Toggle Visibility for Element
     * @param {HTMLElement} element
     * @param {boolean} show
     */
    static toggleVisibility(element: HTMLElement, show: boolean): void;
    /**
     * Toggle Requirement for Element
     * @param {HTMLElement} element
     * @param {boolean} show
     */
    static toggleRequirement(element: HTMLElement, show: boolean): void;
    /**
     * Getting URL-Parameter from address
     * @param {string} key
     * @return {string}
     */
    static getParameter(key: string): string | null;
    /**
       * Regex to fill keys in template
       * @return {RegExp}
       */
    static get regexTemplate(): RegExp;
    /**
       * Replacing Placeholders in template from the loaded element
       * @param {HTMLElement} template
       * @param {Indexable} e
       */
    static replacePlaceholders(template: HTMLElement, e: Indexable): void;
    /**
     * Format View with a attached Pipe
     * @param {string} pipeName
     * @param {string} value
     * @return {string}
     */
    static pipeUse(pipeName: string, value: string): string;
    /**
     * Replace Placeholders in Incoming Text
     * @param {string} text
     * @param {Indexable} e
     * @return {string}
     */
    static replacePlaceholdersInText(text: string, e: Indexable): string;
    /**
    * @private
     * Replace Placeholders in Incoming InnerHTML
     * @param {HTMLElement} template
     * @param {Indexable} e
     */
    private static replacePlaceholdersInnerHTML;
    /**
    * @private
     * Replace Placeholders in Incoming NodeText
     * @param {ChildNode} template
     * @param {Indexable} e
     */
    private static replacePlaceholdersInNodeText;
}

/**
 * Helper for Geo-Coordinates
 */
declare class GeoHelper {
    /**
     * Earth-Radius
     * @return {number}
     */
    private static get R();
    /**
       * Calculate Distance between two GPS Koordinates
       * @param {number} lat1
       * @param {number} lon1
       * @param {number} lat2
       * @param {number} lon2
       * @return {number} number
       */
    static calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number;
}

/**
 * Binding for Form Fields
 */
declare class VetproviehBinding {
    private _targetObject;
    private _targetProperty;
    private _bindings;
    /**
     * Default Constructor needs object and a property to bind
     * @param {any} target
     * @param {target} property
     */
    constructor(target: any, property: any);
    /**
     * Clear all Bindings
     */
    clear(): void;
    /**
     * Gets current property value
     * @return {any}
     */
    get value(): any;
    /**
     * Sets current property value
     * @param {any} val
     */
    set value(val: any);
    /**
     * Set targetObject
     * @param {any} val
     */
    set targetObject(val: any);
    /**
     * Add Binding to HTML-Field
     * @param {HTMLElement} element
     * @param {string} attribute
     * @param {string} event
     * @return {VetproviehBinding}
     */
    addBinding(element: HTMLElement, attribute: string, event: string): this;
    /**
     * Is a HTMLElement for a property already bound?
     * @param {HTMLElement} element
     * @param {String} attribute
     * @return {boolean}
     * @private
     */
    private _alreadyBound;
    /**
     * @private
     * @param {HTMLElement} a
     * @param {{ element: HTMLElement, attribute: string }} b
     * @param {String} attribute
     * @return {boolean}
     */
    private _compareElement;
    /**
     * Insert into internal datastructure
     * @param {HTMLElement} element
     * @param {string} attribute
     * @private
     */
    _addToBindings(element: HTMLElement, attribute: string): void;
    /**
     * Attach EventListener
     * @param {HTMLElement} element
     * @param {string} event
     * @param {string} attribute
     * @private
     */
    _attachListenerToEvent(element: HTMLElement, event: string, attribute: string): void;
    /**
     * Update all set Bindings
     * @param {any} val
     * @private
     */
    _updateBindings(val: any): void;
    static currentBindings: any;
    /**
   * Binding Form Elements
   * @param {HTMLElement|any} target (Target - HTMLElement)
   * @param {any} data (DataObject)
   * @param {String} prefix
   * @param {any} listener
   */
    static bindFormElements(target: any, data: any, prefix?: string, listener?: (x: HTMLElement) => void): void;
    private static uniqueIdentifier;
    /**
     * Setting a unique Identifier
     * @private
     * @param {HTMLElement} element
     */
    private static setUniqueIdentifier;
    /**
     * Binding an Element
     * @param {String} prefix
     * @param {String} key
     * @param {String} targetId
     * @param {any} data
     * @return {VetproviehBinding}
     */
    private static bindElement;
    /**
     * Bind Array
     * @param {Array<any>} array
     * @param {string} key
     * @param {any} target
     * @param {any} listener
     */
    private static bindArray;
    /**
     * Attach Binding to Element
     * @param {any} element
     * @param {VetproviehBinding} binding
     * @param {any} listener
     */
    private static _addBinding;
}

/**
 * BaseClass for view Elements
 */
declare class VetproviehElement extends HTMLElement {
    /**
     * Getting the template
     * @return {string}
     */
    get template(): string;
    /**
     * Default-Constructor
     * @param {boolean} shadowed
     * @param {boolean} render
     */
    constructor(shadowed?: boolean, render?: boolean);
    /**
     * Should skip render on callback
     * @return {boolean}
     */
    protected get skipRenderOnCallback(): boolean;
    /**
     * Hide css?
     * @param {boolean} bool
     * @return {string}
     */
    cssHidden(bool: boolean): string;
    /**
       * Callback Implementation
       * @param {string} name
       * @param {any} old
       * @param {any} value
       */
    attributeChangedCallback(name: string, old: any, value: any): void;
    /**
     * Connected Callback
     */
    connectedCallback(): void;
    /**
     * Sending a Callback
     * @param {string} name
     * @param {any} value
     */
    private sendCallback;
    /**
     * Loading HTML-Element From ShadowRoot
     * @param {string} id
     * @return {HTMLElement | undefined}
     */
    getByIdFromShadowRoot(id: string): HTMLElement | undefined;
    /**
     * Render Template
     */
    render(): void;
    /**
       * Hide Or Show Element
       * @param {string} id
       * @param {boolean} show
       */
    updateVisibility(id: string, show: boolean): void;
    /**
     * Getting InnerHTML
     * @return {string}
     */
    get innerHTML(): string;
    /**
     * Setting InnerHTML to innerHTML or ShadowRoot
     * @param {string} input
     */
    set innerHTML(input: string);
    /**
       * Getting Template
       * @return {string}
       */
    static get template(): string;
}

/**
 * NavParams for a MPA-Application
 */
declare class VetproviehNavParams {
    /**
     * Get a URL-Parameter
     * @param {stirng} key
     * @return {any}
     */
    static getUrlParameter(key: string): any;
    /**
       * Returning Something out of the Storage
       * @param {string} key
       * @return {any}
       */
    static get(key: string): any;
    /**
       * Delete a local Storage Item
       * @param {string} key
       */
    static delete(key: string): void;
    /**
       * Setting Storage
       * @param {string} key
       * @param {any} value
       */
    static set(key: string, value: any): void;
}

interface IRepository<T> {
    /**
     * Looking up all Model-Data
     * @returns Promise<T[]>
     */
    all(): Promise<T[]>;
    /**
     * Searching Model for a value
     * @param {string | undefined} search
     * @returns Promise<T[]>
     */
    where(search: string | undefined): Promise<T[]>;
    /**
     * Suche mit Parametern
     * @param {{ [Identifier: string]: string }} params
     * @returns Promise<T[]>
     */
    whereByParams(params: {
        [Identifier: string]: string;
    }): Promise<T[]>;
    /**
     * Deleting a Model
     * @param {number} id
     * @returns Promise<boolean>
     */
    destroy(id: number): Promise<boolean>;
    /**
     * Finding a Model by his id
     * @param {Promise<T>} id
     */
    find(id: number): Promise<T>;
    /**
     * Updating a Model
     * @param {T} model
     */
    update(model: T): Promise<boolean>;
    /**
     * Creating a model
     * @param {T} model
     */
    create(model: T): Promise<boolean>;
    /**
     * Saving a model. Repository decides if it should update or create
     * @param {T} model
     */
    save(model: T): Promise<boolean>;
}

/**
 * Repeats Template Element. Amount is set by the amount of objects
 * inside
 */
declare class VetproviehBasicRepeat extends VetproviehElement {
    /**
         * Getting observed Attributes
         * @return {string[]}
         */
    static get observedAttributes(): string[];
    private _objects;
    protected _listTemplate: DocumentFragment;
    private _orderBy;
    private _afterClearAndRender;
    repository: IRepository<any> | undefined;
    /**
     * Default-Contructor
     * @param {HTMLTemplateElement | undefined} pListTemplate
     * @param {Boolean} shadowed
     */
    constructor(pListTemplate?: HTMLTemplateElement | undefined, shadowed?: boolean);
    /**
     * Set List Template and Render
     * @param {DocumentFragment} val
     */
    set listTemplate(val: DocumentFragment);
    /**
     * Get objects
     * @return {Array<any>}
     */
    get objects(): Array<any>;
    /**
     * Set objects
     * @param {Array<any>} v
     */
    set objects(v: Array<any>);
    /**
     * Get Function for afterClearAndRender
     * @return {Function | undefined}
     */
    get afterClearAndRender(): (() => void) | undefined;
    /**
     * Set Function for afterClearAndRender
     * @param {Function | undefined} func
     */
    set afterClearAndRender(func: (() => void) | undefined);
    /**
    * Get OrderBy
    * Expect "+position" for asceding positon
    * Expect "-position" for descending position
    * @return {string}
    */
    get orderBy(): string;
    /**
     * Set OrderBy
     * @param {string} v
     */
    set orderBy(v: string);
    /**
     * Delete Element
     * @param {number} index
     */
    delete(index: number): void;
    /**
     * Drop Object from List
     * @param {number} index
     */
    private dropObject;
    /**
    * Connected Callback
    */
    connectedCallback(): void;
    /**
     * Clear and Render
     */
    clearAndRender(): void;
    /**
     * Sorting Objects
     */
    private _sortObjects;
    /**
     * List will be cleared
     */
    clear(): void;
    /**
     * Rendering List-Content
     */
    renderList(): void;
    /**
     * Inserts Element to List
     * @param {any} dataItem
     * @param {number} index
     * @private
     */
    protected _attachToList(dataItem: any, index?: number): void;
    /**
     * Getting List Element
     * @return {HTMLElement | undefined}
     */
    protected get list(): HTMLElement | undefined;
    /**
    * Generate new Item for List which is based on the template
    * @param {any} dataItem
    * @param {boolean} activatedEventListener
    * @return {HTMLDivElement}
    * @private
    */
    protected _generateListItem(dataItem: any, activatedEventListener?: boolean): HTMLDivElement;
    /**
     * Intializing Shadow-Root
     * @param {string} template
     * @protected
     */
    protected _initalizeShadowRoot(template: string): void;
}

declare class VetproviehRepeat extends VetproviehBasicRepeat {
}

/**
 * HTML-Element with inner Databinding
 */
declare class ElementBinding extends VetproviehElement {
    private _object;
    private uniqueId;
    private static nextUniqueId;
    /**
       * Getting a unique id for binding
       * @return {number}
       */
    private static getNextUniqueId;
    /**
       * Default-Konstruktor
       */
    constructor();
    /**
      * Getter group
      * @return {any}
      */
    get object(): any;
    /**
       * Setter group
       * @param {any} value
       */
    set object(value: any);
    /**
       * After-Objekt Set, can be overriden
       */
    protected afterObjectSet(): void;
    /**
       * Connected Callback
       */
    connectedCallback(): void;
    /**
       * Callback to Overwrite
       * @protected
       */
    protected _beforeRender(): void;
    /**
       * Callback to Overwrite
       * @protected
       */
    protected _afterRender(): void;
    /**
       * Resetting innerHTML to a blank string
       */
    protected resetInnerHtml(): void;
    /**
       * Building Template to Show
       * @return {HTMLElement}
       */
    private _buildTemplate;
    /**
       * Render Template
       * @private
       */
    protected _renderTemplate(): void;
    /**
      * Returning template
      * @return {string}
      */
    get template(): string;
    /**
        * Observed attributes
        * @return {Array<string>}
        */
    static get observedAttributes(): string[];
}

/**
 * HTML-Element with inner Databinding
 */
declare class ElementGroupBinding extends ElementBinding {
    protected _fieldId: string;
    protected _subfieldBindings: any[];
    /**
     * Returns the subFields of the object
     * must be overwritten in the children
     * @protected
     */
    protected subFields(): Array<any>;
    /**
     * Generating new SubElement
     * @return {ElementBinding}
     */
    protected newElement(): ElementBinding;
    /**
     * Hiding Child Element
     * @param {HTMLElement} block
     */
    protected hideElement(block: HTMLElement): void;
    /**
     * Callback after Render
     * Attach Fields to
     */
    _afterRender(): void;
    /**
     * Attach a Field to Binding
     * @param {ElementBinding} newField
     */
    protected attachField(newField: ElementBinding): void;
}

declare class VetproviehTable extends VetproviehBasicRepeat {
    /**
     * ConnectedCallback
     */
    connectedCallback(): void;
    /**
     * Getting Element by Index
     * @param {number} index
     * @return {HTMLElement | null | undefined}
     */
    getElementByIndex(index: number): HTMLElement | null | undefined;
    /**
     * Inserts Element to List
     * @param {any} dataItem
     * @param {number} index
     * @protected
     */
    protected _attachToList(dataItem: any, index?: number): void;
    /**
     * @private
     * Get Delete_Button from List_Item
     * @param {HTMLElement} listItem
     * @return {HTMLButtonElement}
     */
    private deleteButtonFromItem;
    /**
     * Attaching Parameters to Link
     * @param {HTMLElement} newListItem
     * @param {any} dataItem
     */
    private _attachParamsToLink;
    /**
   * Generate new Item for List which is based on the template
   * @param {any} dataItem
   * @param {boolean} activatedEventListener
   * @return {HTMLDivElement}
   * @private
   */
    protected _generateListItem(dataItem: any, activatedEventListener?: boolean): HTMLTableSectionElement;
}

/**
 * Interface for arguments
 */
interface IWebComponentArgs {
    template?: string | undefined;
    tag: string;
    extends?: string | undefined;
}
/**
 * Web-Component decorator
 * @param {IWebComponentArgs} webComponentArgs
 * @return {any}
 */
declare function WebComponent(webComponentArgs: IWebComponentArgs): <T extends new (...constructorArgs: any[]) => void>(ConstructorFunction: T) => any;

/**
 * A registred Repository decorator
 * @param {T} Constructor
 * @return {any}
 */
declare function RegistieredRepository<T extends {
    new (...args: any[]): any;
}>(Constructor: T): {
    new (...args: any[]): {
        [x: string]: any;
        newProperty: string;
        hello: string;
    };
} & T;

/**
 * BasicModel for Activerecord ORM
 */
declare abstract class BaseModel {
    id: string | number | undefined;
    /**
       * Is Model already saved
       * @return {boolean}
       */
    get persisted(): boolean;
    /**
       * Is the model already persisted?
       * @param {BaseModel} model
       * @return {boolean}
       */
    static isPersisted(model: BaseModel): boolean;
    /**
       * Getting the Endpoint Adress
       * @return {string}
       */
    static get endpoint(): string;
}

/**
 * Basic Repository to Build an HTTPbased ActiveRecord
 */
declare abstract class BaseRepository<T extends BaseModel> implements IRepository<T> {
    private _endpoint;
    /**
       * Default-Konstruktor
       * @param {string} endpoint
       */
    constructor(endpoint: string);
    /**
       * Get Current Endpoint
       * @return {string}
       */
    get endpoint(): string;
    /**
       * Getting all Datasets without a filter
       * @return {Promise<T[]>}
       */
    all(): Promise<T[]>;
    /**
       * Searching for a String
       * @param {string | undefined} search
       * @return {Promise<T[]>}
       */
    where(search: string | undefined): Promise<T[]>;
    /**
       * Suche mit Parametern
       * @param {any} params
       * @return {Promise<T[]>}
       */
    whereByParams(params: {
        [Identifier: string]: string;
    }): Promise<T[]>;
    /**
       * Destroy Entity by id
       * @param {number} id
       * @return {Promise<boolean>}
       */
    destroy(id: number): Promise<boolean>;
    /**
       * Find a Object by its id
       * @param {number} id
       * @return {Promise<T>}
       */
    find(id: number): Promise<T>;
    /**
       * Update a Entity in Backend
       * @param {T} model
       * @return {Promise<boolean>}
       */
    update(model: T): Promise<boolean>;
    /**
       * Create a new Entity in Backend
       * @param {T} model
       * @return {Promise<boolean>}
       */
    create(model: T): Promise<boolean>;
    /**
       * Save automatically decides if a model should be created
       * or updated. The decision is based on the model id
       * @param {T} model
       * @return {Promise<boolean>}
       */
    save(model: T): Promise<boolean>;
    /**
       * Build Endpoint relative URL for ID
       * @param {number|string} id
       * @return {string}
       */
    private buildEndpointWithId;
    /**
        * Search by Value in Array
        * @param {Array} data
        * @param {string | undefined} searchValue
        * @return {Array}
        */
    static search(data: Array<any>, searchValue: string | undefined): any[];
    /**
       * Search by a Key-Value Pair in Array
      * @param {Array} data
      * @param {any} search
      * @return {Array}
       */
    static searchByKeys(data: Array<any>, search: {
        [Identifier: string]: string;
    }): any[];
    /**
       * Searching Objekt for Keys.
       * @param {any} obj
       * @param {any} search
       * @return {boolean}
       */
    private static _internalFilterByKeys;
    /**
       * Register a Repository
       * @param {string} name
       * @param {any} clazz
       */
    static registerRepositoryByName(name: string, clazz: any): void;
    /**
       * Getting Repository by name
       * @param {string} name
       * @return {BaseRepository<T>}
       */
    static getRepositoryByName<T extends BaseModel>(name: string): BaseRepository<T> | undefined;
    /**
       * @private
       * Replacing Values with URL-Params
       * @param {string} val
       * @return {string}
       */
    private static _replaceParams;
    private static classes;
}

export { BaseModel, BaseRepository, ElementBinding, ElementGroupBinding, GeoHelper, IRepository, Indexable, ObjectHelper, RegistieredRepository, VetproviehBasicRepeat, VetproviehBinding, VetproviehElement, VetproviehNavParams, VetproviehRepeat, VetproviehTable, ViewHelper, WebComponent };