open-index/open-npm huggingface dataset:
npm package: @syncu.be/lb-connector-firebase
Description: Loopback Connector for firebase NoSql Database. LoopBack is an API Mgmt/MBaas platform built on top of express by Strongloop. It supports the notion of connectors to connect to databases, restful web services, soap web services etc. This project is a conn
Author: Syncube Commerce / Amol Kulkarni
Latest version: 0.6.4

## lb-connector-firebase

Firebase connector for loopback v3

## Installation of the connector

You’re going to add a MongoDB data source in addition to the MySQL data source created in Connect your API to a data source.

    $ lb datasource

When prompted, respond as follows:

    ? Enter the data-source name: firebase
    ? Select the connector for firebase: Other
    ? Enter the connector's module name: @syncu.be/lb-connector-firebase
    ? Install lb-connector-firebase (Y/n): Y

Add to your datasources.json file the following:

    "firebase": {
        "name": "firebase",
        "url": "https://<% YOUR FIREBASE PROJECT ID %>.firebaseio.com",
        "token": "<% YOUR FIREBASE PROJECT TOKEN %>"
    }

Done!

## Customizing Firebase configuration for tests/examples

The .loopbackrc file is in JSON format, for example:

    {
        "test": {
            "firebase": {
                "url": "<firebase_url>",
                "token": "<security_token>"
            }
        }
    }

## Running tests

 * npm test - To run the test
 * npm run coverage - To find the code coverage

## Release notes
 Yet to be Released officially


## Credits

Inspired by https://github.com/Synerzip/loopback-connector-firebase

Actually, PUT and DELETE queries were not working for our project so we decided to fork Synerzip's connector and maintain it in actual state.
npm package: @syncular/client-plugin-offline-auth
Description: Provider-agnostic offline auth primitives for Syncular clients (JS runtimes)
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/client-plugin-offline-auth

Provider-agnostic offline auth primitives for JavaScript runtimes.

This package intentionally does **not** implement OAuth/provider flows. It gives you reusable building blocks for:

- Offline session + identity cache shape
- JWT/expiry checks
- Offline subject resolution (online session -> offline identity -> last actor)
- Bearer token/auth lifecycle bridge for Syncular transports
- Local lock policy state machine (framework-agnostic)

Behavior defaults are fail-closed:

- Calling `persistOnlineSession({ session: null, ... })` clears cached session, cached offline identity, and last actor.
- Lock APIs expose `forceUnlock()` for explicit unlock bypass and `attemptUnlock(verify)` / `attemptUnlockAsync(verify)` for app-managed PIN/passcode checks.

## Install

```bash
npm install @syncular/client-plugin-offline-auth
```

## JavaScript primitives

```ts
import {
  createMemoryStorageAdapter,
  loadOfflineAuthState,
  persistOnlineSession,
  resolveOfflineAuthSubject,
} from '@syncular/client-plugin-offline-auth';

const storage = createMemoryStorageAdapter();
const state = await loadOfflineAuthState({
  storage,
  codec: {
    parseSession: (value) => (typeof value === 'object' && value ? value : null),
    parseIdentity: (value) =>
      typeof value === 'object' && value && 'actorId' in value ? value : null,
  },
});

const next = persistOnlineSession({
  state,
  session,
  getSessionActorId: (s) => s.user.id,
  getExpiresAtMs: (s) => s.expiresAtMs,
  deriveIdentity: (s) => ({ actorId: s.user.id, teamId: s.teamId }),
});

const subject = resolveOfflineAuthSubject({
  state: next,
  getSessionActorId: (s) => s.user.id,
  getSessionTeamId: (s) => s.teamId,
});
```

## Transport token/auth lifecycle bridge

```ts
import { createTokenLifecycleBridge } from '@syncular/client-plugin-offline-auth';

const tokenBridge = createTokenLifecycleBridge({
  resolveToken: async () => authState.state.session?.value.sessionJwt ?? null,
});

const transport = createWebSocketTransport({
  baseUrl: '/api',
  getHeaders: tokenBridge.getAuthorizationHeaders,
  getRealtimeParams: tokenBridge.getRealtimeParams,
  authLifecycle: tokenBridge.authLifecycle,
});
```

For React hooks, install and import from `@syncular/client-plugin-offline-auth-react`.

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/client-plugin-offline-auth-react
Description: React hooks for Syncular offline auth client primitives
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/client-plugin-offline-auth-react

React hooks for `@syncular/client-plugin-offline-auth`.

Use this package when your app wants provider-agnostic offline auth state persistence and local lock policy wiring through React hooks.

## Install

```bash
npm install @syncular/client-plugin-offline-auth @syncular/client-plugin-offline-auth-react
```

## Example

```ts
import {
  useOfflineAuthState,
  useOfflineLockPolicy,
} from '@syncular/client-plugin-offline-auth-react';

const authState = useOfflineAuthState({
  storage,
  codec,
});

const lock = useOfflineLockPolicy({
  lockOnMount: true,
  idleTimeoutMs: 5 * 60_000,
  trackWindowActivity: true,
});

const result = await lock.attemptUnlockAsync(async () => verifyPinLocally());
if (result.ok) {
  // unlocked
}
```

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/client-plugin-yjs
Description: Yjs CRDT plugin primitives for Syncular client integration
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/client-plugin-yjs

Yjs-first CRDT plugin for Syncular client integration.

Implemented:
- Rule-based field mapping: `{ table, field, stateColumn }`.
- Kind-aware materialization: `text`, `xml-fragment`, `prosemirror`.
- Stable payload envelope key: `__yjs`.
- `beforePush` transformation:
  - Applies Yjs update envelopes to local state.
  - Materializes projection field values.
  - Stores canonical snapshot state in `stateColumn`.
  - Strips the envelope key by default to keep payload DB-safe.
  - Can keep envelope for server-side CRDT merge via `stripEnvelopeBeforePush: false`.
- `afterPull` transformation for snapshot and incremental rows.
- `beforeApplyWsChanges` transformation for websocket inline rows.
- Helpers:
  - `buildYjsTextUpdate`
  - `applyYjsTextUpdates`

## Envelope Format

Outgoing payload example:

```ts
{
  __yjs: {
    content: {
      updateId: "upd-123",
      updateBase64: "<base64-encoded-yjs-update>"
    }
  }
}
```

The plugin converts this to:

```ts
{
  content: "materialized text",
  content_yjs_state: "<base64-encoded-yjs-snapshot>"
}
```

## Example

```ts
import { createYjsClientPlugin } from '@syncular/client-plugin-yjs';

const yjs = createYjsClientPlugin({
  rules: [
    {
      table: 'tasks',
      field: 'content',
      stateColumn: 'content_yjs_state',
    },
  ],
});
```
npm package: @syncular/client-react
Description: React hooks and bindings for the Syncular client
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/client-react

React bindings for the Syncular client. Provides a typed `SyncProvider` and hooks like `useSyncQuery`, `useSyncSelector`, `useMutations`, and presence helpers.

## Install

```bash
npm install @syncular/client-react react
```

## Usage

```tsx
import { createSyncularReact } from '@syncular/client-react';

const { SyncProvider, useSyncQuery, useMutations } = createSyncularReact<MyDb>();
```

## Documentation

- React SDK: https://syncular.dev/docs/client-sdk/react
- Client setup: https://syncular.dev/docs/build/client-setup
- Presence: https://syncular.dev/docs/build/presence

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/dialect-bun-sqlite
Description: Bun SQLite dialect for the Syncular client
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/dialect-bun-sqlite

Bun SQLite Kysely dialect for Syncular clients and scripts.

## Install

```bash
npm install @syncular/dialect-bun-sqlite
```

## Usage

```ts
import { createDatabase } from '@syncular/core';
import { createBunSqliteDialect } from '@syncular/dialect-bun-sqlite';

const db = createDatabase<MyDb>({
  dialect: createBunSqliteDialect({ path: './app.sqlite' }),
  family: 'sqlite',
});
```

## Documentation

- Dialect selection: https://syncular.dev/docs/introduction/installation#client-database-dialects

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs may change between releases.
npm package: @syncular/dialect-electron-sqlite
Description: Electron IPC SQLite dialect for the Syncular client
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/dialect-electron-sqlite

Electron IPC SQLite Kysely dialect for renderer processes.

This dialect lets renderer code use a normal Kysely API while executing SQL in the Electron main process through a preload bridge.

## Install

```bash
npm install @syncular/dialect-electron-sqlite
```

## Usage

```ts
import { createDatabase } from '@syncular/core';
import { createElectronSqliteDialectFromWindow } from '@syncular/dialect-electron-sqlite';

// Uses window.electronAPI.sqlite by default (bridgeKey: "sqlite")
const db = createDatabase<MyDb>({
  dialect: createElectronSqliteDialectFromWindow(),
  family: 'sqlite',
});
```

## Documentation

- Dialect selection: https://syncular.dev/docs/introduction/installation#client-database-dialects

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs may change between releases.
npm package: @syncular/dialect-react-native-nitro-sqlite
Description: React Native Nitro SQLite dialect for the Syncular client
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/dialect-react-native-nitro-sqlite

React Native Nitro SQLite Kysely dialect.

## Install

```bash
npm install @syncular/dialect-react-native-nitro-sqlite
```

## Usage

```ts
import { open } from 'react-native-nitro-sqlite';
import { createDatabase } from '@syncular/core';
import { createNitroSqliteDialect } from '@syncular/dialect-react-native-nitro-sqlite';

const db = createDatabase<MyDb>({
  dialect: createNitroSqliteDialect({ name: 'app.db', open }),
  family: 'sqlite',
});
```

## Documentation

- Dialect selection: https://syncular.dev/docs/introduction/installation#client-database-dialects

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs may change between releases.
npm package: @syncular/dialect-wa-sqlite
Description: WA-SQLite (WASM) dialect for the Syncular client
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/dialect-wa-sqlite

wa-sqlite (WASM) Kysely dialect for browser SQLite.

## Install

```bash
npm install @syncular/dialect-wa-sqlite
```

## Usage

```ts
import { createDatabase } from '@syncular/core';
import { createWaSqliteDialect } from '@syncular/dialect-wa-sqlite';

const db = createDatabase<MyDb>({
  dialect: createWaSqliteDialect({ fileName: 'app.sqlite' }),
  family: 'sqlite',
});
```

## Documentation

- Dialect selection: https://syncular.dev/docs/introduction/installation#client-database-dialects

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs may change between releases.
npm package: @syncular/migrations
Description: Database migration utilities for Syncular
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/migrations

Versioned migration utilities for Syncular apps. Provides `defineMigrations()` and `runMigrations()` with migration tracking and optional generated checksum validation (plus an optional reset strategy for client DBs).

## Install

```bash
npm install @syncular/migrations
```

## Usage

```ts
import {
  createMigrationTrackingTableName,
  runMigrations,
} from '@syncular/migrations';
import { migrations } from './migrations';
import { migrationChecksums } from './migrations.checksums.generated';

await runMigrations({
  db,
  migrations,
  checksums: migrationChecksums,
  trackingTable: createMigrationTrackingTableName(['my_app', 'client']),
});
```

Define the migrations in a separate source module, for example:

```ts
// migrations.ts
import { defineMigrations } from '@syncular/migrations';

export const migrations = defineMigrations({
  v1: {
    up: async (db) => {
      await db.schema.createTable('tasks').addColumn('id', 'text').execute();
    },
    down: async (db) => {
      await db.schema.dropTable('tasks').ifExists().execute();
    },
  },
  v2: {
    up: async (db) => {
      await db.schema
        .alterTable('tasks')
        .addColumn('done', 'integer')
        .execute();
    },
    down: async (db) => {
      await db.schema.alterTable('tasks').dropColumn('done').execute();
    },
  },
});
```

Use `createMigrationTrackingTableName(...)` whenever you want a custom table.
It keeps names lowercase, predictable, and consistently suffixed with
`migration_state`.

Use `checksum: 'deterministic'` for migrations that have a generated checksum
manifest. Generate that manifest with `@syncular/typegen`; `runMigrations`
compares the stored checksum against the generated SQL-trace checksum at
runtime.

Use `checksum: 'disabled'` for migrations that cannot be replayed safely during
build-time checksum generation. Disabled migrations still track
version/application state, but they skip checksum creation and mismatch checks.

## Documentation

- Schema migrations: https://syncular.dev/docs/build/migrations

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/observability-sentry
Description: Sentry adapters for Syncular telemetry
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/observability-sentry

Sentry adapter for Syncular telemetry (`SyncTelemetry`): logs, traces, metrics, and exceptions.

## Install

```bash
npm install @syncular/observability-sentry
```

## Usage

```ts
import { createBrowserSentryTelemetry } from '@syncular/observability-sentry';

const telemetry = createBrowserSentryTelemetry();
```

## Documentation

- Observability guide: https://syncular.dev/docs/build/observability

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/relay
Description: Edge relay for Syncular distributed sync
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/relay

Edge relay server for Syncular.

A relay acts as a local sync server for nearby clients and forwards commits to a main server when online. Useful for intermittent connectivity (branch offices, field devices, edge deployments).

## Install

```bash
npm install @syncular/relay
```

## Usage

```ts
import { createRelayServer } from '@syncular/relay';

const relay = createRelayServer({
  db,
  dialect,
  mainServerTransport,
  mainServerClientId: 'relay-1',
  mainServerActorId: 'relay-service',
  tables: ['tasks'],
  scopes: { project_id: 'acme' },
  handlers,
});

await relay.start();
```

## Documentation

- Relay guide: https://syncular.dev/docs/build/relay

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/server
Description: Server-side sync engine with push/pull, pruning, and snapshot support
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/server

Framework-agnostic server sync engine for Syncular: commit log, push/pull, scopes/subscriptions, snapshots, blobs, pruning/compaction, and proxy support.

Typically used with `@syncular/server-hono` for HTTP routes, WebSocket wake-ups, and the admin console API.

## Install

```bash
npm install @syncular/server
```

## Documentation

- Server setup: https://syncular.dev/docs/build/server-setup
- How sync works: https://syncular.dev/docs/introduction/architecture
- Server overview: https://syncular.dev/docs/server/overview

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/server-dialect-postgres
Description: PostgreSQL dialect for the Syncular server
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/server-dialect-postgres

PostgreSQL dialect for the Syncular server sync schema and query patterns
(commit log, change log, scopes, snapshot chunks, console tables).

Use this when your server is backed by Postgres.

If your runtime is backed by Neon, use `createNeonServerDialect()`. It runs the
same sync SQL behavior, but makes the intended server/runtime pairing explicit in
code and docs.

## Install

```bash
npm install @syncular/server-dialect-postgres
```

## Usage

### Postgres server

```ts
import { ensureSyncSchema } from '@syncular/server';
import { createPostgresServerDialect } from '@syncular/server-dialect-postgres';

const dialect = createPostgresServerDialect();
await ensureSyncSchema(db, dialect);
```

### Neon-backed server

```ts
import { ensureSyncSchema } from '@syncular/server';
import { createNeonServerDialect } from '@syncular/server-dialect-postgres';

const dialect = createNeonServerDialect();
await ensureSyncSchema(db, dialect);
```

### Neon-backed server with umbrella imports

```ts
import { ensureSyncSchema } from 'syncular/server';
import { createNeonServerDialect } from 'syncular/server-dialect-neon';

const dialect = createNeonServerDialect();
await ensureSyncSchema(db, dialect);
```

## Documentation

- Dialects: https://syncular.dev/docs/server/dialects
- Server setup: https://syncular.dev/docs/build/server-setup

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/server-dialect-sqlite
Description: SQLite dialect for the Syncular server
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/server-dialect-sqlite

SQLite dialect for the Syncular server sync schema and query patterns (commit log, change log, scopes, snapshot chunks, console tables).

Commonly used for dev/test setups and for edge deployments that use a SQLite-compatible backend.

## Install

```bash
npm install @syncular/server-dialect-sqlite
```

## Usage

```ts
import { ensureSyncSchema } from '@syncular/server';
import { createSqliteServerDialect } from '@syncular/server-dialect-sqlite';

const dialect = createSqliteServerDialect();
await ensureSyncSchema(db, dialect);
```

## Documentation

- Dialects: https://syncular.dev/docs/server/dialects
- Server setup: https://syncular.dev/docs/build/server-setup

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/server-hono
Description: Hono adapter for the Syncular server with OpenAPI support
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/server-hono

Hono adapter for `@syncular/server`. Provides push/pull routes, WebSocket wake-ups and presence, blob routes, console API routes, and OpenAPI support.

## Install

```bash
npm install @syncular/server-hono hono
```

If you want to serve the Console UI with `mountConsoleUi`, also install:

```bash
npm install @syncular/console
```

## Documentation

- Hono adapter: https://syncular.dev/docs/server/hono-adapter
- API reference: https://syncular.dev/docs/api
- Operations & console: https://syncular.dev/docs/build/operations

## Sync CORS

`createSyncRoutes` and `createSyncServer` accept a simple Hono-style sync CORS config.
The common case is just an origin string:

```ts
const { syncRoutes } = createSyncServer({
  db,
  dialect,
  sync,
  routes: {
    cors: 'https://app.example.com',
  },
});
```

Or use an object when you need extra exposed/allowed headers:

```ts
const { syncRoutes } = createSyncServer({
  db,
  dialect,
  sync,
  routes: {
    cors: {
      origin: ['https://app.example.com'],
      allowHeaders: ['x-custom-header'],
    },
  },
});
```

Use a function origin only when you need dynamic policy logic.
When `routes.websocket.allowedOrigins` is unset, realtime websocket upgrades
inherit static `routes.cors` origins automatically.

## OpenAPI and Scalar

Serve a generated OpenAPI document:

```ts
import { Hono } from 'hono';
import { createOpenAPIHandler } from '@syncular/server-hono';

const app = new Hono();
app.get('/openapi.json', createOpenAPIHandler(app, { title: 'Syncular API' }));
```

Or mount both the OpenAPI document and a Scalar reference page:

```ts
import { Hono } from 'hono';
import { createOpenAPIDocsRoutes } from '@syncular/server-hono';

const app = new Hono();
app.route('/', createOpenAPIDocsRoutes(app, { title: 'Syncular API' }));
```

That serves:
- `/openapi.json`
- `/spec`

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/server-plugin-yjs
Description: Yjs CRDT server integration primitives for Syncular handlers
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/server-plugin-yjs

Yjs-first server integration helpers for Syncular.

Implemented:
- Rule-based field mapping: `{ table, field, stateColumn }`.
- Kind-aware materialization: `text`, `xml-fragment`, `prosemirror`.
- Stable payload envelope key: `__yjs`.
- `createYjsServerModule()` with helpers:
  - `applyPayload(...)`: merge incoming Yjs envelopes into materialized payload + state column.
  - `materializeRow(...)`: derive projection field values from stored Yjs state.
- `createYjsServerPushPlugin()`:
  - `beforeApplyOperation`: CRDT envelope -> payload/state transform.
  - `afterApplyOperation`: materialize emitted rows + conflict rows.
- Utility exports:
  - `buildYjsTextUpdate`
  - `applyYjsTextUpdates`

## Example

```ts
import { createYjsServerModule } from '@syncular/server-plugin-yjs';

const yjs = createYjsServerModule({
  rules: [
    {
      table: 'tasks',
      field: 'content',
      stateColumn: 'content_yjs_state',
    },
  ],
});

const nextPayload = yjs.applyPayload({
  table: 'tasks',
  rowId: 'task-1',
  payload: incomingPayload,
  existingRow: currentRow,
});
```
npm package: @syncular/transport-ws
Description: WebSocket transport for Syncular real-time sync
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/transport-ws

WebSocket transport for Syncular realtime wake-ups and presence.

WebSockets are used as a wake-up mechanism; data still flows over HTTP via `@syncular/transport-http` (clients pull after being notified).

## Install

```bash
npm install @syncular/transport-ws
```

## Usage

```ts
import { createWebSocketTransport } from '@syncular/transport-ws';

const transport = createWebSocketTransport({
  baseUrl: 'https://api.example.com',
  getHeaders: () => ({ Authorization: `Bearer ${token}` }),
  // In browsers, WebSocket auth is typically cookie-based (same-origin).
  // If needed, use getRealtimeParams to add non-sensitive query params.
});
```

## Documentation

- Realtime wake-ups: https://syncular.dev/docs/build/realtime
- Presence: https://syncular.dev/docs/build/presence

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.
npm package: @syncular/typegen
Description: TypeScript type generator for Syncular schemas
Author: Benjamin Kniffler
Latest version: 0.0.6-246

# @syncular/typegen

Generate TypeScript database types from your migrations.

Supports SQLite and Postgres introspection with column-level codec type overrides via `codecs`.

## Install

```bash
npm install @syncular/typegen
```

## Usage

```ts
import { codecs } from '@syncular/core';
import { generateTypes } from '@syncular/typegen';
import { migrations } from './migrations';

await generateTypes({
  migrations,
  output: './src/db.generated.ts',
  dialect: 'postgres',
  codecs: (col) => {
    if (col.table === 'events' && col.column === 'payload') {
      return codecs.stringJson({
        import: { name: 'EventPayload', from: './domain' },
      });
    }
    if (
      col.table === 'events' &&
      col.column === 'is_active' &&
      col.sqlType?.toLowerCase().includes('int')
    ) {
      return codecs.numberBoolean();
    }
    return undefined;
  },
});
```

## Documentation

- Typegen (in migrations guide): https://syncular.dev/docs/build/migrations#type-generation-with-synculartypegen

## Links

- GitHub: https://github.com/syncular/syncular
- Issues: https://github.com/syncular/syncular/issues

> Status: Alpha. APIs and storage layouts may change between releases.