import { OnDestroy, OnInit } from '@angular/core';
import { FormControl } from '@angular/forms';
import { ActivatedRoute, QueryParamsHandling, Router } from '@angular/router';
import { ResultOf, TypedDocumentNode, VariablesOf } from '@graphql-typed-document-node/core';
import { BehaviorSubject, Observable, Subject } from 'rxjs';
import { DataService } from '../data/providers/data.service';
import { QueryResult } from '../data/query-result';
import { ServerConfigService } from '../data/server-config';
import { DataTableConfigService } from '../providers/data-table/data-table-config.service';
import { DataTableFilterCollection } from '../providers/data-table/data-table-filter-collection';
import { DataTableSortCollection } from '../providers/data-table/data-table-sort-collection';
import { PermissionsService } from '../providers/permissions/permissions.service';
import { DataTable2ColumnComponent } from '../shared/components/data-table-2/data-table-column.component';
import { DataTableCustomFieldColumnComponent } from '../shared/components/data-table-2/data-table-custom-field-column.component';
import { CustomFieldConfig, CustomFields, LanguageCode } from './generated-types';
import { SelectionManager } from './utilities/selection-manager';
import * as i0 from "@angular/core";
export type ListQueryFn<R> = (take: number, skip: number, ...args: any[]) => QueryResult<R, any>;
export type MappingFn<T, R> = (result: R) => {
    items: T[];
    totalItems: number;
};
export type OnPageChangeFn<V> = (skip: number, take: number) => V;
/**
 * Unwraps a query that returns a paginated list with an "items" property,
 * returning the type of one of the items in the array.
 */
export type ItemOf<T, K extends keyof T> = T[K] extends {
    items: infer R;
} ? R extends any[] ? R[number] : R : never;
/**
 * @description
 * This is a base class which implements the logic required to fetch and manipulate
 * a list of data from a query which returns a PaginatedList type.
 *
 * It is normally used in combination with the {@link DataTable2Component}.
 *
 * @docsCategory list-detail-views
 */
export declare class BaseListComponent<ResultType, ItemType, VariableType extends Record<string, any> = any> implements OnInit, OnDestroy {
    protected router: Router;
    protected route: ActivatedRoute;
    searchTermControl: FormControl<string | null>;
    selectionManager: SelectionManager<any>;
    result$: Observable<ResultType>;
    items$: Observable<ItemType[]>;
    totalItems$: Observable<number>;
    itemsPerPage$: Observable<number>;
    currentPage$: Observable<number>;
    protected destroy$: Subject<void>;
    private listQuery;
    private listQueryFn;
    private mappingFn;
    private onPageChangeFn;
    protected refresh$: BehaviorSubject<undefined>;
    private defaults;
    protected visibleCustomFieldColumnChange$: Subject<DataTableCustomFieldColumnComponent<any>[]>;
    constructor(router: Router, route: ActivatedRoute);
    /**
     * @description
     * Sets the fetch function for the list being implemented.
     */
    setQueryFn(listQueryFn: ListQueryFn<ResultType>, mappingFn: MappingFn<ItemType, ResultType>, onPageChangeFn?: OnPageChangeFn<VariableType>, defaults?: {
        take: number;
        skip: number;
    }): void;
    /** @internal */
    ngOnInit(): void;
    /**
     * @description
     * Accepts a list of Observables which will trigger a refresh of the list when any of them emit.
     */
    protected refreshListOnChanges(...streams: Array<Observable<any>>): void;
    /** @internal */
    ngOnDestroy(): void;
    /**
     * @description
     * Sets the current page number in the url.
     */
    setPageNumber(page: number): void;
    /**
     * @description
     * Sets the number of items per page in the url.
     */
    setItemsPerPage(perPage: number): void;
    setVisibleColumns(columns: Array<DataTable2ColumnComponent<any>>): void;
    /**
     * @description
     * Re-fetch the current page of results.
     */
    refresh(): void;
    protected setQueryParam(hash: {
        [key: string]: any;
    }, options?: {
        replaceUrl?: boolean;
        queryParamsHandling?: QueryParamsHandling;
    }): any;
    protected setQueryParam(key: string, value: any, options?: {
        replaceUrl?: boolean;
        queryParamsHandling?: QueryParamsHandling;
    }): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseListComponent<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseListComponent<any, any, any>, never, never, {}, {}, never, never, true, never>;
}
/**
 * @description
 * A version of the {@link BaseListComponent} which is designed to be used with a
 * [TypedDocumentNode](https://the-guild.dev/graphql/codegen/plugins/typescript/typed-document-node).
 *
 * @docsCategory list-detail-views
 */
export declare class TypedBaseListComponent<T extends TypedDocumentNode<any, Vars>, Field extends keyof ResultOf<T>, Vars extends {
    options: {
        filter: any;
        sort: any;
    };
} = VariablesOf<T>> extends BaseListComponent<ResultOf<T>, ItemOf<ResultOf<T>, Field>, VariablesOf<T>> implements OnInit {
    availableLanguages$: Observable<LanguageCode[]>;
    contentLanguage$: Observable<LanguageCode>;
    protected dataService: DataService;
    protected router: Router;
    protected serverConfigService: ServerConfigService;
    protected permissionsService: PermissionsService;
    protected dataTableConfigService: DataTableConfigService;
    /**
     * This was introduced to allow us to more easily manage the relation between the
     * DataTableComponent and the BaseListComponent. It allows the base class to
     * correctly look up the currently-visible custom field columns, which can then
     * be passed to the `dataService.query()` method.
     */
    protected dataTableListId: string | undefined;
    private refreshStreams;
    private collections;
    constructor();
    protected configure(config: {
        document: T;
        getItems: (data: ResultOf<T>) => {
            items: Array<ItemOf<ResultOf<T>, Field>>;
            totalItems: number;
        };
        setVariables?: (skip: number, take: number) => VariablesOf<T>;
        refreshListOnChanges?: Array<Observable<any>>;
    }): void;
    ngOnInit(): void;
    createFilterCollection(): DataTableFilterCollection<NonNullable<NonNullable<Vars['options']>['filter']>>;
    createSortCollection(): DataTableSortCollection<NonNullable<NonNullable<Vars['options']>['sort']>>;
    setLanguage(code: LanguageCode): void;
    getCustomFieldConfig(key: Exclude<keyof CustomFields, '__typename'> | string): CustomFieldConfig[];
    static ɵfac: i0.ɵɵFactoryDeclaration<TypedBaseListComponent<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TypedBaseListComponent<any, any, any>, never, never, {}, {}, never, never, true, never>;
}