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

package/pipes/query/index.d.ts

@@ -1 +1,14 @@
-export * from './query.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare function defaultQueryTransformer<T>(items: T[], query: string): T[];
+declare function injectQueryTransformer<T>(): (items: T[], query: string) => any[];
+declare class QueryPipe<T> implements PipeTransform {
+    protected transformer: (items: T[], query: string) => any[];
+    transform(items: T[], query: string): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<QueryPipe<any>, "query", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryPipe<any>>;
+}
+
+export { QueryPipe, defaultQueryTransformer, injectQueryTransformer };

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

@@ -1 +1,14 @@
-export * from './resolve-columns.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class ResolveColumnsPipe implements PipeTransform {
+    transform(columns: string[]): {
+        type: 'key' | 'actions' | 'checkbox';
+        name: string;
+        payload?: any;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveColumnsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ResolveColumnsPipe, "resolveColumns", true>;
+}
+
+export { ResolveColumnsPipe };

package/pipes/secret/index.d.ts

@@ -1 +1,11 @@
-export * from './secret.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class SecretPipe implements PipeTransform {
+    private secret;
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecretPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SecretPipe, "secret", true>;
+}
+
+export { SecretPipe };

package/pipes/select-id/index.d.ts

@@ -1 +1,16 @@
-export * from './select-id.pipe';
+import * as i0 from '@angular/core';
+import { InjectionToken, PipeTransform } from '@angular/core';
+
+type SelectId = (entity: object) => string | number;
+declare const SELECT_ID: InjectionToken<SelectId>;
+declare const defaultSelectId: SelectId;
+declare class SelectIdPipe implements PipeTransform {
+    protected selectId: SelectId;
+    constructor(selectId: SelectId);
+    transform(entity: any): string | number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectIdPipe, [{ optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SelectIdPipe, "selectId", true>;
+}
+
+export { SELECT_ID, SelectIdPipe, defaultSelectId };
+export type { SelectId };

package/pipes/signal/index.d.ts

@@ -1 +1,15 @@
-export * from './signal.pipe';
+import * as i0 from '@angular/core';
+import { Signal, PipeTransform } from '@angular/core';
+
+type SignalOrValue<T> = T | Signal<T>;
+declare function signalize<T = any>(valueOrSignal: T | Signal<T>): Signal<T>;
+declare function wrapFactory<T>(valueOrSignalFactory: (...args: any[]) => T | Signal<T>): () => Signal<T>;
+declare function resolveSignal<T>(valueOrSignal: T | Signal<T>): T;
+declare class SignalPipe implements PipeTransform {
+    transform<T>(obj: T | Signal<T>): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SignalPipe, "signal", true>;
+}
+
+export { SignalPipe, resolveSignal, signalize, wrapFactory };
+export type { SignalOrValue };

package/pipes/smart-field/index.d.ts

@@ -1 +1,102 @@
-export * from './smart-field.pipe';
+import * as i0 from '@angular/core';
+import { Signal, InjectionToken, PipeTransform } from '@angular/core';
+import { Action } from '@ng-atomic/core';
+import { SignalOrValue } from '@ng-atomic/common/pipes/signal';
+
+interface Option<T> {
+    name: string;
+    value: T;
+}
+interface BaseField {
+    placeholder?: string;
+    hint?: SignalOrValue<string>;
+    actions?: Action[] | Signal<Action[]>;
+}
+interface TextField extends BaseField {
+    type: 'text';
+    autoComplete?: SignalOrValue<string[]>;
+}
+interface PasswordField extends BaseField {
+    type: 'password';
+}
+interface NumberField extends BaseField {
+    type: 'number';
+}
+interface TextareaField extends BaseField {
+    type: 'textarea';
+    rows?: number;
+}
+interface DateInputField extends BaseField {
+    type: 'date';
+}
+interface DateRangeInputField extends BaseField {
+    type: 'date-range';
+}
+interface SelectField<T> extends BaseField {
+    type: 'select';
+    options: Option<T>[] | Signal<Option<T>[]>;
+    multiple?: boolean;
+}
+interface TimeRangeField extends BaseField {
+    type: 'time-range';
+}
+interface MultiSelectField<T> extends BaseField {
+    type: 'multi-select';
+    options: Option<T>[] | Signal<Option<T>[]>;
+}
+interface FileField extends BaseField {
+    type: 'file';
+    progress?: Signal<number | null>;
+}
+interface ActionField extends BaseField {
+    type: 'action';
+    actions: Action[] | Signal<Action[]>;
+    buttonType?: 'flat' | 'raised' | 'stroked' | 'icon';
+    disabled?: boolean;
+}
+interface AgreementField {
+    type: 'agreement';
+    labelTemp: null | any;
+}
+interface SliderField extends BaseField {
+    type: 'slider';
+    slider: {
+        min?: number;
+        max?: number;
+        step?: number;
+    };
+}
+interface HiddenField {
+    type: 'hidden';
+}
+interface PreviewField extends BaseField {
+    type: 'preview';
+}
+interface PreviewImageField extends BaseField {
+    type: 'preview:image';
+}
+type FormField<V = any> = TextField | PasswordField | TextareaField | DateInputField | DateRangeInputField | SelectField<V> | TimeRangeField | MultiSelectField<V> | FileField | ActionField | HiddenField | NumberField | PreviewField | AgreementField | SliderField | PreviewImageField;
+interface FormFieldMap {
+    [key: string]: FormField<any> | FormFieldMap;
+}
+/** @deprecated */
+declare const FORM_FIELD_MAP: InjectionToken<FormFieldMap>;
+/** @deprecated use fieldMap input*/
+declare function provideFormFieldMap(useFactory: () => FormFieldMap): {
+    provide: InjectionToken<FormFieldMap>;
+    useFactory: () => FormFieldMap;
+};
+type Enum<T> = Record<string, T>;
+declare function buildOptions<T>(_enum: Enum<T> | any[]): Option<T>[];
+declare function buildEnumOptions<T>(_enum: Enum<T>): Option<T>[];
+/** @deprecated */
+declare class SmartFieldPipe implements PipeTransform {
+    protected map: FormFieldMap;
+    transform(key: string, map?: FormFieldMap): FormField<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFieldPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SmartFieldPipe, "smartField", true>;
+}
+declare function resolveFormField(fieldMap: FormFieldMap, name: string): FormFieldMap | FormField<any>;
+
+export { FORM_FIELD_MAP, SmartFieldPipe, buildEnumOptions, buildOptions, provideFormFieldMap, resolveFormField };
+export type { FormField, FormFieldMap, Option };

package/pipes/sort/index.d.ts

@@ -1 +1,11 @@
-export * from './sort.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { Column, Sort } from '@ng-atomic/common/models';
+
+declare class SortPipe implements PipeTransform {
+    transform<T>(column: Column, sort: Sort): 'asc' | 'desc' | 'none';
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortPipe, "sort", true>;
+}
+
+export { SortPipe };

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

@@ -1 +1,20 @@
-export * from './sort-by.pipe';
+import * as i0 from '@angular/core';
+import { InjectionToken, PipeTransform } from '@angular/core';
+import { Sort } from '@ng-atomic/common/models';
+import { DataAccessor } from '@ng-atomic/common/pipes/data-accessor';
+
+declare function sortByTransformer<T>(items: T[], { key, order }?: Partial<Sort>, dataAccessor?: DataAccessor<T>): T[];
+declare function sortByTransformerFactory<T>(dataAccessor: DataAccessor<T>): (items: any, params: any) => T[];
+declare const SMART_SORT_BY_TRANSFORMER: InjectionToken<typeof sortByTransformer>;
+declare function injectSortByTransformer<T>(): typeof sortByTransformer<T>;
+declare class SortByPipe<T> implements PipeTransform {
+    protected transformer: (items: T[], { key, order }?: Partial<Sort>, dataAccessor?: DataAccessor<T>) => T[];
+    transform(items: T[], params?: {
+        key?: string;
+        order?: 'asc' | 'desc';
+    }): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortByPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortByPipe<any>, "sortBy", true>;
+}
+
+export { SMART_SORT_BY_TRANSFORMER, SortByPipe, injectSortByTransformer, sortByTransformer, sortByTransformerFactory };

package/pipes/style/index.d.ts

@@ -1 +1,22 @@
-export * from './style.pipe';
+import * as i0 from '@angular/core';
+import { InjectionToken, PipeTransform } from '@angular/core';
+
+declare function isNumeric(value: any): value is number;
+type StyleMap = Record<string, any>;
+type StyleTransformer = (value: any, context?: any) => StyleMap;
+declare const defaultStyleTransformer: StyleTransformer;
+declare const STYLE_TRANSFORMER: InjectionToken<StyleTransformer>;
+declare function provideStyleTransformer(useFactory: () => StyleTransformer): {
+    provide: InjectionToken<StyleTransformer>;
+    useFactory: () => StyleTransformer;
+};
+declare function injectParentStyleTransformer(): StyleTransformer;
+declare class StylePipe implements PipeTransform {
+    protected transformer: StyleTransformer;
+    transform(value: any, context?: any): StyleMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StylePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StylePipe, "style", true>;
+}
+
+export { STYLE_TRANSFORMER, StylePipe, defaultStyleTransformer, injectParentStyleTransformer, isNumeric, provideStyleTransformer };
+export type { StyleMap, StyleTransformer };

package/pipes/yen/index.d.ts

@@ -1 +1,10 @@
-export * from './yen.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class YenPipe implements PipeTransform {
+    transform(value?: number | null, _unit?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<YenPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<YenPipe, "yen", true>;
+}
+
+export { YenPipe };

package/services/app/index.d.ts

@@ -1 +1,37 @@
-export * from './app.service';
+import { Router } from '@angular/router';
+import { LoadingService } from '@ng-atomic/common/services/loading';
+import { SideAppService } from '@ng-atomic/common/services/side-app';
+import { SideNavModeService } from '@ng-atomic/common/services/side-nav-mode';
+import { FabService } from '@ng-atomic/common/services/fab';
+import { SnackBarService } from '@ng-atomic/common/services/snack-bar';
+import { Clipboard } from '@angular/cdk/clipboard';
+import { MatDialog } from '@angular/material/dialog';
+import { SheetService } from '@ng-atomic/common/services/sheets';
+import * as i0 from '@angular/core';
+
+declare class HistoryInjectorService {
+    private router;
+    private isInitialNavigation;
+    constructor(router: Router);
+    private injectParentRoutes;
+    private getFilteredSegments;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoryInjectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HistoryInjectorService>;
+}
+declare class AppService {
+    readonly dialog: MatDialog;
+    readonly loading: LoadingService;
+    readonly sheet: SheetService;
+    readonly sideApp: SideAppService;
+    readonly sideNavMode: SideNavModeService;
+    readonly sideNav: SideNavModeService;
+    readonly router: Router;
+    readonly fab: FabService;
+    readonly snackBar: SnackBarService;
+    readonly clipboard: Clipboard;
+    readonly navigationInterceptor: HistoryInjectorService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}
+
+export { AppService, HistoryInjectorService };

package/services/auth/index.d.ts

@@ -1 +1,56 @@
-export * from './auth.service';
+import * as _firebase_auth from '@firebase/auth';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { UserCredential } from '@angular/fire/auth';
+import { Observable } from 'rxjs';
+
+interface TwitterCredential {
+    context: string;
+    displayName: string;
+    email: string;
+    emailVerified: boolean;
+    expiresIn: string;
+    federatedId: string;
+    fullName: string;
+    idToken: string;
+    kind: 'identitytoolkit#VerifyAssertionResponse';
+    localId: string;
+    oauthAccessToken: string;
+    oauthTokenSecret: string;
+    photoUrl: string;
+    providerId: 'twitter.com';
+    rawUserInfo: string;
+    refreshToken: string;
+    screenName: string;
+}
+type Result = UserCredential & {
+    _tokenResponse: TwitterCredential;
+};
+declare class AuthService {
+    #private;
+    readonly auth$: Observable<_firebase_auth.User>;
+    readonly auth: Signal<_firebase_auth.User>;
+    readonly accessToken$: Observable<string>;
+    readonly accessToken: Signal<string>;
+    userId$: Observable<string>;
+    readonly customClaims$: Observable<_firebase_auth.ParsedToken>;
+    signInWithTwitter(): Promise<Result>;
+    signInWithGoogle(scopes?: string[]): Promise<UserCredential>;
+    signInWithEmailAndPassword(email: string, password: string): Promise<UserCredential>;
+    createUserWithEmailAndPassword(email: string, password: string): Promise<UserCredential>;
+    signInWithCustomToken(customToken: string): Promise<Result>;
+    signOut(): Promise<void>;
+    private onFailedForAccountExistsWithDifferentCredential;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+declare function injectAuthState$(): Observable<_firebase_auth.User>;
+declare function injectAuthState(): Signal<_firebase_auth.User>;
+declare function injectUserId$(): Observable<string | null>;
+declare function injectUserId(): Signal<string | null>;
+declare function injectTwitterId$(): Observable<string>;
+declare function injectClaim$<T = string>(claim: string): Observable<T>;
+declare function injectClaim<T = string>(claim: string): Signal<T>;
+
+export { AuthService, injectAuthState, injectAuthState$, injectClaim, injectClaim$, injectTwitterId$, injectUserId, injectUserId$ };
+export type { Result, TwitterCredential };

package/services/breakpoint/index.d.ts

@@ -1 +1,35 @@
-export * from './breakpoint.service';
+import * as _angular_core from '@angular/core';
+import * as rxjs from 'rxjs';
+import * as _angular_cdk_layout from '@angular/cdk/layout';
+import { BreakpointObserver } from '@angular/cdk/layout';
+
+type Breakpoint = 'xSmall' | 'small' | 'medium' | 'large' | 'xLarge' | 'handset' | 'tablet' | 'web';
+declare class BreakpointService {
+    protected readonly breakpointObserver: BreakpointObserver;
+    readonly breakpointMap$: rxjs.Observable<{
+        xSmall: _angular_cdk_layout.BreakpointState;
+        small: _angular_cdk_layout.BreakpointState;
+        medium: _angular_cdk_layout.BreakpointState;
+        large: _angular_cdk_layout.BreakpointState;
+        xLarge: _angular_cdk_layout.BreakpointState;
+        handset: _angular_cdk_layout.BreakpointState;
+        tablet: _angular_cdk_layout.BreakpointState;
+        web: _angular_cdk_layout.BreakpointState;
+    }>;
+    readonly breakpointMap: _angular_core.Signal<{
+        xSmall: _angular_cdk_layout.BreakpointState;
+        small: _angular_cdk_layout.BreakpointState;
+        medium: _angular_cdk_layout.BreakpointState;
+        large: _angular_cdk_layout.BreakpointState;
+        xLarge: _angular_cdk_layout.BreakpointState;
+        handset: _angular_cdk_layout.BreakpointState;
+        tablet: _angular_cdk_layout.BreakpointState;
+        web: _angular_cdk_layout.BreakpointState;
+    }>;
+    readonly breakpoint: _angular_core.Signal<Breakpoint>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreakpointService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BreakpointService>;
+}
+
+export { BreakpointService };
+export type { Breakpoint };

package/services/chips-manager/index.d.ts

@@ -1 +1,14 @@
-export * from './chips.manager';
+import * as i0 from '@angular/core';
+
+declare class ChipsManager {
+    private _chips;
+    setValue(value: string): void;
+    getValue(): string;
+    remove(value: string): void;
+    add(chip: string): void;
+    get chips(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChipsManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChipsManager>;
+}
+
+export { ChipsManager };

package/services/csv/index.d.ts

@@ -1 +1,9 @@
-export * from './csv.service';
+import * as i0 from '@angular/core';
+
+declare class CsvService {
+    downloadArrayAsCsv(array: Record<string, string>[], fileName?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CsvService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CsvService>;
+}
+
+export { CsvService };

package/services/editing/index.d.ts

@@ -0,0 +1,30 @@
+import * as rxjs from 'rxjs';
+import * as i0 from '@angular/core';
+
+/**
+ * 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>;
+}
+
+export { EditingStateManager };

package/services/fab/index.d.ts

@@ -1 +1,22 @@
-export * from './fab.service';
+import * as _angular_router from '@angular/router';
+import { Router, ActivatedRoute } from '@angular/router';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare class FabService {
+    readonly hidden: i0.WritableSignal<boolean>;
+    protected readonly router: Router;
+    protected readonly route: ActivatedRoute;
+    readonly route$: Observable<ActivatedRoute>;
+    readonly data: Signal<_angular_router.Data>;
+    readonly actions: Signal<any>;
+    private findLastChild;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FabService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FabService>;
+}
+
+export { FabService };

package/services/form/_index/index.d.ts

@@ -1 +1,61 @@
-export * from './index.service';
+import * as _angular_forms from '@angular/forms';
+import { FormBuilder } from '@angular/forms';
+import { PaginationService, PaginationFormValue } from '@ng-atomic/common/services/form/pagination';
+import { SortService, SortFormValue } from '@ng-atomic/common/services/form/sort';
+import { ColumnsFormBuilder, ColumnsFormValue } from '@ng-atomic/common/services/form/columns';
+export { buildColumns } from '@ng-atomic/common/services/form/columns';
+import * as i0 from '@angular/core';
+
+declare class IndexFormBuilder {
+    readonly columns: ColumnsFormBuilder;
+    readonly sort: SortService;
+    readonly pagination: PaginationService;
+    readonly fb: FormBuilder;
+    build({ query, sort, page, columns }?: {
+        query?: string;
+        page?: Partial<PaginationFormValue>;
+        sort?: Partial<SortFormValue>;
+        columns?: ColumnsFormValue;
+    }): _angular_forms.FormGroup<{
+        query: _angular_forms.FormControl<string>;
+        page: _angular_forms.FormGroup<{
+            size: _angular_forms.FormControl<number>;
+            index: _angular_forms.FormControl<number>;
+            length: _angular_forms.FormControl<number>;
+        }>;
+        sort: _angular_forms.FormGroup<{
+            key: _angular_forms.FormControl<string>;
+            order: _angular_forms.FormControl<"asc" | "desc">;
+        }>;
+        columns: _angular_forms.FormGroup<{
+            ids: _angular_forms.FormControl<string[]>;
+            map: _angular_forms.FormGroup<{}>;
+        }>;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexFormBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IndexFormBuilder>;
+}
+declare function injectIndexFormBuilder(): IndexFormBuilder;
+declare function injectIndexForm({ columns, sort, query, page }?: {
+    columns?: ColumnsFormValue;
+    sort?: Partial<SortFormValue>;
+    query?: string;
+    page?: Partial<PaginationFormValue>;
+}): _angular_forms.FormGroup<{
+    query: _angular_forms.FormControl<string>;
+    page: _angular_forms.FormGroup<{
+        size: _angular_forms.FormControl<number>;
+        index: _angular_forms.FormControl<number>;
+        length: _angular_forms.FormControl<number>;
+    }>;
+    sort: _angular_forms.FormGroup<{
+        key: _angular_forms.FormControl<string>;
+        order: _angular_forms.FormControl<"asc" | "desc">;
+    }>;
+    columns: _angular_forms.FormGroup<{
+        ids: _angular_forms.FormControl<string[]>;
+        map: _angular_forms.FormGroup<{}>;
+    }>;
+}>;
+
+export { IndexFormBuilder, IndexFormBuilder as IndexTemplateFormBuilder, injectIndexForm, injectIndexFormBuilder, injectIndexForm as injectIndexTemplateForm, injectIndexFormBuilder as injectIndexTemplateFormBuilder };

package/services/form/columns/index.d.ts

@@ -1 +1,68 @@
-export * from './columns.service';
+import * as _angular_forms from '@angular/forms';
+import { FormGroup, FormControl, FormArray, FormRecord } from '@angular/forms';
+import { Actions } from '@ng-atomic/core';
+import { Column } from '@ng-atomic/common/models';
+import * as i0 from '@angular/core';
+
+type ActionsColumnForm = FormGroup<{
+    type: FormControl<'actions'>;
+    visible: FormControl<boolean>;
+    width: FormControl<number>;
+    actions: FormControl<any>;
+    sticky: FormControl<boolean>;
+    stickyEnd: FormControl<boolean>;
+}>;
+type CheckboxColumnForm = FormGroup<{
+    type: FormControl<'checkbox'>;
+    visible: FormControl<boolean>;
+    width: FormControl<number>;
+    sticky: FormControl<boolean>;
+    stickyEnd: FormControl<boolean>;
+}>;
+type TextColumnForm = FormGroup<{
+    type: FormControl<'text'>;
+    visible: FormControl<boolean>;
+    width: FormControl<number>;
+    sticky: FormControl<boolean>;
+    stickyEnd: FormControl<boolean>;
+}>;
+type TreeColumnForm = FormGroup<{
+    type: FormControl<'tree'>;
+    visible: FormControl<boolean>;
+    width: FormControl<number>;
+    sticky: FormControl<boolean>;
+    stickyEnd: FormControl<boolean>;
+}>;
+type ColumnsForm = FormArray<FormRecord<ActionsColumnForm | CheckboxColumnForm | TextColumnForm | TreeColumnForm>>;
+interface ColumnsFormValue {
+    ids: string[];
+    map: {
+        [key: string]: Column;
+    };
+}
+declare class ColumnsFormBuilder {
+    protected readonly fb: _angular_forms.NonNullableFormBuilder;
+    build(columns?: ColumnsFormValue): FormGroup<{
+        ids: FormControl<string[]>;
+        map: FormGroup<{}>;
+    }>;
+    protected buildColumnForm(column: Column): ActionsColumnForm | CheckboxColumnForm | TextColumnForm | TreeColumnForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsFormBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnsFormBuilder>;
+}
+declare function injectColumnsForm(): FormGroup<{
+    ids: FormControl<string[]>;
+    map: FormGroup<{}>;
+}>;
+declare function buildColumns(columnIdOrActions: (string | Actions)[], { stickyStart, stickyEnd, }?: {
+    stickyStart?: number;
+    stickyEnd?: number;
+}): {
+    ids: string[];
+    map: {
+        [key: string]: Column;
+    };
+};
+
+export { ColumnsFormBuilder, buildColumns, injectColumnsForm };
+export type { ActionsColumnForm, CheckboxColumnForm, ColumnsForm, ColumnsFormValue, TextColumnForm, TreeColumnForm };

package/services/form/index.d.ts

@@ -1 +1,34 @@
-export * from './form.service';
+import { Signal } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { FormField, FormFieldMap } from '@ng-atomic/common/pipes/smart-field';
+
+declare class BaseFormService {
+    static fromQueryParams<T>(obj: T): object;
+    static toQueryParams<T>(obj: object): T;
+    static dayjsKeys(object: object): string[];
+    static toValue(object: object): object;
+    static fromValue(value: object): object;
+}
+
+declare function getFormSignal<T>(form: Signal<AbstractControl<T>>, path?: string[]): {
+    control: Signal<AbstractControl<T>>;
+    value: Signal<T>;
+};
+type SetupFormControl<T, K extends (FormField | FormFieldMap)> = (form: Signal<AbstractControl>, path?: string[]) => {
+    control: Signal<AbstractControl<T>>;
+    value: Signal<T>;
+    field: Signal<K>;
+};
+declare function createSetupFormControl<T, K extends (FormField | FormFieldMap)>(setupFn: (prams: {
+    control: Signal<AbstractControl<T>>;
+    value: Signal<T>;
+}) => Signal<K>): SetupFormControl<T, K>;
+/**
+ * 指定されたフィールドをdisableにする
+ * @param control フォームコントロールのSignal
+ * @param fields disableにするフィールドのパス配列
+ */
+declare function disableControls(control: AbstractControl, fields: string[]): void;
+
+export { BaseFormService, createSetupFormControl, disableControls, getFormSignal };
+export type { SetupFormControl };