@cccteam/ccc-lib 0.0.15 → 0.0.16

package/types/cccteam-ccc-lib.d.ts

@@ -0,0 +1,1877 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, Signal, InjectionToken, EventEmitter, ModelSignal, Injector, ResourceRef, Type, DestroyRef, ViewContainerRef, WritableSignal, PipeTransform, TemplateRef, OnDestroy } from '@angular/core';
+import { HttpClient, HttpContextToken, HttpContext, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as _cccteam_ccc_lib_src_types from '@cccteam/ccc-lib/src/types';
+import { SessionInfo as SessionInfo$1, PermissionScope as PermissionScope$1, Resource as Resource$1, Permission as Permission$1, CreateNotificationMessage as CreateNotificationMessage$1, Domain as Domain$1, NotificationMessage as NotificationMessage$1, ResourceMeta as ResourceMeta$1, RecordData as RecordData$1, MenuItem as MenuItem$1, DataType as DataType$1, ViewConfig as ViewConfig$1, RootConfig as RootConfig$1, ConfigElement as ConfigElement$1, RPCRecordData as RPCRecordData$1, MethodMeta as MethodMeta$1, FieldSort as FieldSort$1, ColumnConfig as ColumnConfig$1, RPCConfig as RPCConfig$1, FieldElement as FieldElement$1, Method as Method$1, RPCBaseFormData as RPCBaseFormData$1, ParentResourceConfig as ParentResourceConfig$1, ChildResourceConfig as ChildResourceConfig$1, FormatType as FormatType$1, PaddingElement as PaddingElement$1, ArrayConfig as ArrayConfig$1, ListViewConfig as ListViewConfig$1, Meta as Meta$1, FieldMeta as FieldMeta$1, RPCFieldMeta as RPCFieldMeta$1, ValidDisplayTypes as ValidDisplayTypes$1, ComponentConfig as ComponentConfig$1, ActionButtonConfig as ActionButtonConfig$1 } from '@cccteam/ccc-lib/src/types';
+import { Observable } from 'rxjs';
+import { NotificationService as NotificationService$1 } from '@cccteam/ccc-lib/src/ui-notification-service';
+import { AuthService as AuthService$1 } from '@cccteam/ccc-lib/src/auth-service';
+import { ActivatedRouteSnapshot, RouterStateSnapshot, Route, Router, ActivatedRoute, UrlTree, CanDeactivateFn } from '@angular/router';
+import { TooltipPosition } from '@angular/material/tooltip';
+import { ValidatorFn, AbstractControl, ValidationErrors, FormGroup } from '@angular/forms';
+import { UiCoreService as UiCoreService$1 } from '@cccteam/ccc-lib/src/ui-core-service';
+import { MatDialog } from '@angular/material/dialog';
+import { Location } from '@angular/common';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { CamelCaseToTitlePipe as CamelCaseToTitlePipe$1 } from '@cccteam/ccc-lib/src/ccc-camel-case-to-title';
+import { SelectableSettings } from '@progress/kendo-angular-grid';
+
+declare class AuthService {
+    private apiUrl;
+    private loginUrl;
+    private sessionUrl;
+    http: HttpClient;
+    private authenticatedSignal;
+    private sessionInfoSignal;
+    redirectUrl: _angular_core.WritableSignal<string>;
+    authenticated: _angular_core.Signal<boolean>;
+    sessionInfo: _angular_core.Signal<SessionInfo$1>;
+    constructor();
+    private static permissionFn;
+    hasPermission(scope?: PermissionScope$1): boolean;
+    static requiresPermission(resource: Resource$1, permission: Permission$1): boolean;
+    private initializePermissionFn;
+    /**
+     * Logs a user out.
+     *
+     * @returns Observable with a boolean indicating whether they were logged out.
+     */
+    logout(): Observable<boolean>;
+    /**
+     * Checks a user's session with the server.
+     *
+     * @returns Observable with the user session info
+     */
+    checkUserSession(): Observable<SessionInfo$1>;
+    loginRoute(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthService>;
+}
+
+declare class UiCoreService {
+    notifications: NotificationService$1;
+    loadingSignal: _angular_core.WritableSignal<string[]>;
+    sidenavOpened: _angular_core.WritableSignal<boolean>;
+    currentSidenavIdentifier: _angular_core.WritableSignal<string>;
+    private loading;
+    isLoading: _angular_core.Signal<boolean>;
+    publishError(message: CreateNotificationMessage$1): void;
+    beginActivity(process: string): void;
+    endActivity(process: string): void;
+    toggleSidenav(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiCoreService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UiCoreService>;
+}
+
+declare class HasPermissionDirective {
+    private auth;
+    private templateRef;
+    private viewContainer;
+    private scope;
+    set cccHasPermission(scope: PermissionScope$1);
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HasPermissionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HasPermissionDirective, "[cccHasPermission]", never, { "cccHasPermission": { "alias": "cccHasPermission"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare enum InputMode {
+    Read = "read",
+    Edit = "edit"
+}
+declare class CccInputFieldComponent implements OnInit {
+    auth: AuthService$1;
+    className: _angular_core.InputSignal<unknown>;
+    mode: _angular_core.InputSignal<InputMode>;
+    resource: _angular_core.InputSignal<Resource$1>;
+    domain: _angular_core.InputSignal<Domain$1>;
+    value: _angular_core.InputSignal<unknown>;
+    name: _angular_core.InputSignal<string>;
+    inputMode: typeof InputMode;
+    canEdit: Signal<boolean>;
+    canEditSelector: boolean;
+    canRead: Signal<boolean>;
+    canReadSelector: boolean;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CccInputFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CccInputFieldComponent, "ccc-input-field", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "resource": { "alias": "resource"; "required": true; "isSignal": true; }; "domain": { "alias": "domain"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const AuthenticationGuard: (route: ActivatedRouteSnapshot, routerState: RouterStateSnapshot) => Observable<boolean>;
+
+declare const AuthorizationGuard: (route: ActivatedRouteSnapshot) => Signal<boolean>;
+
+interface CustomHttpRequestOptions {
+    suppressGlobalError: boolean;
+}
+declare const CUSTOM_HTTP_REQUEST_OPTIONS: HttpContextToken<CustomHttpRequestOptions>;
+declare function errorOptions(suppressGlobalError: boolean | undefined): {
+    context: HttpContext;
+};
+
+type Brand<K, T> = K & {
+    __brand: T;
+};
+type Permission = Brand<string, 'Permission'>;
+type Resource = Brand<string, 'Resource'>;
+type Domain = Brand<string, 'Domain'>;
+type FieldName = Brand<string, 'FieldName'>;
+type Method = Brand<string, 'Method'>;
+type DomainPermissions = Record<Domain, Record<Resource, Record<Permission, Permissions>>>;
+interface PermissionScope {
+    resource: Resource;
+    permission: Permission;
+    domain: Domain;
+}
+declare const ReadPermission: Permission;
+declare const UpdatePermission: Permission;
+
+declare const defaultEmptyFieldValue = "-";
+type NullBoolean = null | true | false;
+type ConcatFn = 'space-concat' | 'hyphen-concat' | 'space-hyphen-concat' | 'hyphen-space-concat';
+
+declare const validatorsPresent: (control: AbstractControl<unknown, unknown>, validators: ValidatorFn[], previousValidatorCount: number) => boolean;
+declare const requiredIf: (predicate: () => boolean, validator: ValidatorFn) => (formControl: AbstractControl) => ValidationErrors | null;
+declare const __singletonValidatorBrand: unique symbol;
+type ResourceValidatorFn = ValidatorFn & {
+    readonly [__singletonValidatorBrand]: true;
+};
+declare function createResourceValidator(validator: ValidatorFn): ResourceValidatorFn;
+
+interface FieldPointer {
+    field: FieldName;
+}
+interface MenuItem {
+    label: string;
+    route?: string[];
+    children?: MenuItem[];
+}
+interface RouteResourceData {
+    config: RootConfig;
+}
+type DataType = string | number | number[] | string[] | boolean | undefined | Date;
+type RecordData = Record<string, DataType | null>;
+type RPCDataType = string | number | string[] | number[] | boolean | Date;
+type RPCRecordData = Record<string, RPCDataType>;
+type RpcMethod = Record<string, DataType>;
+type ParentResourceConfig = ListViewConfig | ViewConfig | ArrayConfig;
+type ChildResourceConfig = ListViewConfig | ViewConfig | ComponentConfig | ArrayConfig;
+type ActionType = 'function' | 'link';
+type ListConcatFn = 'space-concat' | 'hyphen-concat' | 'space-hyphen-concat' | 'hyphen-space-concat' | 'no-space-concat';
+type ConfigType = ChildResourceConfig;
+type FormatType = 'simpleSlashDateFormat';
+type RPCPlacement = 'inline' | 'end';
+type ColumnConfig = SingleColumnConfig | MultiColumnConfig;
+interface ActionButtonConfig {
+    label: string;
+    icon: string;
+    action?: (resource: {
+        id: string;
+    }) => void;
+    viewRoute?: string;
+    actionType?: ActionType;
+    color?: string;
+    disabledLabel?: string;
+}
+interface ActionButtonConfigOptions {
+    label: string;
+    icon: string;
+    action?: (resource: {
+        id: string;
+    }) => void;
+    viewRoute?: string;
+    actionType?: ActionType;
+    color?: string;
+    disabledLabel?: string;
+}
+declare function actionButtonConfig(config: ActionButtonConfigOptions): ActionButtonConfig;
+declare const actionButtonConfigDefaults: {
+    label: string;
+    icon: string;
+    actionType: ActionType;
+    color: string;
+    disabledLabel: string;
+};
+interface SingleColumnConfig {
+    id: FieldName;
+    header?: string;
+    width?: number;
+    resizable?: boolean;
+    valueGetter?: (data: any) => string;
+    valueFormatter?: (data: any) => string;
+    tooltipPosition?: TooltipPosition;
+    viewRoute?: Resource;
+    buttonConfig?: ActionButtonConfig;
+    actionType?: ActionType;
+    formatType?: FormatType | string;
+    hidden?: boolean;
+    emptyDataValue?: DataType;
+    filterable?: boolean;
+    hideHeader?: boolean;
+}
+interface SingleColumnConfigOptions {
+    id: FieldName;
+    header?: string;
+    width?: number;
+    resizable?: boolean;
+    valueGetter?: (data: any) => string;
+    valueFormatter?: (data: any) => string;
+    tooltipPosition?: TooltipPosition;
+    viewRoute?: Resource;
+    buttonConfig?: ActionButtonConfig;
+    actionType?: ActionType;
+    formatType?: FormatType | string;
+    hidden?: boolean;
+    emptyDataValue?: DataType;
+    filterable?: boolean;
+    hideHeader?: boolean;
+}
+declare function singleColumnConfig(config: SingleColumnConfigOptions): SingleColumnConfig;
+declare const singleColumnConfigDefaults: {
+    id: FieldName;
+    header: string;
+    resizable: true;
+    actionType: ActionType;
+    hidden: false;
+    filterable: true;
+    hideHeader: false;
+};
+interface MultiColumnConfig extends SingleColumnConfig {
+    additionalIds: AdditionalResourceConfig[];
+    concatFn: ListConcatFn;
+}
+interface MultiColumnConfigOptions extends SingleColumnConfigOptions {
+    additionalIds: AdditionalResourceConfig[];
+    concatFn: ListConcatFn;
+}
+declare function multiColumnConfig(config: MultiColumnConfigOptions): MultiColumnConfig;
+declare const multiColumnConfigDefaults: {
+    additionalIds: AdditionalResourceConfig[];
+    concatFn: ListConcatFn;
+    id: FieldName;
+    header: string;
+    resizable: true;
+    actionType: ActionType;
+    hidden: false;
+    filterable: true;
+    hideHeader: false;
+};
+interface AdditionalResourceConfig {
+    resource?: Resource;
+    id: FieldName;
+    field?: FieldName;
+    hidden?: boolean;
+}
+interface AdditionalResourceConfigOptions {
+    id: FieldName;
+    resource?: Resource;
+    field?: FieldName;
+    hidden?: boolean;
+}
+declare function additionalResourceConfig(config: AdditionalResourceConfigOptions): AdditionalResourceConfig;
+declare const additionalResourceConfigDefaults: {
+    id: FieldName;
+    resource: Resource;
+    field: FieldName;
+    hidden: false;
+};
+interface FieldSort {
+    field: FieldName;
+    direction: 'asc' | 'desc';
+}
+interface FieldSortOptions {
+    field: FieldName;
+    direction?: 'asc' | 'desc';
+}
+declare function fieldSort(config: FieldSortOptions): FieldSort;
+declare const fieldSortDefaults: {
+    field: FieldName;
+    direction: "asc" | "desc";
+};
+interface EnumeratedConfigOptions {
+    overrideResource?: Resource;
+    filter?: (resource: any) => string;
+    /**
+     * Set disableCacheForFilterPii to `true` to promote the GET to a POST when PII is used in the filter
+     * POST requests cannot be cached
+     */
+    disableCacheForFilterPii?: boolean;
+    /**
+     * Specifies which resource data to pass to the filter function:
+     * - 'rootResource': Pass in the root resource data
+     * - 'parentResource': Pass in the parent resource data
+     * @default 'parentResource'
+     */
+    filterType?: FilterType;
+    sorts?: FieldSort[];
+    listDisplay?: FieldName[];
+    viewDisplay: FieldName[];
+    viewConcatFn?: ConcatFn;
+    listConcatFn?: ConcatFn;
+    viewDetails?: boolean;
+    searchable?: boolean;
+}
+type FilterType = 'parentResource' | 'rootResource';
+interface EnumeratedConfig {
+    overrideResource: Resource;
+    filter: (resource: any) => string;
+    disableCacheForFilterPii: boolean;
+    filterType: FilterType;
+    sorts: FieldSort[];
+    listDisplay: FieldName[];
+    viewDisplay: FieldName[];
+    viewConcatFn: ConcatFn;
+    listConcatFn: ConcatFn;
+    viewDetails: boolean;
+    searchable: boolean;
+}
+declare function enumeratedConfig(config: EnumeratedConfigOptions): EnumeratedConfig;
+declare const enumeratedConfigDefaults: {
+    overrideResource: Resource;
+    filter: () => string;
+    disableCacheForFilterPii: boolean;
+    filterType: FilterType;
+    sorts: FieldSort[];
+    listDisplay: FieldName[];
+    viewDisplay: FieldName[];
+    viewConcatFn: ConcatFn;
+    listConcatFn: ConcatFn;
+    viewDetails: boolean;
+    searchable: boolean;
+};
+type FieldDefault = ForeignKeyDefault | StaticDefault | null;
+interface NullBooleanConfigOptions {
+    displayValues?: Record<'null' | 'true' | 'false', {
+        label: string;
+        value: NullBoolean;
+    }>;
+}
+interface NullBooleanConfig {
+    /** This property maps the three possible values for this
+     * nullboolean field with the display values users will see
+     * on the screen for each
+     */
+    displayValues: Record<'null' | 'true' | 'false', {
+        label: string;
+        value: NullBoolean;
+    }>;
+}
+declare function nullBooleanConfig(config: NullBooleanConfigOptions): NullBooleanConfig;
+declare const nullBooleanConfigDefaults: {
+    displayValues: Readonly<{
+        null: {
+            label: string;
+            value: null;
+        };
+        true: {
+            label: string;
+            value: boolean;
+        };
+        false: {
+            label: string;
+            value: boolean;
+        };
+    }>;
+};
+interface ForeignKeyDefaultOptions {
+    parentId: FieldName;
+}
+interface ForeignKeyDefault {
+    type: 'foreignKey';
+    parentId: FieldName;
+}
+declare function foreignKeyDefault(config: ForeignKeyDefaultOptions): ForeignKeyDefault;
+declare const foreignKeyDefaultDefaults: {
+    type: "foreignKey";
+    parentId: FieldName;
+};
+interface StaticDefault {
+    type: 'static';
+    value: string | boolean;
+}
+interface staticDefaultOptions {
+    value: string | boolean;
+}
+declare function staticDefault(config: staticDefaultOptions): StaticDefault;
+declare const staticDefaultDefaults: {
+    type: "static";
+    value: string;
+};
+type Affix = string | remoteData | parentData;
+interface remoteData {
+    resource: Resource;
+    id: FieldName;
+    field: FieldName;
+}
+interface parentData {
+    field: FieldName;
+}
+type ConfigElement = FieldElement | SectionElement | ComputedDisplayFieldElement | PaddingElement;
+type ColSize = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+interface ComputedDisplayFieldElementOptions {
+    label?: string;
+    class?: string;
+    cols?: ColSize;
+    calculatedValue?: (data: any) => string;
+    shouldRender?: ((data: any) => boolean) | boolean;
+}
+interface ComputedDisplayFieldElement {
+    type: 'computedDisplayField';
+    label: string;
+    class: string;
+    cols: ColSize;
+    calculatedValue: (data: any) => string;
+    shouldRender: ((data: any) => boolean) | boolean;
+}
+declare function computedDisplayField(config: ComputedDisplayFieldElementOptions): ComputedDisplayFieldElement;
+declare const computedDisplayFieldElementDefaults: {
+    type: "computedDisplayField";
+    label: string;
+    class: string;
+    cols: 6;
+    calculatedValue: () => string;
+    shouldRender: true;
+};
+interface PaddingElementOptions {
+    cols?: ColSize;
+    shouldRender?: ((data: any) => boolean) | boolean;
+}
+interface PaddingElement {
+    type: 'padding';
+    cols: ColSize;
+    /** Determines whether the padding is shown
+     */
+    shouldRender: ((data: any) => boolean) | boolean;
+}
+declare function padding(config?: PaddingElementOptions): PaddingElement;
+declare const paddingElementDefaults: {
+    type: "padding";
+    cols: 12;
+    shouldRender: true;
+};
+interface SectionElementOptions {
+    label?: string;
+    class?: string;
+    cols?: ColSize;
+    shouldRender?: ((data: any) => boolean) | boolean;
+    nullAllChildrenIfConditionallyHidden?: boolean;
+    children?: ConfigElement[];
+}
+interface SectionElement {
+    type: 'section';
+    label: string;
+    class: string;
+    cols: ColSize;
+    /**
+     * shouldRender is used to determine if the section should be
+     * displayed to users.
+     * When assigning shouldRender a function, the first argument
+     * is the current state of the resource being displayed
+     * Hides the layout AND all of its children
+     */
+    shouldRender: ((data: any) => boolean) | boolean;
+    /** If shouldRender is NOT a function, this property does nothing
+     * If shouldRender is a function, this property
+     * sets children's values to null if shouldRender hides it (returns false)
+     * within the resource-layout.component
+     */
+    nullAllChildrenIfConditionallyHidden: boolean;
+    children: ConfigElement[];
+}
+declare function section(config: SectionElementOptions): SectionElement;
+declare const sectionElementDefaults: {
+    type: "section";
+    label: string;
+    class: string;
+    cols: 12;
+    shouldRender: true;
+    nullAllChildrenIfConditionallyHidden: false;
+    children: never[];
+};
+interface FieldElementOptions {
+    name: FieldName;
+    label?: string;
+    cols?: ColSize;
+    class?: string;
+    enumeratedConfig?: EnumeratedConfig;
+    default?: FieldDefault;
+    nullBooleanConfig?: NullBooleanConfig;
+    validators?: ((data: any) => ResourceValidatorFn[]) | ResourceValidatorFn[];
+    readOnly?: boolean;
+    prefixes?: Affix[];
+    suffixes?: Affix[];
+    shouldRender?: ((data: any) => boolean) | boolean;
+    nullIfConditionallyHidden?: boolean;
+}
+interface FieldElement {
+    type: 'field';
+    name: string;
+    label: string;
+    cols: ColSize;
+    class: string;
+    enumeratedConfig: EnumeratedConfig;
+    default: FieldDefault;
+    nullBooleanConfig: NullBooleanConfig;
+    /**
+     * A list of validators that must pass to allow a field to be submitted.
+     * Utilize existing validators in the resourceValidators object, and
+     * add any new or custom validators to it
+     */
+    validators: ((data: any) => ResourceValidatorFn[]) | ResourceValidatorFn[];
+    readOnly: boolean;
+    prefixes: Affix[];
+    suffixes: Affix[];
+    /**
+     * shouldRender is used to determine if the element should be
+     * displayed to users.
+     * When assigning shouldRender a function, the first argument
+     * is the current state of the resource being displayed
+     */
+    shouldRender: ((data: any) => boolean) | boolean;
+    /** If shouldRender is NOT a function, this property does nothing
+     * If shouldRender is a function, this property
+     * determines whether the form control associated
+     * with this config element should have its value
+     * set to null if shouldRender hides it (returns false)
+     */
+    nullIfConditionallyHidden: boolean;
+}
+declare function field(config: FieldElementOptions): FieldElement;
+declare const fieldElementDefaults: {
+    type: "field";
+    name: string;
+    label: string;
+    cols: 6;
+    class: string;
+    enumeratedConfig: {
+        overrideResource: Resource;
+        filter: () => string;
+        disableCacheForFilterPii: boolean;
+        filterType: FilterType;
+        sorts: FieldSort[];
+        listDisplay: FieldName[];
+        viewDisplay: FieldName[];
+        viewConcatFn: ConcatFn;
+        listConcatFn: ConcatFn;
+        viewDetails: boolean;
+        searchable: boolean;
+    };
+    default: null;
+    validators: never[];
+    nullBooleanConfig: {
+        displayValues: Readonly<{
+            null: {
+                label: string;
+                value: null;
+            };
+            true: {
+                label: string;
+                value: boolean;
+            };
+            false: {
+                label: string;
+                value: boolean;
+            };
+        }>;
+    };
+    readOnly: false;
+    prefixes: never[];
+    suffixes: never[];
+    shouldRender: true;
+    nullIfConditionallyHidden: false;
+};
+/**
+ * RouteData is used to define the route for a config
+ * route: the route for the config
+ * hasViewRoute: when true, a route will be created for route/:uuid
+ */
+interface RootRouteData {
+    route?: string;
+    hasViewRoute?: boolean;
+}
+interface RPCConfigOptions {
+    label: string;
+    afterMethodRedirect?: string;
+    conditions: {
+        field: FieldName;
+        matchValues: string[];
+    }[];
+    methodBodyTemplate?: any;
+    successMessage?: string;
+    elements?: ConfigElement[];
+    placement?: RPCPlacement;
+    method: Method;
+    customComponent?: ComponentConfig;
+    refreshResources?: Resource[];
+    defaultModalWidth?: string;
+    shouldRender?: () => boolean;
+}
+interface RPCConfig {
+    label: string;
+    afterMethodRedirect: string | string[];
+    conditions: {
+        field: FieldName;
+        matchValues: string[];
+    }[];
+    methodBodyTemplate: any;
+    method: Method;
+    successMessage: string;
+    elements: ConfigElement[];
+    placement: RPCPlacement;
+    customComponent: ComponentConfig;
+    refreshResources: Resource[];
+    defaultModalWidth: string;
+    shouldRender: () => boolean;
+}
+declare function rpcConfig(config: RPCConfigOptions): RPCConfig;
+declare const rpcConfigDefaults: {
+    label: string;
+    afterMethodRedirect: string;
+    conditions: {
+        field: FieldName;
+        matchValues: string[];
+    }[];
+    methodBodyTemplate: any;
+    successMessage: string;
+    elements: ConfigElement[];
+    placement: RPCPlacement;
+    method: Method;
+    customComponent: ComponentConfig;
+    refreshResources: Resource[];
+    defaultModalWidth: string;
+    shouldRender: () => boolean;
+};
+interface RPCBaseFormData {
+    elements: FieldElement[];
+    label: string;
+    method: Method;
+}
+interface RootConfigOptions {
+    routeData?: RootRouteData;
+    nav?: {
+        navItem: MenuItem;
+        group?: string;
+    };
+    parentConfig: ParentResourceConfig;
+    relatedConfigs?: ChildResourceConfig[];
+    rpcConfigs?: RPCConfig[];
+}
+interface RootConfig {
+    routeData: RootRouteData;
+    nav: {
+        navItem: MenuItem;
+        group?: string;
+    };
+    parentConfig: ParentResourceConfig;
+    relatedConfigs: ChildResourceConfig[];
+    rpcConfigs?: RPCConfig[];
+}
+declare const rootConfigDefaults: {
+    routeData: RootRouteData;
+    nav: {
+        navItem: MenuItem;
+    };
+    parentConfig: ParentResourceConfig;
+    relatedConfigs: ChildResourceConfig[];
+    rpcConfigs: RPCConfig[];
+};
+declare function rootConfig(config: RootConfigOptions): RootConfig;
+interface BaseConfigOptions {
+    title?: string;
+    createTitle?: string;
+    createButtonLabel?: string;
+    primaryResource: Resource;
+    parentClass?: string;
+    fieldClass?: string;
+    elements: ConfigElement[];
+    createConfig?: ConfigType;
+    parentRelation?: {
+        parentKey: FieldName;
+        childKey: FieldName;
+    };
+    showBackButton?: boolean;
+    createNavigation?: string[];
+}
+interface BaseConfig {
+    title: string;
+    createTitle: string;
+    createButtonLabel: string;
+    primaryResource: Resource;
+    parentClass: string;
+    fieldClass: string;
+    elements: ConfigElement[];
+    createConfig: ConfigType;
+    parentRelation: {
+        parentKey: FieldName;
+        childKey: FieldName;
+    };
+    showBackButton: boolean;
+    createNavigation: string[];
+}
+type AvailableComponents = 'SwitchResolver';
+type ConfigParam = SwitchConfigParam;
+interface ComponentConfigOptions {
+    primaryResource: Resource;
+    component: AvailableComponents;
+    params?: ConfigParam;
+    relatedConfig?: ParentResourceConfig[];
+    shouldRenderActions?: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+}
+interface ComponentConfig {
+    type: 'Component';
+    primaryResource: Resource;
+    component: AvailableComponents;
+    params: ConfigParam;
+    relatedConfig: ParentResourceConfig[];
+    shouldRenderActions: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+}
+declare function componentConfig(config: ComponentConfigOptions): ComponentConfig;
+declare const componentConfigDefaults: {
+    type: "Component";
+    primaryResource: Resource;
+    component: AvailableComponents;
+    params: {
+        cases: never[];
+    };
+    relatedConfig: ParentResourceConfig[];
+    shouldRenderActions: {
+        create: () => boolean;
+        edit: () => boolean;
+        delete: () => boolean;
+    };
+};
+interface switchCase {
+    caseId: string;
+    parentField: string;
+    childId: string;
+    config: ChildResourceConfig;
+}
+interface SwitchConfigParamOptions {
+    cases: switchCase[];
+}
+interface SwitchConfigParam {
+    cases: switchCase[];
+}
+declare function switchParams(config: SwitchConfigParamOptions): SwitchConfigParam;
+declare const switchParamsDefaults: {
+    cases: switchCase[];
+};
+interface ListViewConfigOptions extends BaseConfigOptions {
+    showViewButton?: boolean;
+    loadCreatedResource?: boolean;
+    collapsible?: boolean;
+    overrideResource?: Resource;
+    searchable?: boolean;
+    enableRowExpansion?: boolean;
+    rowExpansionConfig?: ChildResourceConfig;
+    requireSearchToDisplayResults?: boolean;
+    listColumns: ColumnConfig[];
+    relatedConfigs?: ChildResourceConfig[];
+    viewResource?: Resource | string;
+    actionType?: ActionType;
+    filter?: (parentResource: any) => string;
+    disableCacheForFilterPii?: boolean;
+    rpcConfigs?: RPCConfig[];
+    sorts?: FieldSort[];
+    shouldRenderActions?: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+}
+interface ListViewConfig extends BaseConfig {
+    type: 'ListView';
+    showViewButton: boolean;
+    loadCreatedResource: boolean;
+    collapsible: boolean;
+    overrideResource: Resource;
+    searchable: boolean;
+    enableRowExpansion: boolean;
+    rowExpansionConfig: ChildResourceConfig;
+    requireSearchToDisplayResults: boolean;
+    listColumns: ColumnConfig[];
+    relatedConfigs: ChildResourceConfig[];
+    viewResource: Resource | string;
+    actionType: ActionType;
+    filter: (parentResource: any) => string;
+    disableCacheForFilterPii: boolean;
+    rpcConfigs?: RPCConfig[];
+    sorts: FieldSort[];
+    shouldRenderActions: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+}
+declare function listViewConfig(config: ListViewConfigOptions): ListViewConfig;
+declare const listViewConfigDefaults: {
+    title: string;
+    primaryResource: Resource;
+    type: "ListView";
+    createTitle: string;
+    createButtonLabel: string;
+    loadCreatedResource: false;
+    showViewButton: true;
+    collapsible: false;
+    listColumns: never[];
+    elements: never[];
+    parentClass: string;
+    fieldClass: string;
+    createConfig: ListViewConfig;
+    createNavigation: never[];
+    relatedConfigs: never[];
+    parentRelation: {
+        parentKey: FieldName;
+        childKey: FieldName;
+    };
+    overrideResource: Resource;
+    searchable: false;
+    enableRowExpansion: false;
+    rowExpansionConfig: ChildResourceConfig;
+    requireSearchToDisplayResults: false;
+    showBackButton: true;
+    filter: () => string;
+    disableCacheForFilterPii: false;
+    sorts: FieldSort[];
+    viewResource: Resource;
+    actionType: ActionType;
+    rpcConfigs: never[];
+    shouldRenderActions: {
+        create: () => boolean;
+        edit: () => boolean;
+        delete: () => boolean;
+    };
+};
+type ViewType = 'OneToOne' | 'OneToMany';
+interface ViewConfigOptions extends BaseConfigOptions {
+    collapsible?: boolean;
+    connectorResource?: Resource;
+    relatedConfigs?: ChildResourceConfig[];
+    rpcConfigs?: RPCConfig[];
+    shouldRenderActions?: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+}
+interface ViewConfig extends BaseConfig {
+    type: 'View';
+    collapsible: boolean;
+    connectorResource: Resource;
+    rpcConfigs?: RPCConfig[];
+    relatedConfigs: ChildResourceConfig[];
+    /** A set of functions that allows for
+     * conditional display of non-RPC
+     * actions based on the pristine state of the resource
+     * (if such a state is applicable. Creation for example won't
+     * have such data)
+     * This is separate from ABAC control which takes
+     * precedence and is based on a user's attributes
+     */
+    shouldRenderActions: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+}
+declare function viewConfig(config: ViewConfigOptions): ViewConfig;
+declare const viewConfigDefaults: {
+    title: string;
+    primaryResource: Resource;
+    type: "View";
+    createTitle: string;
+    createButtonLabel: string;
+    parentClass: string;
+    fieldClass: string;
+    elements: never[];
+    collapsible: true;
+    connectorResource: Resource;
+    relatedConfigs: never[];
+    createConfig: ViewConfig;
+    shouldRenderActions: {
+        create: () => boolean;
+        edit: () => boolean;
+        delete: () => boolean;
+    };
+    createNavigation: never[];
+    parentRelation: {
+        parentKey: FieldName;
+        childKey: FieldName;
+    };
+    showBackButton: true;
+    rpcConfigs: never[];
+};
+interface arrayConfigOptions {
+    iteratedConfig: ChildResourceConfig;
+    viewType?: ViewType;
+    collapsible?: boolean;
+    createConfig?: ConfigType;
+    connectorResource?: Resource;
+    connectorField?: FieldName;
+    primaryResource: Resource;
+    listFilter: (parentResource: any) => string;
+    disableCacheForFilterPii?: boolean;
+    sorts?: FieldSort[];
+    title?: string;
+    createButtonLabel?: string;
+    limit?: number;
+    shouldRenderActions?: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+}
+interface ArrayConfig {
+    type: 'Array';
+    iteratedConfig: ChildResourceConfig;
+    viewType: ViewType;
+    collapsible: boolean;
+    createConfig: ConfigType;
+    connectorResource: Resource;
+    connectorField: FieldName;
+    primaryResource: Resource;
+    listFilter: (parentResource: any) => string;
+    disableCacheForFilterPii: boolean;
+    sorts: FieldSort[];
+    title: string;
+    createButtonLabel: string;
+    shouldRenderActions: Record<'edit' | 'delete' | 'create', (data: any) => boolean>;
+    limit: number;
+}
+declare function arrayConfig(config: arrayConfigOptions): ArrayConfig;
+declare const arrayConfigDefaults: {
+    type: "Array";
+    iteratedConfig: ChildResourceConfig;
+    viewType: ViewType;
+    collapsible: true;
+    createConfig: ViewConfig;
+    connectorResource: Resource;
+    connectorField: FieldName;
+    primaryResource: Resource;
+    listFilter: () => string;
+    disableCacheForFilterPii: false;
+    sorts: FieldSort[];
+    title: string;
+    createButtonLabel: string;
+    limit: number;
+    shouldRenderActions: {
+        create: () => boolean;
+        edit: () => boolean;
+        delete: () => boolean;
+    };
+};
+
+declare enum AlertLevel {
+    ERROR = "warn",
+    INFO = "accent",
+    SUCCESS = "success"
+}
+interface CreateNotificationMessage {
+    duration?: number;
+    message: string;
+    link: string;
+    level: AlertLevel;
+}
+interface NotificationMessage {
+    id: number;
+    duration?: number;
+    message: string;
+    link: string;
+    level: AlertLevel;
+}
+
+type ValidDisplayTypes = 'boolean' | 'nullboolean' | 'number' | 'string' | 'date' | 'enumerated' | 'link' | 'uuid' | 'civildate';
+type ValidRPCTypes = ValidDisplayTypes | `${ValidDisplayTypes}[]`;
+interface RPCFieldMeta {
+    fieldName: string;
+    displayType: ValidRPCTypes;
+    enumeratedResource?: Resource;
+}
+interface MethodMeta {
+    route: string;
+    fields: RPCFieldMeta[];
+}
+interface FieldMeta {
+    fieldName: string;
+    /** Indicates whether the field is required and only applies during resource creation.
+     * Use the validators config parameter in all other contexts
+     */
+    required: boolean;
+    primaryKey?: {
+        ordinalPosition: number;
+    };
+    displayType: ValidDisplayTypes;
+    enumeratedResource?: Resource;
+    isIndex: boolean;
+}
+interface ResourceMeta {
+    route: string;
+    consolidatedRoute?: string;
+    listDisabled?: boolean;
+    readDisabled?: boolean;
+    createDisabled?: boolean;
+    updateDisabled?: boolean;
+    deleteDisabled?: boolean;
+    substringSearchParameter?: string;
+    fields: FieldMeta[];
+}
+type Meta = MethodMeta | ResourceMeta;
+
+/**
+ * Session Information for a logged in user
+ */
+interface SessionInfo {
+    authenticated: boolean;
+    username: string;
+    permissions: DomainPermissions;
+}
+
+/**
+ * The base URL for API requests (e.g., 'https://api.example.com/').
+ */
+declare const BASE_URL: InjectionToken<string>;
+/**
+ * The path to the frontend login page (e.g., '/login').
+ */
+declare const FRONTEND_LOGIN_PATH: InjectionToken<string>;
+/**
+ * The path to the session endpoint (e.g., 'user/session').
+ */
+declare const SESSION_PATH: InjectionToken<string>;
+/**
+ * The base URL for API requests (e.g., '/api').
+ */
+declare const API_URL: InjectionToken<string>;
+declare const PERMISSION_REQUIRED: InjectionToken<(resource: Resource, permission: Permission) => boolean>;
+declare const AVAILABLE_PERMISSIONS: InjectionToken<{
+    Create: Permission;
+    Delete: Permission;
+    List: Permission;
+    Read: Permission;
+    Update: Permission;
+}>;
+declare const AVAILABLE_DOMAINS: InjectionToken<Record<string, Domain>[]>;
+declare const RESOURCE_META: InjectionToken<(resource: Resource) => ResourceMeta>;
+declare const METHOD_META: InjectionToken<(method: string) => MethodMeta>;
+declare const IDLE_SESSION_DURATION: InjectionToken<number>;
+declare const IDLE_WARNING_DURATION: InjectionToken<number>;
+declare const IDLE_KEEPALIVE_DURATION: InjectionToken<number>;
+
+declare class AlertComponent implements OnInit {
+    error: NotificationMessage$1;
+    dismiss: EventEmitter<any>;
+    errors: NotificationService$1;
+    ngOnInit(): void;
+    dismissAlert(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertComponent, "ccc-alert", never, { "error": { "alias": "error"; "required": true; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+interface NavItem {
+    type: 'link' | 'header' | 'expandable';
+    routerLink?: string[];
+    label: string;
+    icon?: string;
+    permission?: PermissionScope$1;
+    children?: NavItem[];
+    isExpanded?: boolean;
+    attentionCount?: Signal<number>;
+}
+type NavGroups = Record<string, NavItem[]>;
+declare class SidenavComponent {
+    ui: UiCoreService$1;
+    navGroups?: NavGroups;
+    currentNav: Signal<NavItem[]>;
+    /**
+     * Updates the currentNav based on the identifier
+     * @param identifier
+     * @returns NavItem[]
+     * @memberof SidenavComponent
+     */
+    updateNavItems(identifier: string): NavItem[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidenavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidenavComponent, "ccc-sidenav", never, { "navGroups": { "alias": "navGroups"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ApiInterceptor implements HttpInterceptor {
+    private ui;
+    private auth;
+    private router;
+    private ngZone;
+    private baseUrl;
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ApiInterceptor, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ApiInterceptor>;
+}
+
+declare class NotificationService {
+    private notificationId;
+    private _notifications;
+    notifications: _angular_core.Signal<NotificationMessage$1[]>;
+    /**
+     * Adds a new global notification.
+     * @param notification The notification message to add.
+     * @returns The unique ID assigned to the notification.
+     */
+    addGlobalNotification(notification: CreateNotificationMessage$1): number;
+    /**
+     * Dismisses a global notification by its ID.
+     * @param notificationId The ID of the notification to dismiss.
+     */
+    dismissGlobalNotificationById(notificationId: number): void;
+    /**
+     * Dismisses a specific global notification.
+     * @param notification The notification to dismiss.
+     */
+    dismissGlobalNotification(notification: NotificationMessage$1): void;
+    /**
+     * Updates an existing notification.
+     * @param updatedNotification The notification with updated information.
+     */
+    updateNotification(updatedNotification: NotificationMessage$1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+type ActionButtonContext$1 = {
+    actionType: 'create' | 'edit' | 'delete';
+    meta: ResourceMeta$1;
+    resourceData: RecordData$1;
+    shouldRender: (data: RecordData$1) => boolean;
+} | {
+    actionType: 'rpc';
+    resourceData: RecordData$1;
+    shouldRender: (data: RecordData$1) => boolean;
+};
+declare class ActionAccessControlWrapperComponent {
+    actionContext: _angular_core.InputSignal<ActionButtonContext$1 | undefined>;
+    showAction: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionAccessControlWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionAccessControlWrapperComponent, "action-access-control-wrapper", never, { "actionContext": { "alias": "actionContext"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FormStateService {
+    dirtyForms: _angular_core.WritableSignal<number>;
+    incrementDirtyForms(): void;
+    decrementDirtyForms(): void;
+    resetDirtyForms(): void;
+    isDirty: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FormStateService>;
+}
+
+declare const generatedNavItems: MenuItem$1[];
+declare const generatedNavGroups: string[];
+interface Link {
+    id: string;
+    resource: Resource$1;
+    text: string;
+}
+type ResourceMap = Record<Resource$1, ResourceMeta$1>;
+type PristineData = Record<string, DataType$1 | null>;
+declare const createFormGroup: (meta: ResourceMeta$1, resourceData: RecordData$1, config: ViewConfig$1, formDataState?: ModelSignal<RecordData$1>) => {
+    formGroup: FormGroup;
+    pristineFormValues: PristineData;
+};
+declare const resourceRoutes: (config: RootConfig$1, resourceMeta: (resource: Resource$1) => ResourceMeta$1) => Route;
+/**
+ * Recursive function to extract nested field names from a config.
+ * @param elements - The elements to extract field names from.
+ * @returns - An array of field names.
+ */
+declare function extractFieldNames(elements: ConfigElement$1[]): string[];
+type PatchOperation = 'add' | 'patch' | 'remove';
+interface Operation {
+    op: PatchOperation;
+    value?: Record<string, unknown>;
+    path: string;
+}
+interface CreateOperation extends Operation {
+    op: 'add';
+}
+interface UpdateOperation extends Operation {
+    op: 'patch';
+}
+interface DeleteOperation extends Operation {
+    op: 'remove';
+}
+/**
+ * Checks if a string is a valid UUID (versions 1-5) according to RFC 4122.
+ *
+ * @param str - The string to validate.
+ * @returns `true` if the string is a valid UUID, otherwise `false`.
+ */
+declare function isUUID(str: string): boolean;
+/**
+ * Coerces metadata types in a record according to the metadata.
+ *
+ * @param record - The record to coerce.
+ * @param meta - The metadata (resource or method).
+ * @returns The coerced record.
+ */
+declare function metadataTypeCoercion(record: RecordData$1, meta: ResourceMeta$1): RecordData$1;
+declare function metadataTypeCoercion(record: RPCRecordData$1, meta: MethodMeta$1): RPCRecordData$1;
+
+declare class ResourceStore {
+    resourceMeta: _angular_core.WritableSignal<ResourceMeta$1>;
+    resourceName: _angular_core.WritableSignal<Resource$1>;
+    filter: _angular_core.WritableSignal<string>;
+    disableCacheForFilterPii: _angular_core.WritableSignal<boolean>;
+    searchTokens: _angular_core.WritableSignal<string>;
+    sorts: _angular_core.WritableSignal<FieldSort$1[]>;
+    listColumns: _angular_core.WritableSignal<ColumnConfig$1[]>;
+    requireSearchToDisplayResults: _angular_core.WritableSignal<boolean>;
+    uuid: _angular_core.WritableSignal<string>;
+    error: _angular_core.WritableSignal<string>;
+    notifications: NotificationService$1;
+    http: HttpClient;
+    router: Router;
+    injector: Injector;
+    apiUrl: string;
+    methodMeta: (method: string) => _cccteam_ccc_lib_src_types.MethodMeta;
+    private resourceListRef;
+    listData: Signal<RecordData$1[]>;
+    listStatus: Signal<_angular_core.ResourceStatus | undefined>;
+    private resourceViewRef;
+    viewData: Signal<RecordData$1>;
+    viewStatus: Signal<_angular_core.ResourceStatus | undefined>;
+    overrideRoute: _angular_core.WritableSignal<string>;
+    resourceRoute: Signal<string>;
+    route: Signal<string>;
+    reloadViewData(): void;
+    reloadListData(): void;
+    buildStoreListData(): void;
+    buildStoreViewData(): void;
+    routes: {
+        resources: (rootUrl: string, resources: string) => string;
+        resource: (rootUrl: string, resources: string, uuid: string) => string;
+        method: (rootUrl: string, method: string) => string;
+    };
+    makePatches(operations: Operation[], route: string, resource: Resource$1): Observable<Record<string, unknown>>;
+    createPatch(operation: Operation, route: string, resource: Resource$1): Observable<Record<string, unknown>>;
+    private patchMultiple;
+    resourceView(route: Signal<string>, uuid: Signal<string>): ResourceRef<RecordData$1>;
+    resourceList(route: Signal<string>, filter?: Signal<string>, columns?: Signal<string[]>, disableCacheForFilterPii?: Signal<boolean>, searchTokens?: Signal<string>, sorts?: Signal<FieldSort$1[]>, defaultEmpty?: boolean): ResourceRef<RecordData$1[]>;
+    private list;
+    rpcCall<T>(rpcConfig: RPCConfig$1, body: T): Observable<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ResourceStore>;
+}
+
+declare class RpcButtonComponent {
+    activatedRoute: ActivatedRoute;
+    router: Router;
+    notifications: NotificationService$1;
+    formState: FormStateService;
+    dialog: MatDialog;
+    store: ResourceStore;
+    methodMeta: (method: string) => _cccteam_ccc_lib_src_types.MethodMeta;
+    relatedData: _angular_core.InputSignal<RecordData$1>;
+    rpcConfig: _angular_core.InputSignal<RPCConfig$1>;
+    primaryResource: _angular_core.InputSignal<Resource$1>;
+    dependentResources: _angular_core.InputSignal<ResourceRef<RecordData$1[]>[]>;
+    resourceConfigRouteSnapshot: _angular_core.Signal<RPCConfig$1>;
+    showRPCButton: _angular_core.Signal<boolean>;
+    submitRPC(): void;
+    buildRpcBody(rpcConfig: RPCConfig$1, submitBody: RPCRecordData$1): void;
+    callRpc(rpc: RPCConfig$1, submitBody: RPCRecordData$1): void;
+    reloadDependentResources(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RpcButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RpcButtonComponent, "ccc-rpc-button", never, { "relatedData": { "alias": "relatedData"; "required": true; "isSignal": true; }; "rpcConfig": { "alias": "rpcConfig"; "required": true; "isSignal": true; }; "primaryResource": { "alias": "primaryResource"; "required": true; "isSignal": true; }; "dependentResources": { "alias": "dependentResources"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BaseRPCModalComponent {
+    methodMeta: (method: string) => _cccteam_ccc_lib_src_types.MethodMeta;
+    private dialogRef;
+    data: {
+        elements: FieldElement$1[];
+        label: string;
+        method: Method$1;
+        width: string;
+    };
+    formData: _angular_core.WritableSignal<RPCBaseFormData$1>;
+    meta: _angular_core.Signal<_cccteam_ccc_lib_src_types.MethodMeta>;
+    constructor();
+    onConfirm(): void;
+    form: _angular_core.Signal<FormGroup<{}>>;
+    pristineForm: Record<string, DataType$1>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseRPCModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseRPCModalComponent, "ccc-base-rpc-modal", never, {}, {}, never, never, true, never>;
+}
+
+type CanDeactivateType = Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+interface CanComponentDeactivate {
+    canDeactivate: () => CanDeactivateType;
+}
+declare const canDeactivateGuard: CanDeactivateFn<CanComponentDeactivate>;
+
+declare class CompoundResourceComponent implements OnInit {
+    location: Location;
+    route: ActivatedRoute;
+    store: ResourceStore;
+    injector: Injector;
+    componentRef: Type<any>;
+    resourceMeta: (resource: Resource$1) => _cccteam_ccc_lib_src_types.ResourceMeta;
+    resourceConfig: _angular_core.InputSignal<_cccteam_ccc_lib_src_types.ListViewConfig | _cccteam_ccc_lib_src_types.ViewConfig | _cccteam_ccc_lib_src_types.ComponentConfig | _cccteam_ccc_lib_src_types.ArrayConfig | undefined>;
+    isArrayChild: _angular_core.InputSignal<boolean>;
+    uuid: _angular_core.InputSignal<string>;
+    parentData: _angular_core.InputSignal<RecordData$1 | undefined>;
+    rootConfig: _angular_core.Signal<RootConfig$1>;
+    emptyOneToOne: _angular_core.WritableSignal<boolean>;
+    missingRoot: _angular_core.InputSignal<boolean>;
+    resourceCreate: _angular_core.OutputEmitterRef<void>;
+    deleted: _angular_core.OutputEmitterRef<boolean>;
+    navAfterDelete: _angular_core.InputSignal<boolean>;
+    navAfterDeleteConsideringRoot: _angular_core.Signal<boolean>;
+    hasElements: _angular_core.Signal<boolean>;
+    primaryConfigParentId: _angular_core.Signal<string>;
+    primaryConfig: _angular_core.Signal<_cccteam_ccc_lib_src_types.ComponentConfig | ParentResourceConfig$1>;
+    title: _angular_core.Signal<string>;
+    isRootConfig: _angular_core.Signal<boolean>;
+    configs: _angular_core.Signal<ChildResourceConfig$1[]>;
+    rpcConfigs: _angular_core.Signal<{
+        config: _cccteam_ccc_lib_src_types.RPCConfig;
+        context: {
+            actionType: "rpc";
+            shouldRender: () => boolean;
+            resourceData: RecordData$1;
+        };
+    }[]>;
+    hasRpcConfigs: _angular_core.Signal<boolean>;
+    resolvedData: _angular_core.Signal<RecordData$1>;
+    ngOnInit(): void;
+    constructor();
+    goBack(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CompoundResourceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CompoundResourceComponent, "compound-resource", never, { "resourceConfig": { "alias": "resourceConfig"; "required": false; "isSignal": true; }; "isArrayChild": { "alias": "isArrayChild"; "required": false; "isSignal": true; }; "uuid": { "alias": "uuid"; "required": true; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; "missingRoot": { "alias": "missingRoot"; "required": false; "isSignal": true; }; "navAfterDelete": { "alias": "navAfterDelete"; "required": false; "isSignal": true; }; }, { "resourceCreate": "resourceCreate"; "deleted": "deleted"; }, never, never, true, never>;
+}
+
+declare const concatFunctions: {
+    'space-concat': typeof spaceConcat;
+    'hyphen-concat': typeof hyphenConcat;
+    'space-hyphen-concat': typeof spaceHyphenConcat;
+    'hyphen-space-concat': typeof hyphenSpaceConcat;
+};
+/**
+ * Concatenates the strings corresponding to the given keys in the resource,
+ * using a space separator.
+ * @param resource A record mapping keys to string values.
+ * @param args Keys of the resource to concatenate.
+ * @returns Concatenated string.
+ * @example
+ * const resource = { foo: 'foo', bar: 'bar', baz: 'baz' };
+ * spaceConcat(resource, 'foo', 'bar', 'baz'); // returns 'foo bar baz'
+ */
+declare function spaceConcat(resource: Record<string, string>, ...args: string[]): string;
+/**
+ * Concatenates the strings corresponding to the given keys in the resource,
+ * using a hyphen separator.
+ * @param resource A record mapping keys to string values.
+ * @param args Keys of the resource to concatenate.
+ * @returns Concatenated string.
+ * @example
+ * const resource = { foo: 'foo', bar: 'bar', baz: 'baz' };
+ * hyphenConcat(resource, 'foo', 'bar', 'baz'); // returns 'foo - bar - baz'
+ */
+declare function hyphenConcat(resource: Record<string, string>, ...args: string[]): string;
+/**
+ * Concatenates the given strings so that all but the last are joined with a space,
+ * and the last string is appended with a " - " separator.
+ * @param resource A mapping of keys to string values.
+ * @param args Keys of strings to concatenate.
+ * @returns Concatenated string.
+ * @example spaceHyphenConcat(resource, 'foo', 'bar', 'baz') => 'foo bar - baz'
+ */
+declare function spaceHyphenConcat(resource: Record<string, string>, ...args: string[]): string;
+/**
+ * Concatenates the given strings so that all but the first are joined with a space,
+ * and the first string is appended with a " - " separator.
+ * @param resource A mapping of keys to string values.
+ * @param args Keys of strings to concatenate.
+ * @returns Concatenated string.
+ * @example spaceHyphenConcat(resource, 'foo', 'bar', 'baz') => 'foo - bar baz'
+ */
+declare function hyphenSpaceConcat(resource: Record<string, string>, ...args: string[]): string;
+/**
+ * Concatenates the strings using a space separator.
+ * @param args Strings to concatenate.
+ * @returns Concatenated string.
+ * @example
+ * spaceConcatWithoutResource(['foo', 'bar', 'baz']); // returns 'foo bar baz'
+ */
+declare function spaceConcatWithoutResource(args: string[]): string;
+/**
+ * Concatenates the strings using a hyphen separator.
+ * @param args Strings to concatenate.
+ * @returns Concatenated string.
+ * @example
+ * hyphenConcatWithoutResource(['foo', 'bar', 'baz']); // returns 'foo - bar - baz'
+ */
+declare function hyphenConcatWithoutResource(args: string[]): string;
+/**
+ * Concatenates the given strings so that all but the last are joined with a space,
+ * and the last string is appended with a " - " separator.
+ * @param args Strings to concatenate.
+ * @returns Concatenated string.
+ * @example spaceHyphenConcatWithoutResource(['foo', 'bar', 'baz']) => 'foo bar - baz'
+ */
+declare function spaceHyphenConcatWithoutResource(args: string[]): string;
+/**
+ * Concatenates the given strings so that all but the first are joined with a space,
+ * and the first string is appended with a " - " separator.
+ * @param args Strings to concatenate.
+ * @returns Concatenated string.
+ * @example hyphenSpaceConcatWithoutResource(['foo', 'bar', 'baz']) => 'foo - bar baz'
+ */
+declare function hyphenSpaceConcatWithoutResource(args: string[]): string;
+/**
+ * Concatenates the given strings without any space,
+ * @param args Strings to concatenate.
+ * @returns Concatenated string.
+ * @example noSpaceConcatWithoutResource(['foo', 'bar', 'baz']) => 'foobarbaz'
+ */
+declare function noSpaceConcatWithoutResource(args: string[]): string;
+
+declare class DeleteResourceConfirmationModalComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeleteResourceConfirmationModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DeleteResourceConfirmationModalComponent, "ccc-delete-resource-confirmation-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class EmptyReadonlyFieldComponent {
+    label: _angular_core.InputSignal<string>;
+    displayValue: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyReadonlyFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyReadonlyFieldComponent, "ccc-empty-readonly-field", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type FormatterFn = (value: string) => string;
+declare const simpleSlashDateFormatter: (value: string) => string;
+declare const ValueFormatters: Record<FormatType$1, FormatterFn>;
+declare function applyFormatting(formatString: string, value: string): string;
+declare function formatDateString(formatString: string, value: string): string;
+
+declare const maxConfigElementRecursionDepth = 240;
+declare const maxLayoutNestingDepth = 48;
+/** Returns a flat array of nested elements by recursively traversing
+ * through the elements graph */
+declare const flattenElements: (elements: ConfigElement$1[], depth?: number) => ConfigElement$1[];
+declare const civildateCoercion: (value: string) => Date;
+/**
+ * This object stores every possible validator used across the application
+ * Add all validators that are used in configs to this object
+ *
+ * Available validators that may be added: min, max, required, requiredTrue,
+ *    email, minLength, maxLength, pattern, nullValidator
+ */
+declare const resourceValidators: Readonly<{
+    REQUIRED: _cccteam_ccc_lib_src_types.ResourceValidatorFn;
+    EMAIL: _cccteam_ccc_lib_src_types.ResourceValidatorFn;
+    CURRENT_OR_FUTURE_DATE: _cccteam_ccc_lib_src_types.ResourceValidatorFn;
+    POSITIVE_NUMBER: _cccteam_ccc_lib_src_types.ResourceValidatorFn;
+    NOT_FUTURE_DATE: _cccteam_ccc_lib_src_types.ResourceValidatorFn;
+    VALUE_IN_RANGE_INCLUSIVE: (min: number, max: number) => _cccteam_ccc_lib_src_types.ResourceValidatorFn;
+    MAX_LENGTH: (maxLength: number) => _cccteam_ccc_lib_src_types.ResourceValidatorFn;
+}>;
+
+declare class LeavePageConfirmationModalComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeavePageConfirmationModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LeavePageConfirmationModalComponent, "ccc-leave-page-confirmation-modal", never, {}, {}, never, never, true, never>;
+}
+
+declare class PaddingElementComponent implements OnInit {
+    paddingElement: _angular_core.InputSignal<PaddingElement$1>;
+    class: string;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaddingElementComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaddingElementComponent, "ccc-padding-element", never, { "paddingElement": { "alias": "paddingElement"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type ActionButtonContext = {
+    actionType: 'create' | 'edit' | 'delete';
+    meta: ResourceMeta$1;
+    resourceData: RecordData$1;
+    shouldRender: (data: RecordData$1) => boolean;
+} | {
+    actionType: 'rpc';
+    resourceData: RecordData$1;
+    shouldRender: (data: RecordData$1) => boolean;
+};
+
+declare class ResourceArrayViewComponent implements OnInit {
+    resourceMeta: (resource: _cccteam_ccc_lib_src_types.Resource) => _cccteam_ccc_lib_src_types.ResourceMeta;
+    store: ResourceStore;
+    injector: Injector;
+    resourceConfig: _angular_core.InputSignal<ArrayConfig$1>;
+    parentData: _angular_core.InputSignal<RecordData$1>;
+    expPanel: Signal<MatExpansionPanel | undefined>;
+    emptyOneToOne: _angular_core.OutputEmitterRef<boolean>;
+    createMode: _angular_core.WritableSignal<boolean>;
+    compoundResourceComponent: _angular_core.InputSignal<Type<any>>;
+    showCreateButton: Signal<boolean>;
+    createActionConfig: Signal<ActionButtonContext | undefined>;
+    createConfig: Signal<ViewConfig$1 | ArrayConfig$1>;
+    resourceListRoute: Signal<string>;
+    setCreateMode(value: boolean): void;
+    ngOnInit(): void;
+    constructor();
+    createResource(event: MouseEvent): void;
+    onResourceDeleted(): void;
+    onCreateCompleted(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceArrayViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceArrayViewComponent, "ccc-resource-array-view", never, { "resourceConfig": { "alias": "resourceConfig"; "required": true; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; "compoundResourceComponent": { "alias": "compoundResourceComponent"; "required": true; "isSignal": true; }; }, { "emptyOneToOne": "emptyOneToOne"; }, never, never, true, never>;
+}
+
+declare class ResourceCreateComponent implements OnInit {
+    resourceMeta: (resource: Resource$1) => _cccteam_ccc_lib_src_types.ResourceMeta;
+    activatedRoute: ActivatedRoute;
+    notifications: NotificationService$1;
+    store: ResourceStore;
+    router: Router;
+    destroyRef: DestroyRef;
+    formState: FormStateService;
+    isDirty: _angular_core.WritableSignal<boolean>;
+    submitted: _angular_core.WritableSignal<boolean>;
+    complete: _angular_core.OutputEmitterRef<boolean>;
+    resourceConfig: _angular_core.InputSignal<ChildResourceConfig$1 | undefined>;
+    parentData: _angular_core.InputSignal<RecordData$1>;
+    loadCreatedResource: _angular_core.InputSignal<boolean>;
+    rootConfig: _angular_core.Signal<RootConfig$1>;
+    config: _angular_core.Signal<ListViewConfig$1 | ViewConfig$1>;
+    indentTitle: _angular_core.Signal<boolean>;
+    form: _angular_core.Signal<FormGroup<{}>>;
+    route: _angular_core.Signal<string>;
+    primaryKeys: _angular_core.Signal<_cccteam_ccc_lib_src_types.FieldMeta[]>;
+    hasRequiredPrimaryKey: _angular_core.Signal<boolean>;
+    primaryKeyPath: _angular_core.Signal<string>;
+    camelCaseToTitlePipe: CamelCaseToTitlePipe$1;
+    ngOnInit(): void;
+    saveForm(): void;
+    cancelForm(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceCreateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceCreateComponent, "ccc-resource-create", never, { "resourceConfig": { "alias": "resourceConfig"; "required": false; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; "loadCreatedResource": { "alias": "loadCreatedResource"; "required": false; "isSignal": true; }; }, { "complete": "complete"; }, never, never, true, never>;
+}
+
+declare abstract class BaseInputComponent {
+    resourceMeta: (resource: _cccteam_ccc_lib_src_types.Resource) => _cccteam_ccc_lib_src_types.ResourceMeta;
+    injector: Injector;
+    store: ResourceStore;
+    meta: _angular_core.InputSignal<Meta$1>;
+    pristineValue: _angular_core.InputSignal<DataType$1 | null>;
+    editMode: _angular_core.InputSignal<"edit" | "view">;
+    showField: _angular_core.InputSignal<boolean | undefined>;
+    fieldConfig: _angular_core.InputSignal<FieldElement$1>;
+    fieldClass: _angular_core.InputSignal<string | undefined>;
+    fieldMeta: _angular_core.InputSignal<FieldMeta$1 | RPCFieldMeta$1>;
+    form: _angular_core.InputSignal<FormGroup<any>>;
+    relatedData: _angular_core.InputSignal<RecordData$1 | undefined>;
+    /**
+     * Resets the field back to its pristine value.
+     */
+    reset(): void;
+    private affixResources;
+    prefixString: _angular_core.Signal<string>;
+    suffixString: _angular_core.Signal<string>;
+    floatLabel: _angular_core.Signal<"auto" | "always">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseInputComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseInputComponent, never, never, { "meta": { "alias": "meta"; "required": true; "isSignal": true; }; "pristineValue": { "alias": "pristineValue"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": true; "isSignal": true; }; "showField": { "alias": "showField"; "required": false; "isSignal": true; }; "fieldConfig": { "alias": "fieldConfig"; "required": true; "isSignal": true; }; "fieldClass": { "alias": "fieldClass"; "required": false; "isSignal": true; }; "fieldMeta": { "alias": "fieldMeta"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "relatedData": { "alias": "relatedData"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ResourceFieldComponent {
+    fieldConfig: _angular_core.InputSignal<FieldElement$1>;
+    meta: _angular_core.InputSignal<Meta$1>;
+    fieldClass: _angular_core.InputSignal<string | undefined>;
+    editMode: _angular_core.InputSignal<"edit" | "view">;
+    form: _angular_core.InputSignal<FormGroup<any>>;
+    formDataState: _angular_core.InputSignal<RecordData$1 | undefined>;
+    pristineValue: _angular_core.InputSignal<DataType$1 | null>;
+    data: _angular_core.InputSignal<RecordData$1 | undefined>;
+    previouslyNulled: boolean | null;
+    fieldMeta: Signal<FieldMeta$1>;
+    mode: Signal<"edit" | "view">;
+    showField: Signal<boolean>;
+    showEmptyField: Signal<boolean>;
+    class: string;
+    booleanEditDisplayType: Signal<BooleanDisplayTypes>;
+    previousValidatorCount: number;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceFieldComponent, "ccc-resource-field", never, { "fieldConfig": { "alias": "fieldConfig"; "required": true; "isSignal": true; }; "meta": { "alias": "meta"; "required": true; "isSignal": true; }; "fieldClass": { "alias": "fieldClass"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "formDataState": { "alias": "formDataState"; "required": false; "isSignal": true; }; "pristineValue": { "alias": "pristineValue"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type BooleanDisplayTypes = Extract<ValidDisplayTypes$1, 'boolean' | 'nullboolean'>;
+
+declare class ResourceLayoutComponent implements OnInit {
+    element: _angular_core.InputSignal<ConfigElement$1>;
+    meta: _angular_core.InputSignal<Meta$1>;
+    fieldClass: _angular_core.InputSignal<string | undefined>;
+    editMode: _angular_core.InputSignal<"edit" | "view">;
+    form: _angular_core.InputSignal<FormGroup<any>>;
+    formDataState: _angular_core.ModelSignal<RecordData$1 | undefined>;
+    pristineValue: _angular_core.InputSignal<DataType$1 | null>;
+    relatedData: _angular_core.InputSignal<RecordData$1 | undefined>;
+    parentClass: _angular_core.InputSignal<string | undefined>;
+    layoutNestingDepth: _angular_core.InputSignal<number>;
+    maxLayoutNestingDepth: number;
+    children: _angular_core.Signal<ConfigElement$1[]>;
+    layoutChildrenConfig: _angular_core.Signal<ConfigElement$1[]>;
+    previouslyNulled: boolean;
+    nullIfConditionallyHidden: _angular_core.Signal<boolean>;
+    showLayout: _angular_core.Signal<boolean>;
+    class: string;
+    constructor();
+    ngOnInit(): void;
+    shouldInitializeFormData(form: FormGroup, layoutNestingDepth: number, shouldRender: ConfigElement$1['shouldRender'], layoutChildren: ConfigElement$1[]): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceLayoutComponent, "ccc-resource-layout-template", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "meta": { "alias": "meta"; "required": true; "isSignal": true; }; "fieldClass": { "alias": "fieldClass"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "formDataState": { "alias": "formDataState"; "required": false; "isSignal": true; }; "pristineValue": { "alias": "pristineValue"; "required": false; "isSignal": true; }; "relatedData": { "alias": "relatedData"; "required": false; "isSignal": true; }; "parentClass": { "alias": "parentClass"; "required": false; "isSignal": true; }; "layoutNestingDepth": { "alias": "layoutNestingDepth"; "required": false; "isSignal": true; }; }, { "formDataState": "formDataStateChange"; }, never, never, true, never>;
+}
+
+declare class ResourceListComponent implements OnInit {
+    compoundResourceComponent: _angular_core.InputSignal<Type<any>>;
+    resourceMeta: (resource: Resource$1) => _cccteam_ccc_lib_src_types.ResourceMeta;
+    router: Router;
+    store: ResourceStore;
+    injector: Injector;
+    activatedRoute: ActivatedRoute;
+    hideCreateButton: _angular_core.InputSignal<boolean>;
+    createMode: _angular_core.OutputEmitterRef<boolean>;
+    resourceConfig: _angular_core.InputSignal<ChildResourceConfig$1 | undefined>;
+    viewRoute: _angular_core.InputSignal<string | undefined>;
+    filter: _angular_core.InputSignal<string>;
+    linkCreateType: _angular_core.InputSignal<boolean>;
+    isRootList: _angular_core.InputSignal<boolean>;
+    showCreateButton: _angular_core.Signal<boolean>;
+    createButtonContext: _angular_core.Signal<{
+        actionType: "create";
+        meta: _cccteam_ccc_lib_src_types.ResourceMeta;
+        shouldRender: (data: RecordData$1) => boolean;
+        resourceData: RecordData$1;
+    } | undefined>;
+    searchableFields: _angular_core.Signal<string>;
+    relatedData: _angular_core.InputSignal<RecordData$1 | undefined>;
+    parentId: _angular_core.InputSignal<string | undefined>;
+    routeConfig: _angular_core.Signal<RootConfig$1>;
+    config: _angular_core.Signal<ListViewConfig$1>;
+    expansionConfig: _angular_core.Signal<ChildResourceConfig$1>;
+    viewRouteFallback: _angular_core.Signal<string | undefined>;
+    listTitle: _angular_core.Signal<string>;
+    indentTitle: _angular_core.Signal<boolean>;
+    createButtonLabel: _angular_core.Signal<string>;
+    meta: _angular_core.Signal<_cccteam_ccc_lib_src_types.ResourceMeta>;
+    resourceRefMap: _angular_core.WritableSignal<Map<Resource$1, ResourceRef<RecordData$1[]>>>;
+    primaryKeys: _angular_core.Signal<_cccteam_ccc_lib_src_types.FieldMeta[]>;
+    rootColumns: _angular_core.Signal<ColumnConfig$1[]>;
+    columns: _angular_core.Signal<ColumnConfig$1[]>;
+    reloadListData(): void;
+    processedRowData: _angular_core.Signal<{
+        [x: string]: _cccteam_ccc_lib_src_types.DataType | null;
+    }[]>;
+    filters: _angular_core.Signal<string>;
+    createResource(event: MouseEvent): void;
+    parentKey: _angular_core.Signal<string | number | true | string[] | Date | number[]>;
+    childKey: _angular_core.Signal<string>;
+    private getUniqueId;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceListComponent, "ccc-resource-list", never, { "compoundResourceComponent": { "alias": "compoundResourceComponent"; "required": true; "isSignal": true; }; "hideCreateButton": { "alias": "hideCreateButton"; "required": false; "isSignal": true; }; "resourceConfig": { "alias": "resourceConfig"; "required": false; "isSignal": true; }; "viewRoute": { "alias": "viewRoute"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "linkCreateType": { "alias": "linkCreateType"; "required": false; "isSignal": true; }; "isRootList": { "alias": "isRootList"; "required": false; "isSignal": true; }; "relatedData": { "alias": "relatedData"; "required": false; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; }, { "createMode": "createMode"; }, never, never, true, never>;
+}
+
+declare class ResourceListCreateComponent {
+    compoundResourceComponent: _angular_core.InputSignal<Type<any>>;
+    injector: Injector;
+    store: ResourceStore;
+    listChild: _angular_core.Signal<ResourceListComponent | undefined>;
+    route: ActivatedRoute;
+    router: Router;
+    create: _angular_core.WritableSignal<boolean>;
+    parentId: _angular_core.InputSignal<string | undefined>;
+    parentData: _angular_core.InputSignal<RecordData$1>;
+    searchParams: _angular_core.InputSignal<Record<string, string>[]>;
+    resourceConfig: _angular_core.InputSignal<ListViewConfig$1 | undefined>;
+    isRootList: _angular_core.InputSignal<boolean>;
+    childKey: _angular_core.Signal<string>;
+    filter: _angular_core.Signal<string>;
+    parentKey: _angular_core.Signal<string | number | true | string[] | Date | number[]>;
+    config: _angular_core.Signal<ListViewConfig$1>;
+    expPanel: _angular_core.Signal<MatExpansionPanel | undefined>;
+    rootConfig: _angular_core.Signal<RootConfig$1>;
+    createLinkType: _angular_core.Signal<boolean>;
+    createConfig: _angular_core.Signal<_cccteam_ccc_lib_src_types.ChildResourceConfig>;
+    createResource(event: MouseEvent): void;
+    makeCreatePatches(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceListCreateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceListCreateComponent, "ccc-resource-list-create", never, { "compoundResourceComponent": { "alias": "compoundResourceComponent"; "required": true; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; "searchParams": { "alias": "searchParams"; "required": false; "isSignal": true; }; "resourceConfig": { "alias": "resourceConfig"; "required": false; "isSignal": true; }; "isRootList": { "alias": "isRootList"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ResourceResolverComponent {
+    compoundResourceComponent: _angular_core.InputSignal<Type<any>>;
+    resourceConfig: _angular_core.InputSignal<ChildResourceConfig$1 | undefined>;
+    config: _angular_core.Signal<ComponentConfig$1>;
+    dynamicSlot: _angular_core.Signal<ViewContainerRef>;
+    parentData: _angular_core.InputSignal<RecordData$1>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceResolverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceResolverComponent, "ccc-resource-resolver", never, { "compoundResourceComponent": { "alias": "compoundResourceComponent"; "required": true; "isSignal": true; }; "resourceConfig": { "alias": "resourceConfig"; "required": false; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ResourceViewComponent implements OnInit {
+    resourceMeta: (resource: Resource$1) => _cccteam_ccc_lib_src_types.ResourceMeta;
+    location: Location;
+    router: Router;
+    activatedRoute: ActivatedRoute;
+    notifications: NotificationService$1;
+    store: ResourceStore;
+    injector: Injector;
+    destroyRef: DestroyRef;
+    formState: FormStateService;
+    dialog: MatDialog;
+    editMode: WritableSignal<'edit' | 'view'>;
+    uuid: _angular_core.InputSignal<string>;
+    config: _angular_core.InputSignal<ListViewConfig$1 | ViewConfig$1>;
+    relatedData: _angular_core.InputSignal<RecordData$1>;
+    compoundResourceView: _angular_core.InputSignal<boolean>;
+    isDirty: WritableSignal<boolean>;
+    displayFormInvalidMessage: WritableSignal<boolean>;
+    deleted: _angular_core.OutputEmitterRef<boolean>;
+    navAfterDelete: _angular_core.InputSignal<boolean>;
+    showCreateForm: _angular_core.ModelSignal<boolean>;
+    createConfig: _angular_core.Signal<_cccteam_ccc_lib_src_types.ChildResourceConfig>;
+    rootConfig: _angular_core.Signal<RootConfig$1>;
+    showCloseButton: _angular_core.Signal<boolean>;
+    commonButtonConfig: _angular_core.Signal<{
+        meta: _cccteam_ccc_lib_src_types.ResourceMeta;
+        resourceData: RecordData$1;
+        config: ListViewConfig$1 | ViewConfig$1;
+    } | undefined>;
+    editButtonContext: _angular_core.Signal<{
+        actionType: "edit";
+        meta: _cccteam_ccc_lib_src_types.ResourceMeta;
+        resourceData: RecordData$1;
+        shouldRender: ((data: any) => boolean) | ((data: any) => boolean);
+    } | undefined>;
+    deleteButtonContext: _angular_core.Signal<{
+        actionType: "delete";
+        meta: _cccteam_ccc_lib_src_types.ResourceMeta;
+        resourceData: RecordData$1;
+        shouldRender: (data: RecordData$1) => boolean;
+    } | undefined>;
+    inlineRpcConfigs: _angular_core.Signal<{
+        config: RPCConfig$1;
+        context: {
+            actionType: "rpc";
+            shouldRender: () => boolean;
+            resourceData: RecordData$1;
+        };
+    }[] | undefined>;
+    endRpcConfigs: _angular_core.Signal<{
+        config: RPCConfig$1;
+        context: {
+            actionType: "rpc";
+            shouldRender: () => boolean;
+            resourceData: RecordData$1;
+        };
+    }[] | undefined>;
+    useExpansionPanel: _angular_core.Signal<boolean>;
+    resourceConfigRouteSnapshot: _angular_core.Signal<ListViewConfig$1 | ViewConfig$1>;
+    emptyFormGroup: FormGroup<{}>;
+    form: _angular_core.Signal<FormGroup<{}>>;
+    pristineFormValues: Record<string, DataType$1 | null>;
+    route: _angular_core.Signal<string>;
+    primaryKeys: _angular_core.Signal<_cccteam_ccc_lib_src_types.FieldMeta[]>;
+    primaryKeyPath: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    setEditMode(mode: 'edit' | 'view'): void;
+    saveForm(): void;
+    resetForm(): void;
+    confirmDeleteResource(): void;
+    deleteResource(): void;
+    relatedId(): string;
+    constructor();
+    createResource(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourceViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceViewComponent, "ccc-resource-view", never, { "uuid": { "alias": "uuid"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "relatedData": { "alias": "relatedData"; "required": false; "isSignal": true; }; "compoundResourceView": { "alias": "compoundResourceView"; "required": false; "isSignal": true; }; "navAfterDelete": { "alias": "navAfterDelete"; "required": false; "isSignal": true; }; "showCreateForm": { "alias": "showCreateForm"; "required": false; "isSignal": true; }; }, { "deleted": "deleted"; "showCreateForm": "showCreateFormChange"; }, never, never, true, never>;
+}
+
+declare class CamelCaseToTitlePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CamelCaseToTitlePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CamelCaseToTitlePipe, "camelCaseToTitle", true>;
+}
+
+declare class AppGridComponent {
+    rowData: _angular_core.InputSignal<any[]>;
+    columnDefs: _angular_core.InputSignal<ColumnConfig$1[]>;
+    enableRowExpansion: _angular_core.InputSignal<boolean>;
+    detailTemplate: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    selectionType: _angular_core.InputSignal<"multiple" | "single" | "none">;
+    selectedRows: _angular_core.OutputEmitterRef<RecordData$1[]>;
+    selectedKeys: number[];
+    onSelectedKeysChange(keys: number[]): void;
+    selectionMode: _angular_core.Signal<false | SelectableSettings>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppGridComponent, "ccc-grid", never, { "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; "columnDefs": { "alias": "columnDefs"; "required": false; "isSignal": true; }; "enableRowExpansion": { "alias": "enableRowExpansion"; "required": false; "isSignal": true; }; "detailTemplate": { "alias": "detailTemplate"; "required": false; "isSignal": true; }; "selectionType": { "alias": "selectionType"; "required": false; "isSignal": true; }; }, { "selectedRows": "selectedRows"; }, never, never, true, never>;
+}
+
+declare class TableButtonComponent<T> {
+    config: _angular_core.InputSignal<ActionButtonConfig$1>;
+    rowData: _angular_core.InputSignal<T>;
+    tooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    color: _angular_core.InputSignal<string>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    viewRoute: _angular_core.InputSignal<string>;
+    id: _angular_core.InputSignal<string>;
+    link: _angular_core.Signal<string>;
+    callAction(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableButtonComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableButtonComponent<any>, "ccc-table-button", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "rowData": { "alias": "rowData"; "required": true; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "viewRoute": { "alias": "viewRoute"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IdleService implements OnDestroy {
+    private auth;
+    private core;
+    private router;
+    private notifications;
+    private readonly sessionDuration;
+    private readonly warningDuration;
+    private readonly keepAliveDuration;
+    private readonly idleCheckFrequency;
+    private readonly warningThreshold;
+    readonly isActive: WritableSignal<boolean>;
+    private lastActivityTimestamp;
+    private tick;
+    readonly secondsIdle: _angular_core.Signal<number>;
+    readonly isWarning: _angular_core.Signal<boolean>;
+    readonly countdown: _angular_core.Signal<number>;
+    private alertId;
+    private mainTickerSubscription;
+    private readonly activityEvents;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Starts the idle monitoring service.
+     */
+    start(): void;
+    /**
+     * Stops the idle monitoring service and cleans up timers and alerts.
+     */
+    stop(): void;
+    /**
+     * Logs out the user due to inactivity and stops the service.
+     */
+    logoutAndStop(): void;
+    private startMainTicker;
+    private checkSession;
+    setLastActivity(): void;
+    boundActivity: () => void;
+    private addActivityListeners;
+    private removeActivityListeners;
+    private showOrUpdateWarningAlert;
+    private dismissWarningAlert;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdleService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IdleService>;
+}
+
+/**
+ * Compares two objects and returns a sparse object containing only the differing key-value pairs
+ * @param data - object to compare
+ * @param compareData - object to compare against
+ * @returns Partial<T>
+ * @example sparseData<UserCreate>(this.user, initUser)
+ */
+declare function sparseData<T extends Record<string, unknown>>(data: T, compareData: T): Partial<T>;
+/**
+ * Iterates through a form group's controls and returns a sparse object with only the changed values.
+ * @param form - The form group to iterate through
+ * @param compareData - The object to compare the form's values to
+ * @returns - A sparse object with only the changed values
+ * @example sparseFormData<UserCreate>(this.userForm, initUser)
+ */
+declare function sparseFormData<T>(form: FormGroup, compareData: T): T;
+/**
+ * Recursively cleans a FormGroup or FormArray, removing controls with empty string values.
+ * Similar to sparseFormData, but doesn't compare to an initial state
+ * @param control - The FormGroup or FormArray to clean.
+ * @returns A cleaned object with non-empty values.
+ */
+declare function cleanStringForm<T>(control: AbstractControl): T | undefined;
+
+export { API_URL, AVAILABLE_DOMAINS, AVAILABLE_PERMISSIONS, ActionAccessControlWrapperComponent, AlertComponent, AlertLevel, ApiInterceptor, AppGridComponent, AuthService, AuthenticationGuard, AuthorizationGuard, BASE_URL, BaseInputComponent, BaseRPCModalComponent, CUSTOM_HTTP_REQUEST_OPTIONS, CamelCaseToTitlePipe, CccInputFieldComponent, CompoundResourceComponent, DeleteResourceConfirmationModalComponent, EmptyReadonlyFieldComponent, FRONTEND_LOGIN_PATH, FormStateService, HasPermissionDirective, IDLE_KEEPALIVE_DURATION, IDLE_SESSION_DURATION, IDLE_WARNING_DURATION, IdleService, InputMode, LeavePageConfirmationModalComponent, METHOD_META, NotificationService, PERMISSION_REQUIRED, PaddingElementComponent, RESOURCE_META, ReadPermission, ResourceArrayViewComponent, ResourceCreateComponent, ResourceFieldComponent, ResourceLayoutComponent, ResourceListComponent, ResourceListCreateComponent, ResourceResolverComponent, ResourceStore, ResourceViewComponent, RpcButtonComponent, SESSION_PATH, SidenavComponent, TableButtonComponent, UiCoreService, UpdatePermission, ValueFormatters, actionButtonConfig, actionButtonConfigDefaults, additionalResourceConfig, additionalResourceConfigDefaults, applyFormatting, arrayConfig, arrayConfigDefaults, canDeactivateGuard, civildateCoercion, cleanStringForm, componentConfig, componentConfigDefaults, computedDisplayField, computedDisplayFieldElementDefaults, concatFunctions, createFormGroup, createResourceValidator, defaultEmptyFieldValue, enumeratedConfig, enumeratedConfigDefaults, errorOptions, extractFieldNames, field, fieldElementDefaults, fieldSort, fieldSortDefaults, flattenElements, foreignKeyDefault, foreignKeyDefaultDefaults, formatDateString, generatedNavGroups, generatedNavItems, hyphenConcat, hyphenConcatWithoutResource, hyphenSpaceConcat, hyphenSpaceConcatWithoutResource, isUUID, listViewConfig, listViewConfigDefaults, maxConfigElementRecursionDepth, maxLayoutNestingDepth, metadataTypeCoercion, multiColumnConfig, multiColumnConfigDefaults, noSpaceConcatWithoutResource, nullBooleanConfig, nullBooleanConfigDefaults, padding, paddingElementDefaults, requiredIf, resourceRoutes, resourceValidators, rootConfig, rootConfigDefaults, rpcConfig, rpcConfigDefaults, section, sectionElementDefaults, simpleSlashDateFormatter, singleColumnConfig, singleColumnConfigDefaults, spaceConcat, spaceConcatWithoutResource, spaceHyphenConcat, spaceHyphenConcatWithoutResource, sparseData, sparseFormData, staticDefault, staticDefaultDefaults, switchParams, switchParamsDefaults, validatorsPresent, viewConfig, viewConfigDefaults };
+export type { ActionButtonConfig, ActionButtonConfigOptions, ActionButtonContext$1 as ActionButtonContext, ActionType, AdditionalResourceConfig, AdditionalResourceConfigOptions, Affix, ArrayConfig, AvailableComponents, BaseConfig, BaseConfigOptions, CanComponentDeactivate, CanDeactivateType, ChildResourceConfig, ColSize, ColumnConfig, ComponentConfig, ComponentConfigOptions, ComputedDisplayFieldElement, ComputedDisplayFieldElementOptions, ConcatFn, ConfigElement, ConfigParam, ConfigType, CreateNotificationMessage, CreateOperation, CustomHttpRequestOptions, DataType, DeleteOperation, Domain, DomainPermissions, EnumeratedConfig, EnumeratedConfigOptions, FieldDefault, FieldElement, FieldElementOptions, FieldMeta, FieldName, FieldPointer, FieldSort, FieldSortOptions, ForeignKeyDefault, ForeignKeyDefaultOptions, FormatType, FormatterFn, Link, ListConcatFn, ListViewConfig, ListViewConfigOptions, MenuItem, Meta, Method, MethodMeta, MultiColumnConfig, MultiColumnConfigOptions, NavGroups, NavItem, NotificationMessage, NullBoolean, NullBooleanConfig, NullBooleanConfigOptions, Operation, PaddingElement, PaddingElementOptions, ParentResourceConfig, PatchOperation, Permission, PermissionScope, PristineData, RPCBaseFormData, RPCConfig, RPCConfigOptions, RPCDataType, RPCFieldMeta, RPCPlacement, RPCRecordData, RecordData, Resource, ResourceMap, ResourceMeta, ResourceValidatorFn, RootConfig, RootConfigOptions, RootRouteData, RouteResourceData, RpcMethod, SectionElement, SectionElementOptions, SessionInfo, SingleColumnConfig, SingleColumnConfigOptions, StaticDefault, SwitchConfigParam, SwitchConfigParamOptions, UpdateOperation, ValidDisplayTypes, ValidRPCTypes, ViewConfig, ViewConfigOptions, ViewType, arrayConfigOptions, staticDefaultOptions, switchCase };