spiderly 19.14.0 → 19.16.0

package/agent/docs/backend-testing/index.md

@@ -1,6 +1,6 @@
 ---
 name: backend-testing
-description: Unit-test a Spiderly backend service against an EF Core InMemory database — covers the two InMemory pitfalls that silently corrupt assertions (the change tracker masking a missing SaveChanges, and WithTransactionAsync throwing TransactionIgnoredWarning). Use when writing xUnit/NUnit tests for entity services, business logic, or save/delete hooks against an InMemory DbContext, or when an InMemory-backed test passes/throws for reasons that don't match production.
+description: Unit-test a Spiderly backend service against an EF Core InMemory database — covers the two InMemory pitfalls that silently corrupt assertions (the change tracker masking a missing SaveChanges, and WithTransactionAsync throwing TransactionIgnoredWarning). Use when writing xUnit/NUnit tests for entity services, business logic, or save/delete hooks against an InMemory DbContext, or when an InMemory-backed test passes/throws for reasons that don't match production. Also covers setting the clock a test runs at (a fake `TimeProvider`), which Spiderly's audit stamps and token, API-key and outbox expiry read.
 ---
 
 # Backend Testing (EF Core InMemory)
@@ -63,3 +63,41 @@ Pass a stable `dbName` (e.g. one per test, `Guid.NewGuid().ToString()`) so each
 ## When InMemory isn't enough
 
 InMemory ignores relational constraints (unique indexes, FK cascade, check constraints, `[Required]` at the DB level), provider-specific SQL, and real transaction semantics. If the behavior under test depends on any of those, prefer the **SQLite in-memory** provider (`UseSqlite("DataSource=:memory:")`, keep the connection open) or a disposable real database — don't assert relational guarantees against `UseInMemoryDatabase`.
+
+## Controlling the clock
+
+Spiderly reads the time from the `TimeProvider` registered in the app's container. `AddSpiderly` registers `TimeProvider.System` unless the app registers its own, the same way ASP.NET Core's `AddAuthentication` does. That one clock:
+
+- stamps `CreatedAt` / `ModifiedAt` in `SaveChanges`;
+- sets and checks the expiry of access, refresh and login-verification tokens and the external-login nonce, checks an API key's `ExpiresAt`, and judges a bearer token's lifetime on each request;
+- decides when an outbox row is due for retry, which handled rows retention purges, and how old the health check says the backlog is.
+
+ASP.NET Core's own authentication handlers read the same registration. A test sets the time by registering a fake clock, e.g. `FakeTimeProvider` from the `Microsoft.Extensions.TimeProvider.Testing` package:
+
+```csharp
+using Microsoft.Extensions.Time.Testing;
+
+FakeTimeProvider clock = new(new DateTimeOffset(2030, 1, 1, 12, 0, 0, TimeSpan.Zero));
+services.AddSingleton<TimeProvider>(clock); // before or after AddSpiderly, which adds the system clock only when none is registered
+
+// ... save, issue a token, create an API key ...
+
+clock.Advance(TimeSpan.FromHours(2)); // the fake stands still until the test moves it
+```
+
+In a `WebApplicationFactory`, make that registration in `ConfigureTestServices`. Your own code that needs the current time should take `TimeProvider` in its constructor and call `GetUtcNow()`, so it reads the same clock as the stamps and expiries it compares against. Reading `DateTime.UtcNow` beside it gives the code two clocks, and a test with a fake clock can only control one of them.
+
+A context built with `new`, as in the InMemory examples above, is outside the container and stamps the system clock. Give it the test's clock through its options:
+
+```csharp
+ServiceProvider clockOnly = new ServiceCollection()
+    .AddSingleton<TimeProvider>(clock)
+    .BuildServiceProvider();
+
+MyAppDbContext context = new(new DbContextOptionsBuilder<MyAppDbContext>()
+    .UseInMemoryDatabase(dbName)
+    .UseApplicationServiceProvider(clockOnly)
+    .Options);
+```
+
+The clock does not move a cookie's `Expires`: the client judges that by its own clock, so `CookieManager` keeps setting it from the machine's. Libraries that read the machine's clock themselves, such as Hangfire's schedules, are not moved by it either.

package/agent/docs/background-jobs/index.md

@@ -0,0 +1,87 @@
+---
+name: background-jobs
+description: Write and schedule Hangfire background jobs in a Spiderly app so the container builds every job. Use when adding a job class, enqueueing a job, adding a recurring job, opting in with spiderly.AddJobs, or seeing "is not registered in the container, so it is not built".
+---
+
+# Background Jobs
+
+Spiderly runs background work on Hangfire. Opt in to the job seam and every job is a registered service: a host that
+validates its service graph at boot judges each job's constructor, and Hangfire builds jobs only from the container.
+
+## Opt in
+
+```csharp
+services.AddSpiderly<MyDbContext>(Configuration, spiderly =>
+{
+    // ...
+    spiderly.AddJobs(typeof(Startup).Assembly, typeof(InvoiceExportJob).Assembly);
+});
+```
+
+`AddJobs` registers every non-abstract class implementing `ISpiderlyJob` in the given assemblies (scoped: one instance
+per job run) and replaces Hangfire.NetCore's job activator with `SpiderlyJobActivator`. It works with
+`services.AddHangfire(...)` before or after it. A second call adds assemblies.
+
+## Write a job
+
+```csharp
+using Spiderly.Shared.Jobs;
+
+public class InvoiceExportJob : ISpiderlyJob
+{
+    private readonly IApplicationDbContext _context;
+
+    public InvoiceExportJob(IApplicationDbContext context) => _context = context;
+
+    public async Task ExportAsync(long invoiceId) { /* ... */ }
+}
+```
+
+- Implement `ISpiderlyJob`, take dependencies in the constructor, keep method arguments simple and serializable.
+- No `services.AddScoped<InvoiceExportJob>()` needed: the scan registers it. A registration of your own (another
+  lifetime, a factory) wins over the scan's.
+
+## Schedule it
+
+Use the typed methods, which accept only an `ISpiderlyJob`:
+
+```csharp
+// Injected IBackgroundJobClient
+backgroundJobClient.EnqueueJob<InvoiceExportJob>(job => job.ExportAsync(invoiceId));
+
+// IRecurringJobManager, in the Configure phase
+IRecurringJobManager jobs = app.ApplicationServices.GetRequiredService<IRecurringJobManager>();
+jobs.AddOrUpdateJob<InvoiceExportJob>("invoice-export-nightly", job => job.ExportAllAsync(), "0 2 * * *",
+    new RecurringJobOptions { TimeZone = TimeZoneInfo.Utc });
+```
+
+Do not schedule with Hangfire's `Enqueue<T>` / `AddOrUpdate<T>`: they accept any type, so an unmarked job compiles,
+and the activator refuses it when it runs. An app can ban them with a banned-symbols analyzer to make that a compile
+error.
+
+## What fails where
+
+| Mistake | Where it fails |
+| --- | --- |
+| Job class without `ISpiderlyJob` scheduled through the typed methods | Compile error |
+| Job scheduled through Hangfire's own API, never registered | When it runs: `The Hangfire job '...' is not registered in the container, so it is not built.` |
+| Job's constructor needs a service nobody registered | At boot when the host validates its graph (`ValidateOnBuild`), else when it runs |
+
+## Spiderly's own jobs
+
+`AddOutbox<TOutbox>()` registers the dispatcher, retention and health jobs that `app.SpiderlyUseOutboxRecurringJob<TOutbox>()`
+schedules; `AddNotifications(...)` registers `NotificationDeliveryJob`. They are registered whether or not you call
+`AddJobs`. `SpiderlyUseOutboxRecurringJob` schedules through the container's `IRecurringJobManager`, so it needs
+`services.AddHangfire(...)`.
+
+## Generic jobs
+
+A marked open generic class (`ImportJob<TSource> : ISpiderlyJob`) is registered as an open generic. The container
+cannot validate an open generic registration at boot, so also register each closed form you schedule
+(`services.AddScoped<ImportJob<CsvSource>>()`) to have it judged there.
+
+## Testing
+
+A job is a plain class: construct it with its dependencies and call its method. To test what code schedules, pass a fake
+`IBackgroundJobClient` / `IRecurringJobManager` that records the `Job` it is handed (`job.Type`, `job.Method`,
+`job.Args`).

package/agent/docs/frontend-localization/index.md

@@ -1,33 +1,46 @@
 ---
 name: frontend-localization
-description: How Spiderly localizes Angular admin-panel UI strings — labels, buttons, menu items, validation messages, any user-facing text. Spiderly uses Transloco with flat assets/i18n/{lang}.json files loaded by SpiderlyTranslocoLoader. Use whenever you add or translate a UI string, hit a raw translation key rendering on screen, set up or change languages (provideTransloco / availableLangs), use translocoService.translate or the *transloco template directive, run i18n:extract, or wonder how form labels get auto-translated. For .NET backend strings (error messages, Excel names, IStringLocalizer), use the backend-localization skill instead.
+description: How Spiderly localizes Angular admin-panel UI strings — labels, buttons, menu items, validation messages, any user-facing text. Spiderly uses Transloco with flat assets/i18n/{lang}.json files imported into the build by the app's ImportedTranslocoLoader. Use whenever you add or translate a UI string, hit a raw translation key rendering on screen, set up or change languages (provideTransloco / availableLangs), use translocoService.translate or the *transloco template directive, run i18n:extract, or wonder how form labels get auto-translated. For .NET backend strings (error messages, Excel names, IStringLocalizer), use the backend-localization skill instead.
 ---
 
 # Frontend Localization
 
-The Spiderly Angular admin panel localizes every user-facing string through **Transloco**. Translation files are flat key→value JSON, one per language, served as static assets and loaded over HTTP at runtime — there is no compile-time embedding. Never hardcode user-facing English in a template; route it through a translation key so it localizes with the rest of the panel (e.g. a PACMS app runs entirely in Serbian).
+The Spiderly Angular admin panel localizes every user-facing string through **Transloco**. Translation files are flat key→value JSON, one per language, imported into the build: each becomes a content-hashed chunk that ships with the code reading its keys, loaded when Transloco first needs the language. Never hardcode user-facing English in a template; route it through a translation key so it localizes with the rest of the panel (e.g. a PACMS app runs entirely in Serbian).
 
 This is a **separate system from the backend**: a string shown by the API (a `BusinessException` message) is translated on the .NET side via `IStringLocalizer` (see the **backend-localization** skill); a string rendered by the admin UI is translated here.
 
-## Setup (`app.config.ts`)
+## Setup (`translations.ts`)
 
-Transloco is registered in the app's `ApplicationConfig` with Spiderly's loader:
+`spiderly init` writes the loader and the Transloco config to `src/app/business/services/translations.ts`; `app.config.ts` only calls `provideTranslations()`:
 
 ```typescript
-provideTransloco({
-  config: {
-    availableLangs: ['sr-Latn-RS'],   // every language you ship a JSON file for
-    defaultLang: 'sr-Latn-RS',
-    reRenderOnLangChange: false,       // true only if you let users switch language at runtime
-  },
-  loader: SpiderlyTranslocoLoader,     // from the `spiderly` package
-}),
+@Injectable({ providedIn: 'root' })
+export class ImportedTranslocoLoader implements TranslocoLoader {
+  getTranslation(lang: string): Promise<Translation> {
+    return import(`../../../assets/i18n/${lang}.json`).then((file) => file.default);
+  }
+}
+
+export function provideTranslations() {
+  return provideTransloco({
+    config: {
+      availableLangs: ['en'],          // every language you ship a JSON file for
+      defaultLang: 'en',
+      reRenderOnLangChange: true,      // false if users never switch language at runtime
+    },
+    loader: ImportedTranslocoLoader,
+  });
+}
 ```
 
-`SpiderlyTranslocoLoader` fetches `${ConfigService.frontendUrl}/assets/i18n/{lang}.json`. So:
+So:
 
 - Files live in **`src/assets/i18n/{lang}.json`**, named **exactly** after a `lang` in `availableLangs` (e.g. `sr-Latn-RS.json`, `en.json`).
-- They must be deployed as static assets (they're requested over HTTP, not bundled). They already are under `src/assets`, but a build that drops the `assets/` glob will 404 the translations and every key renders raw.
+- The build bundles them; they are **not** published as `/assets/i18n/*.json`. `angular.json` leaves them out of the assets glob (`"ignore": ["i18n/**"]`), so nothing can fetch them back.
+
+### Why imported, not fetched
+
+A file at an unchanging URL outlives a deploy in the browser cache. A server that sends no `Cache-Control` lets the browser guess a freshness lifetime (Chromium: a tenth of the time since `Last-Modified`), and a hard reload does not help: it bypasses the cache only for requests made before the page's load event, and Transloco asks for the file after it. The user then runs the new code against the old file, and every key added by the deploy renders raw. An imported file gets a new URL whenever its content changes, so this cannot happen. Spiderly's former `SpiderlyTranslocoLoader` fetched `${frontendUrl}/assets/i18n/{lang}.json` and was removed for this reason.
 
 ## File format
 
@@ -111,8 +124,8 @@ If you build a reusable control/component with text baked into its template, rou
 ## Gotchas
 
 - **A missing key renders the raw key.** Transloco's default `missingHandler` returns the key string, so a typo'd or unseeded key leaks the identifier (e.g. `InvalidSKU`) onto the screen instead of erroring. Treat a raw-key sighting as a missing-translation bug. Keep keys in sync across all `{lang}.json` files and lean on `i18n:extract`.
-- **Filename must match `availableLangs`.** `SpiderlyTranslocoLoader` requests `{lang}.json` for the active lang; a mismatch (`sr.json` while `availableLangs` is `['sr-Latn-RS']`) 404s and the whole file falls through to raw keys.
-- **Translations are fetched, not bundled.** They load over HTTP from `frontendUrl/assets/i18n/`. A misconfigured `frontendUrl` (in `ConfigService`) or a build that strips the `assets` glob breaks all translations at once — a useful first thing to check when *everything* shows raw keys.
+- **Filename must match `availableLangs`.** `ImportedTranslocoLoader` imports `{lang}.json` for the active lang; a mismatch (`sr.json` while `availableLangs` is `['sr-Latn-RS']`) fails the import and the whole file falls through to raw keys.
+- **New keys render raw for some users right after a deploy, and a hard reload does not fix it?** Something still fetches the translations from a URL that survives deploys (see *Why imported, not fetched*). Check that `app.config.ts` calls `provideTranslations()` and that the network panel shows no `/assets/i18n/` request.
 - **`reRenderOnLangChange: false`** means a runtime language switch won't re-render already-rendered text. Set it to `true` only if you actually offer in-session language switching.
 
 ## Backend strings are a separate system

package/agent/skills/deployment/SKILL.md

@@ -183,13 +183,16 @@ HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
     root * /srv
     encode zstd gzip
 
-    @hashedAssets {
-        path_regexp hashed \.[a-f0-9]{8,}\.(js|css|woff2?|ttf|otf|svg|png|jpg|jpeg|webp|ico)$
+    # Content-hashed build output (main-QCWZPP5O.js, media/primeicons-4GST5W3O.woff2) that exists
+    # on disk; a missing chunk falls back to index.html and must not be marked immutable.
+    @hashed {
+        path_regexp ^/(media/)?[^/]+-[A-Z0-9]{8}\.[a-z0-9]+$
+        file
     }
-    header @hashedAssets Cache-Control "public, max-age=31536000, immutable"
+    header @hashed Cache-Control "public, max-age=31536000, immutable"
 
-    @indexHtml path /index.html
-    header @indexHtml Cache-Control "no-cache, no-store, must-revalidate"
+    # Everything else (index.html under every route, /assets/*) is revalidated on every use.
+    header ?Cache-Control "no-cache"
 
     try_files {path} /index.html
     file_server
@@ -198,6 +201,8 @@ HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
 
 The `try_files {path} /index.html` line is the SPA fallback that lets the Angular router handle deep links.
 
+Two details in the cache rules matter. Angular's esbuild builder names hashed files `name-HASH.js` (eight uppercase letters and digits), so a `\.[a-f0-9]{8,}\.js` pattern written for the old webpack names matches nothing. And `header` runs before `try_files`, so a `path /index.html` matcher never sees a navigation to `/` or `/orders`: the `?Cache-Control` default covers them. Without any `Cache-Control` a browser guesses a freshness lifetime (Chromium: a tenth of the time since `Last-Modified`) and can open the app from a pre-deploy `index.html`.
+
 **Lockfile gotcha:** `npm ci` requires `package.json` and `package-lock.json` to be in sync. If a stale dev-dep pins an older Angular major as a peer (e.g. `@jsverse/transloco-keys-manager` 5.x pins Angular 17 while your project is on Angular 19), `npm ci` fails. Bump the dev-dep to the matching major (e.g. `transloco-keys-manager` 6.x for Angular 19) rather than reaching for `--legacy-peer-deps`.
 
 ## Terraform layout
@@ -406,7 +411,7 @@ Postgres data lives in a Docker volume on a single VPS — disk failure, acciden
 - **CORS `FrontendUrl`.** The backend's `AppSettings__Spiderly.Shared__FrontendUrl` must point to the admin subdomain, not a build-preview URL. Update it when you cut over from staging hosting.
 - **First deploy ordering.** The backend compose references `${ADMIN_IMAGE}`. On a fresh VPS, that image must exist in GHCR before backend deploys, or the admin service definition fails to pull. Push admin first, or run the admin workflow once before the first backend deploy.
 - **`docker compose up -d` scoping.** Always scope to the services you're updating: `docker compose up -d backend caddy` for backend deploys, `docker compose up -d admin` for admin deploys. Unscoped `up -d` bounces every service that's currently down or has a config change — including admin and postgres on a backend-only commit. The healthcheck-gated `depends_on` makes the unscoped form *safe* but not *desirable*.
-- **Static assets caching.** Hashed Angular bundles (e.g. `main.abc123.js`) can be cached forever; `index.html` must never cache, or users will get a stale shell after a deploy. The Caddyfile in this skill already handles both cases.
+- **Static assets caching.** Hashed Angular bundles (e.g. `main-QCWZPP5O.js`) can be cached forever; `index.html` and every other unhashed file must be revalidated on each use, or users get a stale shell after a deploy. The Caddyfile in this skill handles both, and translations are imported into the build rather than served from `/assets/i18n/` (see the **frontend-localization** doc).
 - **`tls_private_key` lives in Terraform state in cleartext.** R2 encryption-at-rest is bucket-level; anyone with R2 API access (or a leaked state file) can read the key. Scope the R2 token tightly, audit who can pull state, and never copy `terraform.tfstate` to laptops or shared drives. Rotating the cert means a fresh `terraform apply` followed by re-pasting the new outputs into GitHub Secrets — plan a maintenance window. Add `lifecycle { prevent_destroy = true }` to the `tls_private_key` and `cloudflare_origin_ca_certificate` resources so accidental config changes can't trigger a silent rotation. Also add `ignore_changes = [hostnames, csr]` on the cert — Cloudflare normalizes hostname/CSR ordering server-side, otherwise every plan would show a phantom recreate.
 - **Postgres data on Docker named volumes is not durable across server replacement.** If the VPS itself is Terraform-managed (`hcloud_server`) and gets recreated for any reason — image change, server_type change, accidental destroy — the local Docker named volume `postgres_data` goes with it. Add `lifecycle { prevent_destroy = true }` to the `hcloud_server` resource. For genuine durability, attach an `hcloud_volume` and bind-mount it into postgres (`/var/lib/postgresql` on the 18+ image); volumes survive server destruction and snapshot independently.
 - **Cloudflare in front of Vercel must stay "DNS only".** When the Next.js storefront (or a Vercel-hosted admin) deploys to Vercel and DNS is on Cloudflare, those records must be **DNS only** (grey cloud), not proxied. Vercel terminates TLS and runs its own edge — CDN, image optimization, ISR, PPR — so adding the Cloudflare proxy on top breaks the TLS handshake and double-caches/conflicts with Vercel's edge features. Cloudflare's WAF/cache/analytics/Turnstile belong on the **Hetzner-served** records (`api.*`, `admin.*`) where the orange cloud stays on. If you want Cloudflare features in front of Vercel anyway, that's an advanced setup ("Full (strict)" SSL + custom hostnames) that Vercel does not officially recommend.

package/fesm2022/spiderly.mjs

@@ -8110,24 +8110,6 @@ function authInitializer(authService, platformId) {
     };
 }
 
-class SpiderlyTranslocoLoader {
-    constructor(http, config) {
-        this.http = http;
-        this.config = config;
-    }
-    getTranslation(lang) {
-        return this.http.get(`${this.config.frontendUrl}/assets/i18n/${lang}.json`);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyTranslocoLoader, deps: [{ token: i1$2.HttpClient }, { token: ConfigServiceBase }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyTranslocoLoader, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: SpiderlyTranslocoLoader, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: ConfigServiceBase }] });
-
 class SpiderlyTemplateTypeDirective {
     static ngTemplateContextGuard(dir, ctx) {
         return true;
@@ -8152,5 +8134,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ALLOWED_OPERATORS, Action, AllClickEvent, ApiErrorCodes, ApiSecurityService, AppSidebarComponent, AuthCardComponent, AuthGuard, AuthResult, AuthResultWithCookies, AuthServiceBase, BaseAutocompleteControl, BaseControl, BaseDropdownControl, BaseEntity, BaseFormComponent, BaseFormService, CardSkeletonComponent, Codebook, Column, ConfigServiceBase, DEFAULT_EXTERNAL_PROVIDER_ICONS, DEFAULT_OPERATOR, ExternalLoginComponent, ExternalProvider, ExternalProviderPublic, Filter, FilterRule, FilterSortMeta, IndexCardComponent, InfoCardComponent, InitCompanyAuthDialogDetails, InitTopBarData, IsAuthorizedForSaveEvent, LastMenuIconIndexClicked, LayoutServiceBase, LazyLoadSelectedIdsResult, Login, LoginVerificationComponent, LoginVerificationToken, MatchModeCodes, MenuChangeEvent, MenuitemComponent, Namebook, NotAuthGuard, NotFoundComponent, PROPS_KEY, PaginatedResult, PanelBodyComponent, PanelFooterComponent, PanelHeaderComponent, PrimengOption, ProfileAvatarComponent, ReflectProp, RefreshTokenRequest, RequiredComponent, RowClickEvent, SecurityPermissionCodes, SendLoginVerificationEmailResult, SideMenuTopBarComponent, SidebarMenuComponent, SimpleSaveResult, SpiderlyAutocompleteComponent, SpiderlyButtonBaseComponent, SpiderlyButtonComponent, SpiderlyCalendarComponent, SpiderlyCardComponent, SpiderlyCellTemplateDirective, SpiderlyCheckboxComponent, SpiderlyColorPickerComponent, SpiderlyControlsModule, SpiderlyDataTableActionsDirective, SpiderlyDataTableComponent, SpiderlyDataViewComponent, SpiderlyDeleteConfirmationComponent, SpiderlyDropdownComponent, SpiderlyEditorComponent, SpiderlyErrorHandler, SpiderlyFileComponent, SpiderlyFileSelectEvent, SpiderlyFilterBarComponent, SpiderlyFilterTemplateDirective, SpiderlyFormArray, SpiderlyFormControl, SpiderlyFormGroup, SpiderlyLayoutComponent, SpiderlyLoginComponent, SpiderlyMarkdownComponent, SpiderlyMessageService, SpiderlyMultiAutocompleteComponent, SpiderlyMultiSelectComponent, SpiderlyNumberComponent, SpiderlyOverflowTitleDirective, SpiderlyPanelComponent, SpiderlyPanelsModule, SpiderlyPasswordComponent, SpiderlyReturnButtonComponent, SpiderlySplitButtonComponent, SpiderlyTab, SpiderlyTemplateTypeDirective, SpiderlyTextareaComponent, SpiderlyTextboxComponent, SpiderlyTranslocoLoader, TopBarComponent, UserBase, UserRole, ValidatorAbstractService, VerificationTokenRequest, VerificationTypeCodes, VerificationWrapperComponent, adjustColor, authInitializer, booleanFilter, capitalizeFirstChar, createFilterStore, dateFilter, deleteAction, exportListToExcel, firstCharToUpper, foldForSearch, getFileNameFromContentDisposition, getFilterOptions, getHtmlImgDisplayString64, getImageDimensions, getMimeTypeForFileName, getMonth, getParentUrl, getPrimengAutocompleteCodebookOptions, getPrimengAutocompleteNamebookOptions, getPrimengDropdownCodebookOptions, getPrimengDropdownNamebookOptions, getPrimengNamebookOptions, httpLoadingInterceptor, isExcelFileType, isFileImageType, isNullOrEmpty, jsonHttpInterceptor, jwtInterceptor, kebabToTitleCase, nameOf, nameof, numberFilter, operatorOptionsForKind, parseDateOnlyLocal, pushAction, saveResponseAsFile, scrollElementIntoViewIfAboveViewport, selectedTab, singleOrDefault, splitPascalCase, textFilter, toCommaSeparatedString, unauthorizedInterceptor, validatePrecisionScale };
+export { ALLOWED_OPERATORS, Action, AllClickEvent, ApiErrorCodes, ApiSecurityService, AppSidebarComponent, AuthCardComponent, AuthGuard, AuthResult, AuthResultWithCookies, AuthServiceBase, BaseAutocompleteControl, BaseControl, BaseDropdownControl, BaseEntity, BaseFormComponent, BaseFormService, CardSkeletonComponent, Codebook, Column, ConfigServiceBase, DEFAULT_EXTERNAL_PROVIDER_ICONS, DEFAULT_OPERATOR, ExternalLoginComponent, ExternalProvider, ExternalProviderPublic, Filter, FilterRule, FilterSortMeta, IndexCardComponent, InfoCardComponent, InitCompanyAuthDialogDetails, InitTopBarData, IsAuthorizedForSaveEvent, LastMenuIconIndexClicked, LayoutServiceBase, LazyLoadSelectedIdsResult, Login, LoginVerificationComponent, LoginVerificationToken, MatchModeCodes, MenuChangeEvent, MenuitemComponent, Namebook, NotAuthGuard, NotFoundComponent, PROPS_KEY, PaginatedResult, PanelBodyComponent, PanelFooterComponent, PanelHeaderComponent, PrimengOption, ProfileAvatarComponent, ReflectProp, RefreshTokenRequest, RequiredComponent, RowClickEvent, SecurityPermissionCodes, SendLoginVerificationEmailResult, SideMenuTopBarComponent, SidebarMenuComponent, SimpleSaveResult, SpiderlyAutocompleteComponent, SpiderlyButtonBaseComponent, SpiderlyButtonComponent, SpiderlyCalendarComponent, SpiderlyCardComponent, SpiderlyCellTemplateDirective, SpiderlyCheckboxComponent, SpiderlyColorPickerComponent, SpiderlyControlsModule, SpiderlyDataTableActionsDirective, SpiderlyDataTableComponent, SpiderlyDataViewComponent, SpiderlyDeleteConfirmationComponent, SpiderlyDropdownComponent, SpiderlyEditorComponent, SpiderlyErrorHandler, SpiderlyFileComponent, SpiderlyFileSelectEvent, SpiderlyFilterBarComponent, SpiderlyFilterTemplateDirective, SpiderlyFormArray, SpiderlyFormControl, SpiderlyFormGroup, SpiderlyLayoutComponent, SpiderlyLoginComponent, SpiderlyMarkdownComponent, SpiderlyMessageService, SpiderlyMultiAutocompleteComponent, SpiderlyMultiSelectComponent, SpiderlyNumberComponent, SpiderlyOverflowTitleDirective, SpiderlyPanelComponent, SpiderlyPanelsModule, SpiderlyPasswordComponent, SpiderlyReturnButtonComponent, SpiderlySplitButtonComponent, SpiderlyTab, SpiderlyTemplateTypeDirective, SpiderlyTextareaComponent, SpiderlyTextboxComponent, TopBarComponent, UserBase, UserRole, ValidatorAbstractService, VerificationTokenRequest, VerificationTypeCodes, VerificationWrapperComponent, adjustColor, authInitializer, booleanFilter, capitalizeFirstChar, createFilterStore, dateFilter, deleteAction, exportListToExcel, firstCharToUpper, foldForSearch, getFileNameFromContentDisposition, getFilterOptions, getHtmlImgDisplayString64, getImageDimensions, getMimeTypeForFileName, getMonth, getParentUrl, getPrimengAutocompleteCodebookOptions, getPrimengAutocompleteNamebookOptions, getPrimengDropdownCodebookOptions, getPrimengDropdownNamebookOptions, getPrimengNamebookOptions, httpLoadingInterceptor, isExcelFileType, isFileImageType, isNullOrEmpty, jsonHttpInterceptor, jwtInterceptor, kebabToTitleCase, nameOf, nameof, numberFilter, operatorOptionsForKind, parseDateOnlyLocal, pushAction, saveResponseAsFile, scrollElementIntoViewIfAboveViewport, selectedTab, singleOrDefault, splitPascalCase, textFilter, toCommaSeparatedString, unauthorizedInterceptor, validatePrecisionScale };
 //# sourceMappingURL=spiderly.mjs.map