newo 3.4.0 → 3.4.2

package/dist/cli/commands/watch.js

@@ -0,0 +1,195 @@
+/**
+ * Watch command handler
+ *
+ * Watches for file changes and automatically pushes when changes are detected.
+ * Supports selective resource watching with --only and --exclude flags.
+ *
+ * Usage:
+ *   newo watch                     # Watch and push all changes
+ *   newo watch --only projects     # Watch only project files
+ *   newo watch --debounce 2000     # Custom debounce delay (ms)
+ */
+import { selectSingleCustomer } from '../customer-selection.js';
+import { setupCli } from '../../cli-new/bootstrap.js';
+import { PUSHABLE_RESOURCE_TYPES } from '../../cli-new/di/tokens.js';
+import chokidar from 'chokidar';
+import path from 'path';
+// Default debounce delay in milliseconds
+const DEFAULT_DEBOUNCE_MS = 1000;
+/**
+ * Parse resource list from comma-separated string
+ */
+function parseResourceList(input) {
+    if (!input)
+        return [];
+    return input.split(',').map(r => r.trim().toLowerCase()).filter(Boolean);
+}
+/**
+ * Get file patterns to watch based on resource types
+ */
+function getWatchPatterns(customerDir, resources) {
+    const patterns = [];
+    for (const resource of resources) {
+        switch (resource) {
+            case 'projects':
+                // Watch .guidance and .jinja files in projects
+                patterns.push(path.join(customerDir, 'projects', '**', '*.guidance'));
+                patterns.push(path.join(customerDir, 'projects', '**', '*.jinja'));
+                patterns.push(path.join(customerDir, 'projects', '**', 'metadata.yaml'));
+                break;
+            case 'attributes':
+                // Watch attributes.yaml files
+                patterns.push(path.join(customerDir, 'attributes.yaml'));
+                patterns.push(path.join(customerDir, 'projects', '*', 'attributes.yaml'));
+                break;
+            case 'integrations':
+                // Watch integration files
+                patterns.push(path.join(customerDir, 'integrations', '**', '*.yaml'));
+                break;
+            case 'akb':
+                // Watch AKB files
+                patterns.push(path.join(customerDir, 'akb', '**', '*.yaml'));
+                break;
+        }
+    }
+    return patterns;
+}
+/**
+ * Push with V2 engine for selective resources
+ */
+async function pushWithV2Engine(customerConfig, customer, resources, verbose) {
+    const { syncEngine, logger } = setupCli(customerConfig, verbose);
+    const result = await syncEngine.pushSelected(customer, resources);
+    if (result.totalCreated > 0 || result.totalUpdated > 0 || result.totalDeleted > 0) {
+        logger.info(`✅ Pushed: ${result.totalCreated} created, ${result.totalUpdated} updated, ${result.totalDeleted} deleted`);
+    }
+    if (result.errors.length > 0) {
+        logger.warn(`⚠️  ${result.errors.length} error(s) occurred`);
+        result.errors.forEach(e => logger.error(`   ${e}`));
+    }
+}
+/**
+ * Main watch command handler
+ */
+export async function handleWatchCommand(customerConfig, args, verbose) {
+    const { selectedCustomer } = selectSingleCustomer(customerConfig, args.customer);
+    if (!selectedCustomer) {
+        console.error('❌ Please specify a customer with --customer <idn> or set a default');
+        process.exit(1);
+    }
+    // Parse options
+    const onlyResources = parseResourceList(args.only);
+    const excludeResources = parseResourceList(args.exclude);
+    const debounceMs = typeof args.debounce === 'number'
+        ? args.debounce
+        : (typeof args.debounce === 'string' ? parseInt(args.debounce, 10) : DEFAULT_DEBOUNCE_MS);
+    // Determine resources to watch
+    let resourcesToWatch;
+    if (onlyResources.length > 0) {
+        resourcesToWatch = onlyResources.filter(r => PUSHABLE_RESOURCE_TYPES.includes(r));
+    }
+    else if (excludeResources.length > 0) {
+        resourcesToWatch = PUSHABLE_RESOURCE_TYPES.filter(r => !excludeResources.includes(r));
+    }
+    else {
+        resourcesToWatch = [...PUSHABLE_RESOURCE_TYPES];
+    }
+    if (resourcesToWatch.length === 0) {
+        console.error('❌ No valid resources to watch');
+        console.error(`   Available: ${PUSHABLE_RESOURCE_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    const customerDir = path.join(process.cwd(), 'newo_customers', selectedCustomer.idn);
+    const watchPatterns = getWatchPatterns(customerDir, resourcesToWatch);
+    console.log(`👀 Watching for changes in: ${resourcesToWatch.join(', ')}`);
+    console.log(`📁 Customer: ${selectedCustomer.idn}`);
+    console.log(`⏱️  Debounce: ${debounceMs}ms`);
+    console.log('');
+    console.log('Press Ctrl+C to stop watching.');
+    console.log('');
+    // Debounce state
+    let debounceTimer = null;
+    let pendingChanges = new Set();
+    let isPushing = false;
+    // Push function with debouncing
+    const debouncedPush = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+            if (isPushing) {
+                // If already pushing, wait and try again
+                debouncedPush();
+                return;
+            }
+            if (pendingChanges.size === 0) {
+                return;
+            }
+            const changedFiles = Array.from(pendingChanges);
+            pendingChanges.clear();
+            isPushing = true;
+            console.log(`\n🔄 Changes detected in ${changedFiles.length} file(s):`);
+            changedFiles.slice(0, 5).forEach(f => console.log(`   ${path.relative(process.cwd(), f)}`));
+            if (changedFiles.length > 5) {
+                console.log(`   ... and ${changedFiles.length - 5} more`);
+            }
+            try {
+                // Use V2 engine for selective push
+                await pushWithV2Engine(customerConfig, selectedCustomer, resourcesToWatch, verbose);
+                console.log('✅ Push completed');
+            }
+            catch (error) {
+                console.error('❌ Push failed:', error instanceof Error ? error.message : String(error));
+            }
+            finally {
+                isPushing = false;
+            }
+        }, debounceMs);
+    };
+    // Set up file watcher
+    const watcher = chokidar.watch(watchPatterns, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100
+        }
+    });
+    watcher
+        .on('change', (filePath) => {
+        pendingChanges.add(filePath);
+        if (verbose) {
+            console.log(`📝 Changed: ${path.relative(process.cwd(), filePath)}`);
+        }
+        debouncedPush();
+    })
+        .on('add', (filePath) => {
+        pendingChanges.add(filePath);
+        if (verbose) {
+            console.log(`➕ Added: ${path.relative(process.cwd(), filePath)}`);
+        }
+        debouncedPush();
+    })
+        .on('unlink', (filePath) => {
+        pendingChanges.add(filePath);
+        if (verbose) {
+            console.log(`➖ Removed: ${path.relative(process.cwd(), filePath)}`);
+        }
+        debouncedPush();
+    })
+        .on('error', (error) => {
+        console.error('❌ Watcher error:', error);
+    });
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        console.log('\n\n👋 Stopping watch...');
+        watcher.close();
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        process.exit(0);
+    });
+    // Keep the process running
+    await new Promise(() => { }); // Never resolves - keeps process alive
+}
+//# sourceMappingURL=watch.js.map

package/dist/cli-new/bootstrap.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Bootstrap - Application Initialization and DI Setup
+ *
+ * This file wires all dependencies together and creates the service container.
+ * It's the single entry point for configuring the application.
+ */
+import { ServiceContainer } from './di/Container.js';
+import { type ILogger, type CustomerConfig, type MultiCustomerConfig } from '../domain/resources/common/types.js';
+import { SyncEngine, type SyncEngineOptions } from '../application/sync/SyncEngine.js';
+import { MigrationEngine } from '../application/migration/MigrationEngine.js';
+import type { AxiosInstance } from 'axios';
+/**
+ * API Client Factory that creates authenticated clients
+ */
+export declare function createApiClient(customer: CustomerConfig, verbose: boolean): Promise<AxiosInstance>;
+/**
+ * Bootstrap options
+ */
+export interface BootstrapOptions {
+    /**
+     * Enable verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * Sync engine options
+     */
+    syncEngineOptions?: SyncEngineOptions;
+}
+/**
+ * Create and configure the service container
+ */
+export declare function createServiceContainer(customerConfig: MultiCustomerConfig, options?: BootstrapOptions): ServiceContainer;
+/**
+ * Get SyncEngine from container
+ */
+export declare function getSyncEngine(container: ServiceContainer): SyncEngine;
+/**
+ * Get MigrationEngine from container
+ */
+export declare function getMigrationEngine(container: ServiceContainer): MigrationEngine;
+/**
+ * Get Logger from container
+ */
+export declare function getLogger(container: ServiceContainer): ILogger;
+/**
+ * Quick setup for CLI commands
+ *
+ * Creates a configured container with all services ready to use.
+ */
+export declare function setupCli(customerConfig: MultiCustomerConfig, verbose?: boolean): {
+    container: ServiceContainer;
+    syncEngine: SyncEngine;
+    migrationEngine: MigrationEngine;
+    logger: ILogger;
+};
+/**
+ * Adapter function for legacy pull command
+ *
+ * This provides backward compatibility with the existing CLI.
+ */
+export declare function legacyPullAdapter(customerConfig: MultiCustomerConfig, customer: CustomerConfig, verbose: boolean, silentOverwrite: boolean): Promise<void>;
+/**
+ * Adapter function for legacy push command
+ */
+export declare function legacyPushAdapter(customerConfig: MultiCustomerConfig, customer: CustomerConfig, verbose: boolean): Promise<void>;
+/**
+ * Adapter function for legacy status command
+ */
+export declare function legacyStatusAdapter(customerConfig: MultiCustomerConfig, customer: CustomerConfig, verbose: boolean): Promise<void>;
+/**
+ * Adapter function for legacy migrate command
+ */
+export declare function legacyMigrateAdapter(customerConfig: MultiCustomerConfig, sourceCustomer: CustomerConfig, destCustomer: CustomerConfig, sourceClient: AxiosInstance, destClient: AxiosInstance, verbose: boolean): Promise<void>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/cli-new/bootstrap.js

@@ -0,0 +1,154 @@
+/**
+ * Bootstrap - Application Initialization and DI Setup
+ *
+ * This file wires all dependencies together and creates the service container.
+ * It's the single entry point for configuring the application.
+ */
+import { ServiceContainer } from './di/Container.js';
+import { TOKENS } from './di/tokens.js';
+import { ConsoleLogger } from '../domain/resources/common/types.js';
+import { SyncEngine } from '../application/sync/SyncEngine.js';
+import { MigrationEngine, TransformService } from '../application/migration/MigrationEngine.js';
+import { ProjectSyncStrategy, createProjectSyncStrategy } from '../domain/strategies/sync/ProjectSyncStrategy.js';
+import { AttributeSyncStrategy, createAttributeSyncStrategy } from '../domain/strategies/sync/AttributeSyncStrategy.js';
+import { IntegrationSyncStrategy, createIntegrationSyncStrategy } from '../domain/strategies/sync/IntegrationSyncStrategy.js';
+import { AkbSyncStrategy, createAkbSyncStrategy } from '../domain/strategies/sync/AkbSyncStrategy.js';
+import { ConversationSyncStrategy, createConversationSyncStrategy } from '../domain/strategies/sync/ConversationSyncStrategy.js';
+import { makeClient } from '../api.js';
+import { getValidAccessToken } from '../auth.js';
+/**
+ * API Client Factory that creates authenticated clients
+ */
+export async function createApiClient(customer, verbose) {
+    // Set environment variables for the customer
+    process.env.NEWO_API_KEY = customer.apiKey;
+    if (customer.projectId) {
+        process.env.NEWO_PROJECT_ID = customer.projectId;
+    }
+    const token = await getValidAccessToken();
+    return makeClient(verbose, token);
+}
+/**
+ * Create and configure the service container
+ */
+export function createServiceContainer(customerConfig, options = {}) {
+    const container = new ServiceContainer();
+    const verbose = options.verbose ?? false;
+    // === Infrastructure Layer ===
+    // Logger
+    const logger = new ConsoleLogger(verbose);
+    container.registerValue(TOKENS.LOGGER, logger);
+    // Customer Config
+    container.registerValue(TOKENS.CUSTOMER_CONFIG, customerConfig);
+    // API Client Factory
+    container.registerValue(TOKENS.API_CLIENT_FACTORY, createApiClient);
+    // === Domain Layer - Sync Strategies ===
+    // Project Sync Strategy
+    container.registerSingleton(TOKENS.PROJECT_SYNC_STRATEGY, () => createProjectSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // Attribute Sync Strategy
+    container.registerSingleton(TOKENS.ATTRIBUTE_SYNC_STRATEGY, () => createAttributeSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // Integration Sync Strategy
+    container.registerSingleton(TOKENS.INTEGRATION_SYNC_STRATEGY, () => createIntegrationSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // AKB Sync Strategy
+    container.registerSingleton(TOKENS.AKB_SYNC_STRATEGY, () => createAkbSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // Conversation Sync Strategy
+    container.registerSingleton(TOKENS.CONVERSATION_SYNC_STRATEGY, () => createConversationSyncStrategy(createApiClient, container.get(TOKENS.LOGGER)));
+    // === Application Layer ===
+    // Sync Engine (uses all sync strategies)
+    container.registerSingleton(TOKENS.SYNC_ENGINE, () => {
+        const strategies = [
+            container.get(TOKENS.PROJECT_SYNC_STRATEGY),
+            container.get(TOKENS.ATTRIBUTE_SYNC_STRATEGY),
+            container.get(TOKENS.INTEGRATION_SYNC_STRATEGY),
+            container.get(TOKENS.AKB_SYNC_STRATEGY),
+            container.get(TOKENS.CONVERSATION_SYNC_STRATEGY),
+        ];
+        return new SyncEngine(strategies, container.get(TOKENS.LOGGER), options.syncEngineOptions);
+    });
+    // Migration Engine (uses SyncEngine)
+    container.registerSingleton(TOKENS.MIGRATION_ENGINE, () => {
+        const syncEngine = container.get(TOKENS.SYNC_ENGINE);
+        const transformService = new TransformService(container.get(TOKENS.LOGGER));
+        return new MigrationEngine(syncEngine, transformService, container.get(TOKENS.LOGGER));
+    });
+    return container;
+}
+/**
+ * Get SyncEngine from container
+ */
+export function getSyncEngine(container) {
+    return container.get(TOKENS.SYNC_ENGINE);
+}
+/**
+ * Get MigrationEngine from container
+ */
+export function getMigrationEngine(container) {
+    return container.get(TOKENS.MIGRATION_ENGINE);
+}
+/**
+ * Get Logger from container
+ */
+export function getLogger(container) {
+    return container.get(TOKENS.LOGGER);
+}
+/**
+ * Quick setup for CLI commands
+ *
+ * Creates a configured container with all services ready to use.
+ */
+export function setupCli(customerConfig, verbose = false) {
+    const container = createServiceContainer(customerConfig, { verbose });
+    return {
+        container,
+        syncEngine: getSyncEngine(container),
+        migrationEngine: getMigrationEngine(container),
+        logger: getLogger(container)
+    };
+}
+/**
+ * Adapter function for legacy pull command
+ *
+ * This provides backward compatibility with the existing CLI.
+ */
+export async function legacyPullAdapter(customerConfig, customer, verbose, silentOverwrite) {
+    const { syncEngine } = setupCli(customerConfig, verbose);
+    await syncEngine.pullAll(customer, {
+        silentOverwrite,
+        verbose
+    });
+}
+/**
+ * Adapter function for legacy push command
+ */
+export async function legacyPushAdapter(customerConfig, customer, verbose) {
+    const { syncEngine } = setupCli(customerConfig, verbose);
+    await syncEngine.pushAll(customer);
+}
+/**
+ * Adapter function for legacy status command
+ */
+export async function legacyStatusAdapter(customerConfig, customer, verbose) {
+    const { syncEngine, logger } = setupCli(customerConfig, verbose);
+    const status = await syncEngine.getStatus(customer);
+    logger.info(`\nStatus for customer: ${status.customer}`);
+    logger.info(`Total changes: ${status.totalChanges}\n`);
+    for (const resource of status.resources) {
+        if (resource.changedCount > 0) {
+            logger.info(`${resource.displayName}: ${resource.changedCount} change(s)`);
+            for (const change of resource.changes) {
+                logger.info(`  ${change.operation.toUpperCase()[0]} ${change.path}`);
+            }
+        }
+    }
+    if (status.totalChanges === 0) {
+        logger.info('No changes to push.');
+    }
+}
+/**
+ * Adapter function for legacy migrate command
+ */
+export async function legacyMigrateAdapter(customerConfig, sourceCustomer, destCustomer, sourceClient, destClient, verbose) {
+    const { migrationEngine } = setupCli(customerConfig, verbose);
+    await migrationEngine.migrateAccount(sourceCustomer, destCustomer, sourceClient, destClient, { verbose });
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/cli-new/di/Container.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Dependency Injection Container
+ *
+ * A simple, TypeScript-native DI container that:
+ * - Supports singleton and factory registrations
+ * - Provides type-safe dependency resolution
+ * - Enables easy testing through dependency injection
+ */
+/**
+ * Factory function type for creating service instances
+ */
+type Factory<T> = (container: ServiceContainer) => T;
+/**
+ * Service Container for Dependency Injection
+ */
+export declare class ServiceContainer {
+    private registrations;
+    /**
+     * Register a factory that creates a new instance each time
+     */
+    register<T>(token: symbol, factory: Factory<T>): void;
+    /**
+     * Register a singleton - only created once
+     */
+    registerSingleton<T>(token: symbol, instanceOrFactory: T | Factory<T>): void;
+    /**
+     * Register a value directly
+     */
+    registerValue<T>(token: symbol, value: T): void;
+    /**
+     * Resolve a service by its token
+     */
+    get<T>(token: symbol): T;
+    /**
+     * Check if a token is registered
+     */
+    has(token: symbol): boolean;
+    /**
+     * Get all registered tokens
+     */
+    getTokens(): symbol[];
+    /**
+     * Clear all registrations (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Create a child container that inherits parent registrations
+     */
+    createChild(): ServiceContainer;
+}
+/**
+ * Get the global container instance
+ */
+export declare function getContainer(): ServiceContainer;
+/**
+ * Set the global container instance (useful for testing)
+ */
+export declare function setContainer(container: ServiceContainer): void;
+/**
+ * Reset the global container (useful for testing)
+ */
+export declare function resetContainer(): void;
+export {};
+//# sourceMappingURL=Container.d.ts.map

package/dist/cli-new/di/Container.js

@@ -0,0 +1,122 @@
+/**
+ * Dependency Injection Container
+ *
+ * A simple, TypeScript-native DI container that:
+ * - Supports singleton and factory registrations
+ * - Provides type-safe dependency resolution
+ * - Enables easy testing through dependency injection
+ */
+/**
+ * Service Container for Dependency Injection
+ */
+export class ServiceContainer {
+    registrations = new Map();
+    /**
+     * Register a factory that creates a new instance each time
+     */
+    register(token, factory) {
+        this.registrations.set(token, {
+            factory,
+            singleton: false
+        });
+    }
+    /**
+     * Register a singleton - only created once
+     */
+    registerSingleton(token, instanceOrFactory) {
+        if (typeof instanceOrFactory === 'function') {
+            this.registrations.set(token, {
+                factory: instanceOrFactory,
+                singleton: true
+            });
+        }
+        else {
+            this.registrations.set(token, {
+                factory: () => instanceOrFactory,
+                singleton: true,
+                instance: instanceOrFactory
+            });
+        }
+    }
+    /**
+     * Register a value directly
+     */
+    registerValue(token, value) {
+        this.registrations.set(token, {
+            factory: () => value,
+            singleton: true,
+            instance: value
+        });
+    }
+    /**
+     * Resolve a service by its token
+     */
+    get(token) {
+        const registration = this.registrations.get(token);
+        if (!registration) {
+            throw new Error(`No registration found for token: ${token.toString()}`);
+        }
+        if (registration.singleton) {
+            if (registration.instance === undefined) {
+                registration.instance = registration.factory(this);
+            }
+            return registration.instance;
+        }
+        return registration.factory(this);
+    }
+    /**
+     * Check if a token is registered
+     */
+    has(token) {
+        return this.registrations.has(token);
+    }
+    /**
+     * Get all registered tokens
+     */
+    getTokens() {
+        return Array.from(this.registrations.keys());
+    }
+    /**
+     * Clear all registrations (useful for testing)
+     */
+    clear() {
+        this.registrations.clear();
+    }
+    /**
+     * Create a child container that inherits parent registrations
+     */
+    createChild() {
+        const child = new ServiceContainer();
+        // Copy parent registrations
+        for (const [token, registration] of this.registrations) {
+            child.registrations.set(token, { ...registration });
+        }
+        return child;
+    }
+}
+/**
+ * Global container instance
+ */
+let globalContainer = null;
+/**
+ * Get the global container instance
+ */
+export function getContainer() {
+    if (!globalContainer) {
+        globalContainer = new ServiceContainer();
+    }
+    return globalContainer;
+}
+/**
+ * Set the global container instance (useful for testing)
+ */
+export function setContainer(container) {
+    globalContainer = container;
+}
+/**
+ * Reset the global container (useful for testing)
+ */
+export function resetContainer() {
+    globalContainer = null;
+}
+//# sourceMappingURL=Container.js.map

package/dist/cli-new/di/tokens.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Dependency Injection Tokens
+ *
+ * These symbols are used as unique identifiers for services in the DI container.
+ * Using symbols ensures no naming conflicts.
+ */
+export declare const TOKENS: {
+    readonly LOGGER: symbol;
+    readonly AUTH_SERVICE: symbol;
+    readonly API_CLIENT: symbol;
+    readonly API_CLIENT_FACTORY: symbol;
+    readonly FILE_SYSTEM: symbol;
+    readonly HASH_MANAGER: symbol;
+    readonly METADATA_GENERATOR: symbol;
+    readonly PROJECT_REPOSITORY: symbol;
+    readonly INTEGRATION_REPOSITORY: symbol;
+    readonly AKB_REPOSITORY: symbol;
+    readonly ATTRIBUTE_REPOSITORY: symbol;
+    readonly CONVERSATION_REPOSITORY: symbol;
+    readonly PROJECT_SYNC_STRATEGY: symbol;
+    readonly INTEGRATION_SYNC_STRATEGY: symbol;
+    readonly AKB_SYNC_STRATEGY: symbol;
+    readonly ATTRIBUTE_SYNC_STRATEGY: symbol;
+    readonly CONVERSATION_SYNC_STRATEGY: symbol;
+    readonly PROJECT_ENTITY_STRATEGY: symbol;
+    readonly AGENT_ENTITY_STRATEGY: symbol;
+    readonly FLOW_ENTITY_STRATEGY: symbol;
+    readonly SKILL_ENTITY_STRATEGY: symbol;
+    readonly SYNC_ENGINE: symbol;
+    readonly MIGRATION_ENGINE: symbol;
+    readonly ENTITY_MANAGER: symbol;
+    readonly PULL_USE_CASE: symbol;
+    readonly PUSH_USE_CASE: symbol;
+    readonly STATUS_USE_CASE: symbol;
+    readonly MIGRATE_USE_CASE: symbol;
+    readonly CREATE_ENTITY_USE_CASE: symbol;
+    readonly DELETE_ENTITY_USE_CASE: symbol;
+    readonly COMMAND_REGISTRY: symbol;
+    readonly COMMAND_EXECUTOR: symbol;
+    readonly ERROR_HANDLER: symbol;
+    readonly CUSTOMER_SELECTOR: symbol;
+    readonly CUSTOMER_CONFIG: symbol;
+    readonly ENVIRONMENT: symbol;
+};
+/**
+ * Type for the tokens object
+ */
+export type TokenKey = keyof typeof TOKENS;
+export type Token = (typeof TOKENS)[TokenKey];
+/**
+ * Resource types for selective sync
+ * These match the resourceType property in each ISyncStrategy implementation
+ */
+export declare const RESOURCE_TYPES: {
+    readonly PROJECTS: "projects";
+    readonly ATTRIBUTES: "attributes";
+    readonly INTEGRATIONS: "integrations";
+    readonly AKB: "akb";
+    readonly CONVERSATIONS: "conversations";
+};
+/**
+ * All available resource types for sync operations
+ */
+export declare const ALL_RESOURCE_TYPES: ("projects" | "integrations" | "akb" | "attributes" | "conversations")[];
+/**
+ * Pushable resource types (excludes read-only resources like conversations)
+ */
+export declare const PUSHABLE_RESOURCE_TYPES: readonly ["projects", "attributes", "integrations", "akb"];
+/**
+ * Type for resource type values
+ */
+export type ResourceType = (typeof RESOURCE_TYPES)[keyof typeof RESOURCE_TYPES];
+/**
+ * Type for pushable resource types
+ */
+export type PushableResourceType = (typeof PUSHABLE_RESOURCE_TYPES)[number];
+//# sourceMappingURL=tokens.d.ts.map