@undefineds.co/models 0.1.1 → 0.2.1

package/dist/chat.schema.d.ts

@@ -1 +1,37 @@
-export { chatTable, type ChatMetadata, type ChatMemberRole, type ChatRow, type ChatInsert, type ChatUpdate, } from './core.js';
+export type ChatMemberRole = 'owner' | 'admin' | 'member';
+export interface ChatMetadata {
+    memberRoles?: Record<string, ChatMemberRole>;
+}
+/**
+ * Chat schema (channel/place).
+ *
+ * CP0 baseline (alignment):
+ * - Chat is a container for messages/widgets regardless of counterpart type.
+ * - Do not encode counterpart-specific behavior in Chat (no chatType/subtype).
+ * - Participants use Solid chat-aligned flow vocabulary (wf/flow).
+ *
+ * Storage structure (aligned with xpod):
+ * - Chat metadata stored as #this in index.ttl
+ * - Location: /.data/chat/{id}/index.ttl#this
+ * - Threads stored as fragments in same file: /.data/chat/{id}/index.ttl#{threadId}
+ */
+export declare const chatTable: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    title: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    description: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    avatarUrl: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
+    muted: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
+    unreadCount: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"integer", null, false, true>;
+    contact: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    participants: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"array", "uri", false, false>;
+    metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
+    lastActiveAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    lastMessageId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    lastMessagePreview: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    updatedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+}>>;
+export type ChatRow = typeof chatTable.$inferSelect;
+export type ChatInsert = typeof chatTable.$inferInsert;
+export type ChatUpdate = typeof chatTable.$inferUpdate;

package/dist/chat.schema.js

@@ -1 +1,47 @@
-export { chatTable, } from './core.js';
+import { boolean, object, podTable, string, text, timestamp, uri, id, integer } from '@undefineds.co/drizzle-solid';
+import { UDFS, DCTerms, SCHEMA, MEETING, WF } from './namespaces.js';
+/**
+ * Chat schema (channel/place).
+ *
+ * CP0 baseline (alignment):
+ * - Chat is a container for messages/widgets regardless of counterpart type.
+ * - Do not encode counterpart-specific behavior in Chat (no chatType/subtype).
+ * - Participants use Solid chat-aligned flow vocabulary (wf/flow).
+ *
+ * Storage structure (aligned with xpod):
+ * - Chat metadata stored as #this in index.ttl
+ * - Location: /.data/chat/{id}/index.ttl#this
+ * - Threads stored as fragments in same file: /.data/chat/{id}/index.ttl#{threadId}
+ */
+export const chatTable = podTable('chats', {
+    id: id('id'),
+    // Display
+    title: string('title').predicate(DCTerms.title).notNull(),
+    description: string('description').predicate(DCTerms.description),
+    avatarUrl: uri('avatarUrl').predicate(SCHEMA.image),
+    // Chat state
+    starred: boolean('starred').predicate(UDFS.favorite).default(false),
+    muted: boolean('muted').predicate(UDFS.muted).default(false),
+    unreadCount: integer('unreadCount').predicate(UDFS.unreadCount).default(0),
+    // Optional counterpart/contact represented by this channel. Stored as RDF URI; callers may pass a short contact id.
+    contact: uri('contact').predicate(UDFS.term('contact')).link('contact'),
+    // Explicit membership for group chats.
+    participants: uri('participants')
+        .array()
+        .predicate(WF.participant),
+    // Structured chat metadata.
+    metadata: object('metadata').predicate(UDFS.metadata),
+    // Last activity
+    lastActiveAt: timestamp('lastActiveAt').predicate(UDFS.lastActiveAt),
+    lastMessageId: uri('lastMessageId').predicate(WF.message),
+    lastMessagePreview: text('lastMessagePreview').predicate(SCHEMA.text),
+    // Timestamps
+    createdAt: timestamp('createdAt').predicate(DCTerms.created).notNull().defaultNow(),
+    updatedAt: timestamp('updatedAt').predicate(DCTerms.modified).notNull().defaultNow(),
+}, {
+    base: '/.data/chat/',
+    sparqlEndpoint: '/.data/chat/-/sparql',
+    type: MEETING.LongChat,
+    namespace: UDFS,
+    subjectTemplate: '{id}/index.ttl#this',
+});

package/dist/client/index.d.ts

@@ -0,0 +1,121 @@
+export type LinxAuthType = 'client_credentials' | 'oidc_oauth';
+export interface LinxClientConfig {
+    url: string;
+    webId: string;
+    authType: LinxAuthType;
+}
+export interface LinxClientCredentialsSecrets {
+    clientId: string;
+    clientSecret: string;
+}
+export interface LinxOidcOAuthSecrets {
+    oidcRefreshToken: string;
+    oidcAccessToken: string;
+    oidcExpiresAt: string;
+    oidcClientId?: string;
+}
+export type LinxClientSecrets = LinxClientCredentialsSecrets | LinxOidcOAuthSecrets;
+export interface AccountSession {
+    url: string;
+    email: string;
+    token: string;
+    webId?: string;
+    podUrl?: string;
+    createdAt: string;
+}
+export interface LinxAccountControls {
+    pod?: string;
+    clientCredentials?: string;
+}
+export interface LinxAccountData {
+    controls: LinxAccountControls;
+    pods: Record<string, string>;
+    webIds: Record<string, string>;
+    clientCredentials: Record<string, string>;
+}
+export interface LinxClientCredential {
+    id: string;
+    secret?: string;
+    label?: string;
+    webId?: string;
+}
+export interface LinxStoredCredentials {
+    url: string;
+    webId: string;
+    authType: LinxAuthType;
+    secrets: LinxClientSecrets;
+}
+export type LinxCredentialBootstrapStatus = 'reused' | 'created' | 'recreated';
+export interface LinxWhoAmIField {
+    key: 'email' | 'server' | 'webId' | 'pod' | 'session-created-at';
+    value: string;
+}
+export interface PerformLinxPasswordLoginInput {
+    baseUrl?: string | null;
+    fallbackBaseUrl?: string;
+    email: string;
+    password: string;
+    requestedWebId?: string | null;
+    credentialName?: string | null;
+    existingCredentials?: LinxStoredCredentials | null;
+    now?: Date;
+}
+export interface PerformLinxPasswordLoginResult {
+    baseUrl: string;
+    webId: string;
+    account: LinxAccountData;
+    session: AccountSession;
+    credentialStatus: LinxCredentialBootstrapStatus;
+    credentialsToSave?: {
+        url: string;
+        webId: string;
+        authType: 'client_credentials';
+        secrets: LinxClientCredentialsSecrets;
+    };
+}
+export interface PerformLinxPasswordLoginDependencies {
+    checkServer(baseUrl: string): Promise<boolean>;
+    login(email: string, password: string, baseUrl: string): Promise<string | null>;
+    getAccountData(token: string, baseUrl: string): Promise<LinxAccountData | null>;
+    validateClientCredentials?(credentials: LinxStoredCredentials): Promise<boolean>;
+    createClientCredentials(token: string, credentialsUrl: string, webId: string, name?: string): Promise<LinxClientCredential | null>;
+}
+export declare const LINX_HOME_DIRNAME = ".linx";
+export declare const LINX_CONFIG_FILE_NAME = "config.json";
+export declare const LINX_SECRETS_FILE_NAME = "secrets.json";
+export declare const LINX_ACCOUNT_SESSION_FILE_NAME = "account.json";
+export declare const LINX_CLOUD_IDENTITY_ORIGIN = "https://id.undefineds.co";
+export declare const LINX_CLOUD_API_ORIGIN = "https://api.undefineds.co";
+export declare const LINX_CLOUD_ACCOUNT_API_BASE_URL = "https://id.undefineds.co/";
+export declare const LINX_CLOUD_RUNTIME_API_BASE_URL = "https://api.undefineds.co/v1";
+export declare const LINX_CLOUD_API_BASE_URL = "https://id.undefineds.co/";
+export declare const LINX_CLOUD_IDENTITY_HOSTS: readonly ["id.undefineds.co"];
+export declare function resolveLinxBaseUrl(url?: string | null, fallbackBaseUrl?: string): string;
+export declare function resolveLinxRuntimeApiBaseUrl(url?: string | null, fallbackBaseUrl?: string): string;
+export declare function resolveLinxCloudAccountBaseUrl(url?: string | null): string;
+export declare function resolveLinxCloudRuntimeApiBaseUrl(url?: string | null): string;
+export declare function resolveLinxCloudApiBaseUrl(url?: string | null): string;
+export declare function isLinxCloudIdentityBaseUrl(url?: string | null): boolean;
+export declare function resolveLinxRuntimeOriginForIssuerUrl(url?: string | null): string;
+export declare function resolveLinxRuntimeApiBaseUrlForIssuerUrl(url?: string | null): string;
+export declare function resolveLinxPodUrl(webId: string): string;
+export declare function resolveLinxPodBaseUrl(webId: string): string;
+export declare function extractProfileUsernameFromWebId(webId: string): string;
+export declare function parseLinxClientConfig(raw: unknown): LinxClientConfig | null;
+export declare function isLinxClientCredentialsSecrets(secrets: LinxClientSecrets): secrets is LinxClientCredentialsSecrets;
+export declare function isLinxOidcOAuthSecrets(secrets: LinxClientSecrets): secrets is LinxOidcOAuthSecrets;
+export declare function parseLinxClientSecrets(raw: unknown): LinxClientSecrets | null;
+export declare function parseLinxAccountData(raw: unknown): LinxAccountData | null;
+export declare function parseLinxClientCredential(raw: unknown): LinxClientCredential | null;
+export declare function parseAccountSession(raw: unknown): AccountSession | null;
+export declare function selectLinxAccountWebId(account: LinxAccountData | null, preferredWebId?: string | null): string | null;
+export declare function resolveLinxAccountPodUrl(account: LinxAccountData | null, webId?: string | null): string | null;
+export declare function hasMatchingLinxStoredCredentials(credentials: Pick<LinxStoredCredentials, 'url' | 'webId'> | null | undefined, baseUrl: string, webId: string): boolean;
+export declare function resolveLinxCredentialBootstrapStatus(input: {
+    reusedExistingCredentials: boolean;
+    hadMatchingStoredCredentials: boolean;
+}): LinxCredentialBootstrapStatus;
+export declare function listLinxWhoAmIFields(session: AccountSession, options?: {
+    verbose?: boolean;
+}): LinxWhoAmIField[];
+export declare function performLinxPasswordLogin(input: PerformLinxPasswordLoginInput, deps: PerformLinxPasswordLoginDependencies): Promise<PerformLinxPasswordLoginResult>;

package/dist/client/index.js

@@ -0,0 +1,299 @@
+export const LINX_HOME_DIRNAME = '.linx';
+export const LINX_CONFIG_FILE_NAME = 'config.json';
+export const LINX_SECRETS_FILE_NAME = 'secrets.json';
+export const LINX_ACCOUNT_SESSION_FILE_NAME = 'account.json';
+export const LINX_CLOUD_IDENTITY_ORIGIN = 'https://id.undefineds.co';
+export const LINX_CLOUD_API_ORIGIN = 'https://api.undefineds.co';
+export const LINX_CLOUD_ACCOUNT_API_BASE_URL = `${LINX_CLOUD_IDENTITY_ORIGIN}/`;
+export const LINX_CLOUD_RUNTIME_API_BASE_URL = `${LINX_CLOUD_API_ORIGIN}/v1`;
+export const LINX_CLOUD_API_BASE_URL = LINX_CLOUD_ACCOUNT_API_BASE_URL;
+export const LINX_CLOUD_IDENTITY_HOSTS = ['id.undefineds.co'];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function parseStringRecord(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const entries = Object.entries(value)
+        .filter((entry) => typeof entry[1] === 'string');
+    return Object.fromEntries(entries);
+}
+function normalizeAuthType(value) {
+    return value === 'oidc_oauth' ? 'oidc_oauth' : 'client_credentials';
+}
+function trimTrailingSlash(url) {
+    return url.replace(/\/+$/, '');
+}
+function resolveHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return '';
+    }
+}
+export function resolveLinxBaseUrl(url, fallbackBaseUrl = 'http://localhost:3000') {
+    const raw = typeof url === 'string' && url.trim() ? url.trim() : fallbackBaseUrl;
+    return raw.endsWith('/') ? raw : `${raw}/`;
+}
+export function resolveLinxRuntimeApiBaseUrl(url, fallbackBaseUrl = LINX_CLOUD_ACCOUNT_API_BASE_URL) {
+    const normalized = trimTrailingSlash(resolveLinxBaseUrl(url, fallbackBaseUrl));
+    return normalized.endsWith('/v1') ? normalized : `${normalized}/v1`;
+}
+export function resolveLinxCloudAccountBaseUrl(url) {
+    return resolveLinxBaseUrl(url, LINX_CLOUD_ACCOUNT_API_BASE_URL);
+}
+export function resolveLinxCloudRuntimeApiBaseUrl(url) {
+    return resolveLinxRuntimeApiBaseUrl(url, LINX_CLOUD_RUNTIME_API_BASE_URL);
+}
+export function resolveLinxCloudApiBaseUrl(url) {
+    return resolveLinxCloudAccountBaseUrl(url);
+}
+export function isLinxCloudIdentityBaseUrl(url) {
+    const normalized = resolveLinxBaseUrl(url, LINX_CLOUD_ACCOUNT_API_BASE_URL);
+    const hostname = resolveHostname(normalized);
+    return LINX_CLOUD_IDENTITY_HOSTS.includes(hostname);
+}
+export function resolveLinxRuntimeOriginForIssuerUrl(url) {
+    const normalized = trimTrailingSlash(resolveLinxBaseUrl(url, LINX_CLOUD_ACCOUNT_API_BASE_URL));
+    if (isLinxCloudIdentityBaseUrl(normalized)) {
+        return LINX_CLOUD_API_ORIGIN;
+    }
+    return normalized;
+}
+export function resolveLinxRuntimeApiBaseUrlForIssuerUrl(url) {
+    const runtimeOrigin = resolveLinxRuntimeOriginForIssuerUrl(url);
+    return resolveLinxRuntimeApiBaseUrl(runtimeOrigin, LINX_CLOUD_RUNTIME_API_BASE_URL);
+}
+export function resolveLinxPodUrl(webId) {
+    try {
+        const target = new URL(webId);
+        const pathParts = target.pathname.split('/').filter(Boolean);
+        return `${target.origin}/${pathParts[0] ?? ''}/`.replace(/\/+$/, '/');
+    }
+    catch {
+        return '';
+    }
+}
+export function resolveLinxPodBaseUrl(webId) {
+    return trimTrailingSlash(resolveLinxPodUrl(webId));
+}
+export function extractProfileUsernameFromWebId(webId) {
+    try {
+        const target = new URL(webId);
+        const pathParts = target.pathname.split('/').filter(Boolean).map((part) => decodeURIComponent(part));
+        const profileIndex = pathParts.indexOf('profile');
+        if (profileIndex > 0) {
+            return pathParts[profileIndex - 1];
+        }
+        const firstUserSegment = pathParts.find((part) => part !== 'profile' && part !== 'card');
+        if (firstUserSegment) {
+            return firstUserSegment;
+        }
+    }
+    catch {
+        // Fall through to the unsigned-in fallback.
+    }
+    return 'there';
+}
+export function parseLinxClientConfig(raw) {
+    if (!isRecord(raw) || typeof raw.url !== 'string' || typeof raw.webId !== 'string') {
+        return null;
+    }
+    return {
+        url: raw.url,
+        webId: raw.webId,
+        authType: normalizeAuthType(raw.authType),
+    };
+}
+export function isLinxClientCredentialsSecrets(secrets) {
+    return 'clientId' in secrets && 'clientSecret' in secrets;
+}
+export function isLinxOidcOAuthSecrets(secrets) {
+    return 'oidcRefreshToken' in secrets && 'oidcAccessToken' in secrets && 'oidcExpiresAt' in secrets;
+}
+export function parseLinxClientSecrets(raw) {
+    if (!isRecord(raw)) {
+        return null;
+    }
+    if (typeof raw.clientId === 'string' && typeof raw.clientSecret === 'string') {
+        return {
+            clientId: raw.clientId,
+            clientSecret: raw.clientSecret,
+        };
+    }
+    if (typeof raw.oidcRefreshToken === 'string'
+        && typeof raw.oidcAccessToken === 'string'
+        && typeof raw.oidcExpiresAt === 'string') {
+        return {
+            oidcRefreshToken: raw.oidcRefreshToken,
+            oidcAccessToken: raw.oidcAccessToken,
+            oidcExpiresAt: raw.oidcExpiresAt,
+            oidcClientId: optionalString(raw.oidcClientId),
+        };
+    }
+    return null;
+}
+export function parseLinxAccountData(raw) {
+    if (!isRecord(raw)) {
+        return null;
+    }
+    const controls = isRecord(raw.controls) ? raw.controls : {};
+    const accountControls = isRecord(controls.account) ? controls.account : controls;
+    return {
+        controls: {
+            pod: optionalString(accountControls.pod),
+            clientCredentials: optionalString(accountControls.clientCredentials),
+        },
+        pods: parseStringRecord(raw.pods),
+        webIds: parseStringRecord(raw.webIds),
+        clientCredentials: parseStringRecord(raw.clientCredentials),
+    };
+}
+export function parseLinxClientCredential(raw) {
+    if (!isRecord(raw) || typeof raw.id !== 'string') {
+        return null;
+    }
+    return {
+        id: raw.id,
+        label: optionalString(raw.label),
+        secret: optionalString(raw.secret),
+        webId: optionalString(raw.webId),
+    };
+}
+export function parseAccountSession(raw) {
+    if (!isRecord(raw)
+        || typeof raw.url !== 'string'
+        || typeof raw.email !== 'string'
+        || typeof raw.token !== 'string'
+        || typeof raw.createdAt !== 'string') {
+        return null;
+    }
+    return {
+        url: raw.url,
+        email: raw.email,
+        token: raw.token,
+        webId: optionalString(raw.webId),
+        podUrl: optionalString(raw.podUrl),
+        createdAt: raw.createdAt,
+    };
+}
+export function selectLinxAccountWebId(account, preferredWebId) {
+    if (typeof preferredWebId === 'string' && preferredWebId.trim()) {
+        return preferredWebId.trim();
+    }
+    if (!account) {
+        return null;
+    }
+    return Object.keys(account.webIds)[0] ?? null;
+}
+export function resolveLinxAccountPodUrl(account, webId) {
+    if (!account) {
+        return null;
+    }
+    if (webId && account.webIds[webId]) {
+        return resolveLinxBaseUrl(account.webIds[webId], account.webIds[webId]);
+    }
+    const firstMappedPodUrl = Object.values(account.webIds)[0];
+    if (typeof firstMappedPodUrl === 'string' && firstMappedPodUrl.trim()) {
+        return resolveLinxBaseUrl(firstMappedPodUrl, firstMappedPodUrl);
+    }
+    if (account.controls.pod?.trim()) {
+        return resolveLinxBaseUrl(account.controls.pod, account.controls.pod);
+    }
+    const firstPodKey = Object.keys(account.pods)[0];
+    if (typeof firstPodKey === 'string' && firstPodKey.trim()) {
+        return resolveLinxBaseUrl(firstPodKey, firstPodKey);
+    }
+    return null;
+}
+export function hasMatchingLinxStoredCredentials(credentials, baseUrl, webId) {
+    return credentials?.url === baseUrl && credentials?.webId === webId;
+}
+export function resolveLinxCredentialBootstrapStatus(input) {
+    if (input.reusedExistingCredentials) {
+        return 'reused';
+    }
+    return input.hadMatchingStoredCredentials ? 'recreated' : 'created';
+}
+export function listLinxWhoAmIFields(session, options = {}) {
+    const fields = [
+        { key: 'email', value: session.email },
+        { key: 'server', value: session.url },
+    ];
+    if (session.webId) {
+        fields.push({ key: 'webId', value: session.webId });
+    }
+    if (options.verbose && session.podUrl) {
+        fields.push({ key: 'pod', value: session.podUrl });
+    }
+    fields.push({ key: 'session-created-at', value: session.createdAt });
+    return fields;
+}
+export async function performLinxPasswordLogin(input, deps) {
+    const baseUrl = resolveLinxBaseUrl(input.baseUrl, input.fallbackBaseUrl);
+    if (!(await deps.checkServer(baseUrl))) {
+        throw new Error(`Cannot reach server at ${baseUrl}`);
+    }
+    const token = await deps.login(input.email, input.password, baseUrl);
+    if (!token) {
+        throw new Error('Login failed.');
+    }
+    const account = await deps.getAccountData(token, baseUrl);
+    if (!account) {
+        throw new Error('Failed to load account data after login.');
+    }
+    const webId = selectLinxAccountWebId(account, input.requestedWebId);
+    if (!webId) {
+        throw new Error('No WebID found. Pass --web-id explicitly.');
+    }
+    const hadMatchingStoredCredentials = hasMatchingLinxStoredCredentials(input.existingCredentials, baseUrl, webId);
+    const existingCredentialsValid = hadMatchingStoredCredentials && input.existingCredentials?.authType === 'client_credentials'
+        ? await deps.validateClientCredentials?.(input.existingCredentials)
+        : false;
+    const reusedExistingCredentials = hadMatchingStoredCredentials
+        && input.existingCredentials?.authType === 'client_credentials'
+        && existingCredentialsValid === true;
+    const credentialStatus = resolveLinxCredentialBootstrapStatus({
+        reusedExistingCredentials,
+        hadMatchingStoredCredentials,
+    });
+    let credentialsToSave;
+    if (!reusedExistingCredentials) {
+        if (!account.controls.clientCredentials) {
+            throw new Error('Cannot find client credentials endpoint.');
+        }
+        const credential = await deps.createClientCredentials(token, account.controls.clientCredentials, webId, input.credentialName ?? undefined);
+        if (!credential?.id || !credential.secret) {
+            throw new Error('Failed to create local client credentials.');
+        }
+        credentialsToSave = {
+            url: baseUrl,
+            webId,
+            authType: 'client_credentials',
+            secrets: {
+                clientId: credential.id,
+                clientSecret: credential.secret,
+            },
+        };
+    }
+    return {
+        baseUrl,
+        webId,
+        account,
+        credentialStatus,
+        ...(credentialsToSave ? { credentialsToSave } : {}),
+        session: {
+            url: baseUrl,
+            email: input.email,
+            token,
+            webId,
+            podUrl: resolveLinxAccountPodUrl(account, webId) ?? resolveLinxPodUrl(webId),
+            createdAt: (input.now ?? new Date()).toISOString(),
+        },
+    };
+}

package/dist/contact.repository.d.ts

@@ -1,24 +1,24 @@
-export declare const contactRepository: import("./repository.js").PodRepositoryDescriptor<import("@undefineds.co/models/_drizzle-solid/pod-table").PodTableWithColumns<import("@undefineds.co/models/_drizzle-solid/types").ResolvedColumns<{
-    id: import("@undefineds.co/models/_drizzle-solid/columns").PodStringColumn<false, false>;
-    name: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, true, false>;
-    avatarUrl: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"uri", null, false, false>;
-    entityUri: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"uri", null, true, false>;
-    rdfType: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"uri", null, true, true>;
-    contactType: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, true, false>;
-    isPublic: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"boolean", null, false, true>;
-    externalPlatform: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    externalId: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    alias: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    starred: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"boolean", null, false, true>;
-    note: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    sortKey: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    gender: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    province: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    city: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"string", null, false, false>;
-    createdAt: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"datetime", null, true, true>;
-    updatedAt: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"datetime", null, true, true>;
-    deletedAt: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"datetime", null, false, false>;
-    lastSyncedAt: import("@undefineds.co/models/_drizzle-solid/columns").ColumnBuilder<"datetime", null, false, false>;
+export declare const contactRepository: import("./repository").PodRepositoryDescriptor<import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    name: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    avatarUrl: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    entityUri: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    rdfType: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, true>;
+    contactType: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    isPublic: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
+    externalPlatform: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    externalId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    alias: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
+    note: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    sortKey: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    gender: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    province: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    city: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    updatedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    deletedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    lastSyncedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
 }>>, {
     id: string;
     name: string;

package/dist/contact.schema.d.ts

@@ -1 +1,48 @@
-export { contactTable, ContactClass, ContactType, isAgentContact, isGroupContact, type ContactRow, type ContactInsert, type ContactUpdate, type ContactClassValue, type ContactTypeValue, } from './core.js';
+export declare const ContactType: {
+    readonly SOLID: "solid";
+    readonly EXTERNAL: "external";
+    readonly AGENT: "agent";
+    readonly GROUP: "group";
+};
+export type ContactTypeValue = typeof ContactType[keyof typeof ContactType];
+export declare const ContactClass: {
+    readonly PERSON: string;
+    readonly AGENT: string;
+    readonly GROUP: string;
+};
+export type ContactClassValue = typeof ContactClass[keyof typeof ContactClass];
+type ContactClassifier = {
+    rdfType?: string | null;
+    contactType?: string | null;
+};
+export declare function isGroupContact(contact: ContactClassifier | null | undefined): boolean;
+export declare function isAgentContact(contact: ContactClassifier | null | undefined): boolean;
+/**
+ * Contact Table - Unified contact index for all contact types.
+ */
+export declare const contactTable: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    name: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    avatarUrl: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    entityUri: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    rdfType: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, true>;
+    contactType: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    isPublic: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
+    externalPlatform: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    externalId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    alias: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
+    note: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    sortKey: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    gender: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    province: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    city: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    updatedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    deletedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    lastSyncedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+}>>;
+export type ContactRow = typeof contactTable.$inferSelect;
+export type ContactInsert = typeof contactTable.$inferInsert;
+export type ContactUpdate = typeof contactTable.$inferUpdate;
+export {};