@ng-atomic/common 19.0.0-preview.8 → 19.1.1

package/index.d.ts

@@ -1 +1,111 @@
-export * from './common.module';
+import * as i0 from '@angular/core';
+import { EnvironmentProviders, OnDestroy } from '@angular/core';
+import * as i1 from '@angular/material/dialog';
+import * as i2 from '@angular/material/snack-bar';
+import * as i3 from '@ng-atomic/common/services/sheets';
+import * as rxjs from 'rxjs';
+import { MonoTypeOperatorFunction } from 'rxjs';
+
+declare class NgAtomicCommonModule {
+    static forRoot(): {
+        ngModule: typeof NgAtomicCommonModule;
+        providers: any[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgAtomicCommonModule, never, [typeof i1.MatDialogModule, typeof i2.MatSnackBarModule, typeof i3.NgAtomicSheetsModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgAtomicCommonModule>;
+}
+declare function provideNgAtomicCommon(): EnvironmentProviders;
+
+/**
+ * EditingStateManager Service
+ *
+ * Manages global editing state for preventing data updates during cell editing.
+ * Uses Angular Signals for reactive state management.
+ */
+declare class EditingStateManager {
+    private readonly editingCells;
+    readonly isEditing: i0.Signal<boolean>;
+    readonly isEditing$: rxjs.Observable<boolean>;
+    /**
+     * Start editing a cell
+     * @param rowId Row identifier
+     * @param columnId Column identifier
+     */
+    startEditing(rowId: string | number, columnId: string): void;
+    /**
+     * Stop editing a cell
+     * @param rowId Row identifier
+     * @param columnId Column identifier
+     */
+    stopEditing(rowId: string | number, columnId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditingStateManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EditingStateManager>;
+}
+
+/**
+ * Custom RxJS operator that pauses data flow when editing is active.
+ *
+ * When editing starts, incoming values are buffered.
+ * When editing ends, the latest buffered value is emitted.
+ *
+ * @param editingStateManager The EditingStateManager service instance
+ * @returns An operator function that can be used in RxJS pipe
+ *
+ * @example
+ * ```typescript
+ * dataStream$.pipe(
+ *   pauseWhenEditing(this.editingStateManager),
+ *   // ... other operators
+ * )
+ * ```
+ */
+declare function pauseWhenEditing<T>(editingStateManager: EditingStateManager): MonoTypeOperatorFunction<T>;
+/**
+ * Alternative operator that buffers ALL updates during editing.
+ *
+ * When editing ends, all buffered values are emitted in sequence.
+ * This preserves the complete update history.
+ *
+ * @param editingStateManager The EditingStateManager service instance
+ * @returns An operator function that can be used in RxJS pipe
+ *
+ * @example
+ * ```typescript
+ * dataStream$.pipe(
+ *   bufferWhenEditing(this.editingStateManager),
+ *   // ... other operators
+ * )
+ * ```
+ */
+declare function bufferWhenEditing<T>(editingStateManager: EditingStateManager): MonoTypeOperatorFunction<T>;
+
+/**
+ * アクティブ状態を管理するディレクティブ
+ *
+ * クリックでアクティブ化、外部クリックで非アクティブ化し、
+ * スクロール位置の固定やイベント伝播の制御を行います。
+ *
+ * @example
+ * ```html
+ * <div appActiveControl
+ *      [scrollSelector]="'.xterm-viewport'"
+ *      (activeChange)="onActiveChange($event)">
+ *   <!-- content -->
+ * </div>
+ * ```
+ */
+declare class ActiveControlDirective implements OnDestroy {
+    private readonly el;
+    readonly scrollSelector: i0.InputSignal<string>;
+    readonly activeChange: i0.OutputEmitterRef<boolean>;
+    readonly isActive: i0.WritableSignal<boolean>;
+    private cleanupFunctions;
+    constructor();
+    ngOnDestroy(): void;
+    private initialize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ActiveControlDirective, "[appActiveControl]", never, { "scrollSelector": { "alias": "scrollSelector"; "required": false; "isSignal": true; }; }, { "activeChange": "activeChange"; }, never, never, true, never>;
+}
+
+export { ActiveControlDirective, EditingStateManager, NgAtomicCommonModule, bufferWhenEditing, pauseWhenEditing, provideNgAtomicCommon };

package/interceptors/authorization/index.d.ts

@@ -1 +1,20 @@
-export * from './authorization.interceptor';
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpInterceptorFn } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+type GetAuthorization = () => Promise<string | null> | Observable<string | null>;
+declare const AUTHORIZATION: InjectionToken<GetAuthorization>;
+/** @deprecated use `authorizationInterceptor` instead. */
+declare class AuthorizationInterceptor implements HttpInterceptor {
+    private getAuth;
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    private getRequestWithToken;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationInterceptor>;
+}
+declare function authorizationInterceptor(isAuthorizedRequest?: (req: HttpRequest<unknown>) => boolean): HttpInterceptorFn;
+declare function provideAuthorization(useFactory: () => GetAuthorization): Provider;
+
+export { AUTHORIZATION, AuthorizationInterceptor, authorizationInterceptor, provideAuthorization };
+export type { GetAuthorization };

package/interceptors/index.d.ts

@@ -1 +1,10 @@
-export * from './interceptors.module';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class InterceptorsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterceptorsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InterceptorsModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InterceptorsModule>;
+}
+
+export { InterceptorsModule };

package/interceptors/throttle/index.d.ts

@@ -1 +1,25 @@
-export * from './throttle.interceptor';
+import { HttpInterceptor, HttpEvent, HttpRequest, HttpHandler } from '@angular/common/http';
+import { Subject, Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class IcedCacheService {
+    cache: {};
+    has(key: string): boolean;
+    get(key: string): Subject<HttpEvent<unknown>>;
+    set(key: string, value: Subject<HttpEvent<unknown>>): void;
+    removeAfter(key: string, ms?: number): void;
+    remove(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IcedCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IcedCacheService>;
+}
+declare class ThrottleInterceptor implements HttpInterceptor {
+    private cache;
+    constructor(cache: IcedCacheService);
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    protected test(req: HttpRequest<unknown>): boolean;
+    private buildKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThrottleInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThrottleInterceptor>;
+}
+
+export { ThrottleInterceptor };

package/interceptors/token/index.d.ts

@@ -1 +1,17 @@
-export * from './authorization.interceptor';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+type ProvideAuthorization = () => Promise<string | null> | Observable<string | null>;
+declare const PROVIDE_AUTHORIZATION: InjectionToken<ProvideAuthorization>;
+declare class AuthorizationInterceptor implements HttpInterceptor {
+    private provide;
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    private getRequestWithToken;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationInterceptor>;
+}
+
+export { AuthorizationInterceptor, PROVIDE_AUTHORIZATION };
+export type { ProvideAuthorization };

package/models/index.d.ts

@@ -1,20 +1,39 @@
 import { Actions } from '@ng-atomic/core';
-export * from './menu-item';
-export interface Page {
+
+interface Message {
+    time: Date;
+    content?: string;
+    role: 'assistant' | 'user' | 'system';
+    attachments?: Attachment[];
+    isWriting?: boolean;
+}
+interface Attachment {
+    name: string;
+    type: 'image' | 'video';
+    file: File;
+    url?: string;
+}
+
+interface MenuItem {
+    id: number | string;
+    name: string;
+}
+
+interface Page {
     pageIndex: number;
     pageSize: number;
 }
-export interface Sort {
+interface Sort {
     key: string;
     order: 'asc' | 'desc';
 }
-export interface Index {
+interface Index {
     query: string;
     page: Page;
     sort: Sort;
 }
-export type ColumnType = 'text' | 'actions' | 'checkbox' | 'tree';
-export interface BaseColumn {
+type ColumnType = 'text' | 'actions' | 'checkbox' | 'tree';
+interface BaseColumn {
     type: ColumnType;
     name?: string;
     visible: boolean;
@@ -24,17 +43,19 @@ export interface BaseColumn {
     stickyEnd?: boolean;
     stickyLeft?: number;
 }
-export interface ActionsColumn extends BaseColumn {
+interface ActionsColumn extends BaseColumn {
     type: 'actions';
     actions?: Actions;
 }
-export interface TextColumn extends BaseColumn {
+interface TextColumn extends BaseColumn {
     type: 'text';
 }
-export interface CheckboxColumn extends BaseColumn {
+interface CheckboxColumn extends BaseColumn {
     type: 'checkbox';
 }
-export interface TreeColumnMolecule extends BaseColumn {
+interface TreeColumnMolecule extends BaseColumn {
     type: 'tree';
 }
-export type Column = ActionsColumn | TextColumn | CheckboxColumn | TreeColumnMolecule;
+type Column = ActionsColumn | TextColumn | CheckboxColumn | TreeColumnMolecule;
+
+export type { ActionsColumn, Attachment, BaseColumn, CheckboxColumn, Column, ColumnType, Index, MenuItem, Message, Page, Sort, TextColumn, TreeColumnMolecule };

package/package.json

@@ -1,34 +1,10 @@
 {
   "name": "@ng-atomic/common",
-  "version": "19.0.0-preview.8",
+  "version": "19.1.1",
   "license": "MIT",
   "peerDependencies": {
-    "@angular/cdk": "19.1.2",
-    "@angular/common": "19.1.4",
-    "@angular/core": "19.1.4",
-    "@angular/fire": "18.0.1",
-    "@angular/forms": "19.1.4",
-    "@angular/material": "19.1.2",
-    "@angular/router": "19.1.4",
-    "@ngrx/component-store": "19.0.1",
-    "@nx-ddd/core": "19.0.0-preview.8",
-    "dayjs": "1.11.13",
-    "flat": "^6.0.0",
-    "lodash-es": "^4.17.15",
-    "papaparse": "^5.4.1",
-    "rxjs": "^7.0.0",
-    "@ng-atomic/core": "19.0.0-preview.8",
-    "@nx-ddd/common": "19.0.0-preview.8",
-    "class-validator": "^0.14.0",
-    "ngxtension": "^2.0.0",
-    "ffprobe-wasm": "^0.3.1",
-    "json-schema-library": "^10.0.0-rc2",
-    "class-validator-jsonschema": "^5.0.0",
-    "json-schema": "0.4.0",
-    "class-transformer": "^0.5.1",
-    "angular-material-css-vars": "^7.0.0",
-    "crypto-js": "4.2.0",
-    "@ngrx/entity": "19.0.1"
+    "@nx-ddd/core": "19.1.1",
+    "@nx-ddd/common": "19.1.1"
   },
   "dependencies": {
     "tslib": "^2.3.0"
@@ -63,14 +39,14 @@
       "types": "./directives/ios-safari-scroll-buggyfill/index.d.ts",
       "default": "./fesm2022/ng-atomic-common-directives-ios-safari-scroll-buggyfill.mjs"
     },
-    "./interceptors/authorization": {
-      "types": "./interceptors/authorization/index.d.ts",
-      "default": "./fesm2022/ng-atomic-common-interceptors-authorization.mjs"
-    },
     "./directives/resize-column": {
       "types": "./directives/resize-column/index.d.ts",
       "default": "./fesm2022/ng-atomic-common-directives-resize-column.mjs"
     },
+    "./interceptors/authorization": {
+      "types": "./interceptors/authorization/index.d.ts",
+      "default": "./fesm2022/ng-atomic-common-interceptors-authorization.mjs"
+    },
     "./interceptors/throttle": {
       "types": "./interceptors/throttle/index.d.ts",
       "default": "./fesm2022/ng-atomic-common-interceptors-throttle.mjs"
@@ -191,14 +167,18 @@
       "types": "./services/chips-manager/index.d.ts",
       "default": "./fesm2022/ng-atomic-common-services-chips-manager.mjs"
     },
-    "./services/fab": {
-      "types": "./services/fab/index.d.ts",
-      "default": "./fesm2022/ng-atomic-common-services-fab.mjs"
-    },
     "./services/csv": {
       "types": "./services/csv/index.d.ts",
       "default": "./fesm2022/ng-atomic-common-services-csv.mjs"
     },
+    "./services/editing": {
+      "types": "./services/editing/index.d.ts",
+      "default": "./fesm2022/ng-atomic-common-services-editing.mjs"
+    },
+    "./services/fab": {
+      "types": "./services/fab/index.d.ts",
+      "default": "./fesm2022/ng-atomic-common-services-fab.mjs"
+    },
     "./services/form": {
       "types": "./services/form/index.d.ts",
       "default": "./fesm2022/ng-atomic-common-services-form.mjs"

package/pipes/actions/index.d.ts

@@ -1 +1,11 @@
-export * from './actions.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { Action } from '@ng-atomic/core';
+
+declare class ActionsPipe implements PipeTransform {
+    transform(value: any, ...args: any[]): Action[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ActionsPipe, "resolveActions", true>;
+}
+
+export { ActionsPipe };

package/pipes/auto-columns/index.d.ts

@@ -1 +1,10 @@
-export * from './auto-columns.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class AutoColumnsPipe<T> implements PipeTransform {
+    transform(items: T[]): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoColumnsPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AutoColumnsPipe<any>, "autoColumns", true>;
+}
+
+export { AutoColumnsPipe };

package/pipes/columns/index.d.ts

@@ -1 +1,12 @@
-export * from './columns.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { Column } from '@ng-atomic/common/models';
+
+/** @deprecated */
+declare class ColumnsPipe implements PipeTransform {
+    transform<T>(columns: Column[]): Column[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnsPipe, "columns", true>;
+}
+
+export { ColumnsPipe };

package/pipes/data-accessor/index.d.ts

@@ -1 +1,23 @@
-export * from './data-accessor.pipe';
+import * as i0 from '@angular/core';
+import { InjectionToken, PipeTransform } from '@angular/core';
+
+type DataAccessor<T> = (obj: T, key: string, context?: number | any) => any;
+declare const DATA_ACCESSOR: InjectionToken<DataAccessor<any>>;
+declare const defaultDataAccessor: DataAccessor<any>;
+declare function provideDataAccessor<T>(useFactory?: () => DataAccessor<T>, { merge }?: {
+    merge?: boolean;
+}): {
+    provide: InjectionToken<DataAccessor<any>>;
+    useFactory: () => DataAccessor<T>;
+};
+declare function injectDataAccessor<T>(): DataAccessor<T>;
+declare function injectParentDataAccessor<T>(): DataAccessor<T>;
+declare class DataAccessorPipe<T> implements PipeTransform {
+    protected dataAccessor: DataAccessor<unknown>;
+    transform(data: T, key: string, index?: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataAccessorPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DataAccessorPipe<any>, "dataAccessor", true>;
+}
+
+export { DATA_ACCESSOR, DataAccessorPipe, defaultDataAccessor, injectDataAccessor, injectParentDataAccessor, provideDataAccessor };
+export type { DataAccessor };

package/pipes/domain/index.d.ts

@@ -1 +1,72 @@
-export * from './domain.pipe';
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal, PipeTransform, Injector } from '@angular/core';
+import { Type, Entity } from '@nx-ddd/common/domain';
+import { SignalOrValue } from '@ng-atomic/common/pipes/signal';
+import { LanguageService, DomainLangMap } from '@ng-atomic/common/services/language';
+
+declare const DOMAIN_MODEL: InjectionToken<Type<{
+    id: string;
+}>>;
+declare const DOMAIN_PROPS: InjectionToken<Signal<string[]>>;
+declare const DOMAIN_MODEL_NAME: InjectionToken<Signal<string>>;
+declare class DomainPipe implements PipeTransform {
+    readonly language: LanguageService;
+    transform(input: string, map?: DomainLangMap): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DomainPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DomainPipe, "domain", true>;
+}
+declare function injectParentLangMap(): DomainLangMap;
+/** @deprecated use `injectParentLangMap` instead */
+declare const injectParentDomainLangMap: typeof injectParentLangMap;
+declare function provideLangMap(useFactory: () => DomainLangMap, { merge }?: {
+    merge?: boolean;
+}): {
+    provide: InjectionToken<DomainLangMap>;
+    useFactory: () => DomainLangMap;
+};
+/** @deprecated use `provideLangMap` instead */
+declare function provideDomainLang<E>(domain: Type<E>, mergeObj?: DomainLangMap): {
+    provide: InjectionToken<DomainLangMap>;
+    useFactory: () => DomainLangMap;
+};
+/** @deprecated */
+declare function provideModel<E>(useFactory: () => Type<E>): {
+    provide: InjectionToken<Type<{
+        id: string;
+    }>>;
+    useFactory: () => Type<E>;
+};
+/** @deprecated */
+declare function injectModel<E = Entity>(): Type<E>;
+/** @deprecated */
+declare function provideProps(useFactory: () => SignalOrValue<string[]>): {
+    provide: InjectionToken<Signal<string[]>>;
+    useFactory: () => Signal<string[]>;
+};
+/** @deprecated */
+declare function provideModelName(useFactory: () => SignalOrValue<string>): {
+    provide: InjectionToken<Signal<string>>;
+    useFactory: () => Signal<string>;
+};
+/** @deprecated */
+declare function injectProps(): Signal<string[]>;
+/** @deprecated */
+declare function injectModelName(injector?: Injector): Signal<string>;
+/** @deprecated */
+declare function provideDomain<E>(useFactory: () => Type<E>): ({
+    provide: InjectionToken<DomainLangMap>;
+    useFactory: () => DomainLangMap;
+} | {
+    provide: InjectionToken<Signal<string[]>>;
+    useFactory: () => Signal<string[]>;
+} | {
+    provide: InjectionToken<Signal<string>>;
+    useFactory: () => Signal<string>;
+} | {
+    provide: InjectionToken<Type<{
+        id: string;
+    }>>;
+    useFactory: () => Type<E>;
+})[];
+
+export { DOMAIN_MODEL, DOMAIN_MODEL_NAME, DOMAIN_PROPS, DomainPipe, injectModel, injectModelName, injectParentDomainLangMap, injectParentLangMap, injectProps, provideDomain, provideDomainLang, provideLangMap, provideModel, provideModelName, provideProps };

package/pipes/error/index.d.ts

@@ -1 +1,21 @@
-export * from './error.pipe';
+import * as i0 from '@angular/core';
+import { InjectionToken, PipeTransform } from '@angular/core';
+import { ValidationErrors } from '@angular/forms';
+
+type ErrorMessageResolver = (errors: ValidationErrors) => string;
+declare const ERROR_MESSAGE_RESOLVER: InjectionToken<ErrorMessageResolver>;
+declare const defaultErrorMessageResolver: ErrorMessageResolver;
+declare function provideErrorMessageResolver(resolver: ErrorMessageResolver): {
+    provide: InjectionToken<ErrorMessageResolver>;
+    useValue: ErrorMessageResolver;
+};
+declare function injectErrorMessageResolver(): ErrorMessageResolver;
+declare class ErrorPipe implements PipeTransform {
+    protected resolver: ErrorMessageResolver;
+    transform(errors: ValidationErrors): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ErrorPipe, "error", true>;
+}
+
+export { ERROR_MESSAGE_RESOLVER, ErrorPipe, defaultErrorMessageResolver, injectErrorMessageResolver, provideErrorMessageResolver };
+export type { ErrorMessageResolver };

package/pipes/expression/index.d.ts

@@ -1 +1,13 @@
-export * from './expression.pipe';
+import * as _ng_atomic_common_utils from '@ng-atomic/common/utils';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import dayjs from 'dayjs';
+
+declare class ExpressionPipe implements PipeTransform {
+    protected transformer: _ng_atomic_common_utils.ExpressionTransformer;
+    transform(input: string | number | dayjs.Dayjs | any, key?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpressionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ExpressionPipe, "expression", true>;
+}
+
+export { ExpressionPipe };

package/pipes/grouped-by/index.d.ts

@@ -1 +1,13 @@
-export * from './grouped-by.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class GroupedByPipe implements PipeTransform {
+    private dataAccessor;
+    transform<T>(items: T[], groupedBy?: string): {
+        [id: string]: T[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupedByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GroupedByPipe, "groupedBy", true>;
+}
+
+export { GroupedByPipe };

package/pipes/index/index.d.ts

@@ -1 +1,17 @@
-export * from './index.pipe';
+import * as _ng_atomic_common_pipes_page from '@ng-atomic/common/pipes/page';
+import * as _ng_atomic_common_pipes_data_accessor from '@ng-atomic/common/pipes/data-accessor';
+import * as _ng_atomic_common_models from '@ng-atomic/common/models';
+import { Index } from '@ng-atomic/common/models';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class IndexPipe<T> implements PipeTransform {
+    protected query: (items: T[], query: string) => any[];
+    protected sortBy: (items: T[], { key, order }?: Partial<_ng_atomic_common_models.Sort>, dataAccessor?: _ng_atomic_common_pipes_data_accessor.DataAccessor<T>) => T[];
+    protected page: typeof _ng_atomic_common_pipes_page.defaultPageTransformer;
+    transform(items: T[], params: Partial<Index>): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IndexPipe<any>, "index", true>;
+}
+
+export { IndexPipe };

package/pipes/index-length/index.d.ts

@@ -1 +1,15 @@
-export * from './index-length.pipe';
+import * as _ng_atomic_common_pipes_data_accessor from '@ng-atomic/common/pipes/data-accessor';
+import * as _ng_atomic_common_models from '@ng-atomic/common/models';
+import { Index } from '@ng-atomic/common/models';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class IndexLengthPipe<T> implements PipeTransform {
+    protected query: (items: T[], query: string) => any[];
+    protected sortBy: (items: T[], { key, order }?: Partial<_ng_atomic_common_models.Sort>, dataAccessor?: _ng_atomic_common_pipes_data_accessor.DataAccessor<T>) => T[];
+    transform(items: T[], prams: Partial<Index>): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexLengthPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IndexLengthPipe<any>, "indexLength", true>;
+}
+
+export { IndexLengthPipe };

package/pipes/keys/index.d.ts

@@ -1 +1,12 @@
-export * from './keys.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class KeysPipe implements PipeTransform {
+    transform(obj: {
+        [id: string]: any;
+    }): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeysPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeysPipe, "keys", true>;
+}
+
+export { KeysPipe };

package/pipes/map/index.d.ts

@@ -1 +1,10 @@
-export * from './map.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class MapPipe<T> implements PipeTransform {
+    transform(itemOrItems: T | T[], path: string): any | any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MapPipe<any>, "map", true>;
+}
+
+export { MapPipe };

package/pipes/page/index.d.ts

@@ -1 +1,14 @@
-export * from './page.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { Page } from '@ng-atomic/common/models';
+
+declare function defaultPageTransformer<T>(items: T[], { pageIndex, pageSize }?: Partial<Page>): T[];
+declare function injectPageTransformer<T>(): typeof defaultPageTransformer;
+declare class PagePipe<T> implements PipeTransform {
+    protected transformer: typeof defaultPageTransformer;
+    transform(items: T[], params?: Partial<Page>): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PagePipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PagePipe<any>, "page", true>;
+}
+
+export { PagePipe, defaultPageTransformer, injectPageTransformer };

package/pipes/pagination/index.d.ts

@@ -1 +1,28 @@
-export * from './pagination.pipe';
+import * as i0 from '@angular/core';
+import { InjectionToken, PipeTransform } from '@angular/core';
+
+interface Page {
+    start: number;
+    end: number;
+    key: string;
+    order: 'asc' | 'desc';
+}
+declare const PAGINATION_TRANSFORMER: InjectionToken<unknown>;
+type PaginationTransformer<E> = (items: E[], page: Page) => E[];
+declare function paginationTransformer<E>(items: E[], page: Page): E[];
+declare class PaginationPipe<E> implements PipeTransform {
+    private transformer;
+    constructor(transformer: PaginationTransformer<E>);
+    transform(items: E[], { sortKey, sortOrder, start, end }?: {
+        sortKey?: string;
+        sortOrder?: 'asc' | 'desc';
+        start?: number;
+        end?: number;
+    }): E[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationPipe<any>, [{ optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PaginationPipe<any>, "pagination", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationPipe<any>>;
+}
+
+export { PAGINATION_TRANSFORMER, PaginationPipe, paginationTransformer };
+export type { PaginationTransformer };