@fractary/codex 0.12.0 → 0.12.4

package/dist/index.d.cts

@@ -33,7 +33,7 @@ declare function getExtension(uri: string): string;
 declare function getFilename(uri: string): string;
 declare function getDirectory(uri: string): string;
 
-type StorageProviderType = 'local' | 'github' | 'http' | 's3' | 's3-archive' | 'r2' | 'gcs' | 'drive' | 'file-plugin';
+type StorageProviderType$1 = 'local' | 'github' | 'http' | 's3' | 's3-archive' | 'r2' | 'gcs' | 'drive' | 'file-plugin';
 interface FetchResult {
     content: Buffer;
     contentType: string;
@@ -51,13 +51,13 @@ interface FetchOptions {
 }
 interface StorageProvider {
     readonly name: string;
-    readonly type: StorageProviderType;
+    readonly type: StorageProviderType$1;
     fetch(reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
     exists(reference: ResolvedReference, options?: FetchOptions): Promise<boolean>;
     canHandle(reference: ResolvedReference): boolean;
 }
-interface StorageProviderConfig {
-    type: StorageProviderType;
+interface StorageProviderConfig$1 {
+    type: StorageProviderType$1;
     options?: Record<string, unknown>;
     timeout?: number;
     maxRetries?: number;
@@ -74,7 +74,7 @@ interface ResolvedReference extends ParsedReference {
     cachePath: string;
     isCurrentProject: boolean;
     localPath?: string;
-    sourceType?: StorageProviderType;
+    sourceType?: StorageProviderType$1;
     filePluginSource?: string;
 }
 interface ResolveOptions {
@@ -203,7 +203,7 @@ declare const CustomTypeSchema: z.ZodObject<{
         exclude: string[];
     } | undefined;
 }>;
-type CustomTypeConfig = z.infer<typeof CustomTypeSchema>;
+type CustomTypeConfig$1 = z.infer<typeof CustomTypeSchema>;
 declare const TypesConfigSchema: z.ZodObject<{
     custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
@@ -277,7 +277,7 @@ declare const TypesConfigSchema: z.ZodObject<{
         } | undefined;
     }> | undefined;
 }>;
-type TypesConfig = z.infer<typeof TypesConfigSchema>;
+type TypesConfig$1 = z.infer<typeof TypesConfigSchema>;
 interface ValidationResult {
     valid: boolean;
     errors: Array<{
@@ -288,7 +288,7 @@ interface ValidationResult {
 }
 declare function parseTtl(value: string | number): number;
 declare function validateCustomTypes(config: unknown): ValidationResult;
-declare function loadCustomTypes(config: TypesConfig): Map<string, ArtifactType>;
+declare function loadCustomTypes(config: TypesConfig$1): Map<string, ArtifactType>;
 declare function mergeTypes(builtIn: Record<string, ArtifactType>, custom: Map<string, ArtifactType>): Map<string, ArtifactType>;
 declare function extendType(baseName: string, overrides: Partial<Omit<ArtifactType, 'name'>>): Partial<ArtifactType>;
 
@@ -460,7 +460,7 @@ declare const CodexConfigSchema: z.ZodObject<{
             include: string[];
             exclude?: string[] | undefined;
         }>>;
-        from_codex: z.ZodOptional<z.ZodObject<{
+        from_codex: z.ZodOptional<z.ZodEffects<z.ZodObject<{
             include: z.ZodArray<z.ZodString, "many">;
             exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
@@ -469,6 +469,12 @@ declare const CodexConfigSchema: z.ZodObject<{
         }, {
             include: string[];
             exclude?: string[] | undefined;
+        }>, {
+            include: string[];
+            exclude?: string[] | undefined;
+        }, {
+            include: string[];
+            exclude?: string[] | undefined;
         }>>;
         exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         default_to_codex: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -923,7 +929,7 @@ declare const UnifiedConfigSchema: z.ZodObject<{
                 include: string[];
                 exclude?: string[] | undefined;
             }>>;
-            from_codex: z.ZodOptional<z.ZodObject<{
+            from_codex: z.ZodOptional<z.ZodEffects<z.ZodObject<{
                 include: z.ZodArray<z.ZodString, "many">;
                 exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, "strip", z.ZodTypeAny, {
@@ -932,6 +938,12 @@ declare const UnifiedConfigSchema: z.ZodObject<{
             }, {
                 include: string[];
                 exclude?: string[] | undefined;
+            }>, {
+                include: string[];
+                exclude?: string[] | undefined;
+            }, {
+                include: string[];
+                exclude?: string[] | undefined;
             }>>;
             exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             default_to_codex: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -1347,7 +1359,7 @@ declare const UnifiedConfigSchema: z.ZodObject<{
         }> | undefined;
     } | undefined;
 }>;
-type UnifiedConfig = z.infer<typeof UnifiedConfigSchema>;
+type UnifiedConfig$1 = z.infer<typeof UnifiedConfigSchema>;
 
 interface ParseMetadataOptions {
     strict?: boolean;
@@ -1489,7 +1501,7 @@ declare class HttpStorage implements StorageProvider {
 declare function createHttpStorage(options?: HttpStorageOptions): HttpStorage;
 
 interface FilePluginStorageOptions {
-    config: UnifiedConfig;
+    config: UnifiedConfig$1;
     enableS3Fallback?: boolean;
     baseDir?: string;
 }
@@ -1535,7 +1547,7 @@ interface StorageManagerConfig {
     http?: HttpStorageOptions;
     s3Archive?: S3ArchiveStorageOptions;
     filePlugin?: FilePluginStorageOptions;
-    priority?: StorageProviderType[];
+    priority?: StorageProviderType$1[];
     enableCaching?: boolean;
     codexConfig?: CodexConfig;
 }
@@ -1547,16 +1559,16 @@ declare class StorageManager {
     private resolveToken;
     private resolveFetchOptions;
     registerProvider(provider: StorageProvider): void;
-    removeProvider(type: StorageProviderType): boolean;
-    getProvider(type: StorageProviderType): StorageProvider | undefined;
+    removeProvider(type: StorageProviderType$1): boolean;
+    getProvider(type: StorageProviderType$1): StorageProvider | undefined;
     getProviders(): StorageProvider[];
     findProvider(reference: ResolvedReference): StorageProvider | null;
     fetch(reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
     exists(reference: ResolvedReference, options?: FetchOptions): Promise<boolean>;
-    fetchWith(type: StorageProviderType, reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
+    fetchWith(type: StorageProviderType$1, reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
     fetchMany(references: ResolvedReference[], options?: FetchOptions): Promise<Map<string, FetchResult | Error>>;
     getStatus(): Array<{
-        type: StorageProviderType;
+        type: StorageProviderType$1;
         name: string;
         priority: number;
     }>;
@@ -1752,45 +1764,45 @@ interface SyncOptions {
         hash?: string;
     }>;
 }
-interface SyncRule {
+interface SyncRule$1 {
     pattern: string;
     include: boolean;
     priority?: number;
     direction?: SyncDirection;
 }
-interface DirectionalSyncConfig {
+interface DirectionalSyncConfig$1 {
     include: string[];
     exclude?: string[];
 }
 interface RoutingConfig {
     use_frontmatter?: boolean;
 }
-interface SyncConfig {
+interface SyncConfig$1 {
     defaultDirection: SyncDirection;
-    rules: SyncRule[];
+    rules: SyncRule$1[];
     defaultExcludes: string[];
     deleteOrphans: boolean;
     conflictStrategy: 'newest' | 'local' | 'remote' | 'manual';
-    from_codex?: DirectionalSyncConfig;
-    to_codex?: DirectionalSyncConfig;
+    from_codex?: DirectionalSyncConfig$1;
+    to_codex?: DirectionalSyncConfig$1;
     routing?: RoutingConfig;
     default_from_codex?: string[];
     default_to_codex?: string[];
     exclude?: string[];
 }
-declare const DEFAULT_SYNC_CONFIG: SyncConfig;
+declare const DEFAULT_SYNC_CONFIG: SyncConfig$1;
 
 interface EvaluationResult {
     path: string;
     shouldSync: boolean;
-    matchedRule?: SyncRule;
+    matchedRule?: SyncRule$1;
     reason: string;
 }
-declare function evaluatePath(path: string, rules: SyncRule[], direction: SyncDirection, defaultExcludes?: string[]): EvaluationResult;
-declare function evaluatePaths(paths: string[], rules: SyncRule[], direction: SyncDirection, defaultExcludes?: string[]): Map<string, EvaluationResult>;
-declare function filterSyncablePaths(paths: string[], rules: SyncRule[], direction: SyncDirection, defaultExcludes?: string[]): string[];
-declare function createRulesFromPatterns(include?: string[], exclude?: string[]): SyncRule[];
-declare function mergeRules(...ruleSets: SyncRule[][]): SyncRule[];
+declare function evaluatePath(path: string, rules: SyncRule$1[], direction: SyncDirection, defaultExcludes?: string[]): EvaluationResult;
+declare function evaluatePaths(paths: string[], rules: SyncRule$1[], direction: SyncDirection, defaultExcludes?: string[]): Map<string, EvaluationResult>;
+declare function filterSyncablePaths(paths: string[], rules: SyncRule$1[], direction: SyncDirection, defaultExcludes?: string[]): string[];
+declare function createRulesFromPatterns(include?: string[], exclude?: string[]): SyncRule$1[];
+declare function mergeRules(...ruleSets: SyncRule$1[][]): SyncRule$1[];
 interface EvaluationSummary {
     total: number;
     included: number;
@@ -1798,7 +1810,7 @@ interface EvaluationSummary {
     byReason: Record<string, number>;
 }
 declare function summarizeEvaluations(results: Map<string, EvaluationResult>): EvaluationSummary;
-declare function validateRules$1(rules: SyncRule[]): string[];
+declare function validateRules$1(rules: SyncRule$1[]): string[];
 
 interface FileInfo {
     path: string;
@@ -1806,7 +1818,7 @@ interface FileInfo {
     mtime: number;
     hash?: string;
 }
-declare function createSyncPlan(sourceFiles: FileInfo[], targetFiles: FileInfo[], options: SyncOptions, config: SyncConfig): SyncPlan;
+declare function createSyncPlan(sourceFiles: FileInfo[], targetFiles: FileInfo[], options: SyncOptions, config: SyncConfig$1): SyncPlan;
 declare function estimateSyncTime(plan: SyncPlan, bytesPerSecond?: number): number;
 declare function createEmptySyncPlan(direction?: SyncDirection): SyncPlan;
 declare function filterPlanOperations(plan: SyncPlan, operations: Array<'create' | 'update' | 'delete'>): SyncPlan;
@@ -1847,7 +1859,7 @@ interface RoutingScanResult {
 
 interface SyncManagerConfig {
     localStorage: LocalStorage;
-    config?: Partial<SyncConfig>;
+    config?: Partial<SyncConfig$1>;
     manifestPath?: string;
 }
 declare class SyncManager {
@@ -1876,19 +1888,19 @@ declare class SyncManager {
     isFileSynced(path: string): Promise<boolean>;
     getLastSyncTime(): Promise<number | null>;
     clearManifest(): Promise<void>;
-    getConfig(): SyncConfig;
-    updateConfig(updates: Partial<SyncConfig>): void;
+    getConfig(): SyncConfig$1;
+    updateConfig(updates: Partial<SyncConfig$1>): void;
 }
 declare function createSyncManager(config: SyncManagerConfig): SyncManager;
 
-type PermissionLevel = 'none' | 'read' | 'write' | 'admin';
+type PermissionLevel$1 = 'none' | 'read' | 'write' | 'admin';
 type PermissionScope = 'global' | 'org' | 'project' | 'path';
 type PermissionAction = 'fetch' | 'cache' | 'sync' | 'invalidate' | 'manage';
-interface PermissionRule {
+interface PermissionRule$1 {
     id?: string;
     pattern: string;
     actions: PermissionAction[];
-    level: PermissionLevel;
+    level: PermissionLevel$1;
     scope: PermissionScope;
     org?: string;
     project?: string;
@@ -1905,46 +1917,46 @@ interface PermissionContext {
 }
 interface PermissionResult {
     allowed: boolean;
-    level: PermissionLevel;
-    matchedRule?: PermissionRule;
+    level: PermissionLevel$1;
+    matchedRule?: PermissionRule$1;
     reason: string;
 }
 interface PermissionConfig {
-    defaultLevel: PermissionLevel;
+    defaultLevel: PermissionLevel$1;
     defaultAllow: boolean;
-    rules: PermissionRule[];
+    rules: PermissionRule$1[];
     enforced: boolean;
 }
 declare const DEFAULT_PERMISSION_CONFIG: PermissionConfig;
-declare const PERMISSION_LEVEL_ORDER: PermissionLevel[];
-declare function levelGrants(granted: PermissionLevel, required: PermissionLevel): boolean;
-declare function maxLevel(a: PermissionLevel, b: PermissionLevel): PermissionLevel;
-declare function minLevel(a: PermissionLevel, b: PermissionLevel): PermissionLevel;
+declare const PERMISSION_LEVEL_ORDER: PermissionLevel$1[];
+declare function levelGrants(granted: PermissionLevel$1, required: PermissionLevel$1): boolean;
+declare function maxLevel(a: PermissionLevel$1, b: PermissionLevel$1): PermissionLevel$1;
+declare function minLevel(a: PermissionLevel$1, b: PermissionLevel$1): PermissionLevel$1;
 
-declare function ruleMatchesContext(rule: PermissionRule, context: PermissionContext): boolean;
-declare function ruleMatchesPath(rule: PermissionRule, path: string): boolean;
-declare function ruleMatchesAction(rule: PermissionRule, action: PermissionAction): boolean;
+declare function ruleMatchesContext(rule: PermissionRule$1, context: PermissionContext): boolean;
+declare function ruleMatchesPath(rule: PermissionRule$1, path: string): boolean;
+declare function ruleMatchesAction(rule: PermissionRule$1, action: PermissionAction): boolean;
 declare function evaluatePermission(path: string, action: PermissionAction, context: PermissionContext, config: PermissionConfig): PermissionResult;
 declare function isAllowed(path: string, action: PermissionAction, context: PermissionContext, config: PermissionConfig): boolean;
-declare function hasPermission(path: string, action: PermissionAction, requiredLevel: PermissionLevel, context: PermissionContext, config: PermissionConfig): boolean;
+declare function hasPermission(path: string, action: PermissionAction, requiredLevel: PermissionLevel$1, context: PermissionContext, config: PermissionConfig): boolean;
 declare function evaluatePermissions(paths: string[], action: PermissionAction, context: PermissionContext, config: PermissionConfig): Map<string, PermissionResult>;
-declare function filterByPermission(paths: string[], action: PermissionAction, context: PermissionContext, config: PermissionConfig, requiredLevel?: PermissionLevel): string[];
-declare function validateRules(rules: PermissionRule[]): string[];
+declare function filterByPermission(paths: string[], action: PermissionAction, context: PermissionContext, config: PermissionConfig, requiredLevel?: PermissionLevel$1): string[];
+declare function validateRules(rules: PermissionRule$1[]): string[];
 declare function createRule(options: {
     pattern: string;
     actions: PermissionAction[];
-    level: PermissionLevel;
-    scope?: PermissionRule['scope'];
+    level: PermissionLevel$1;
+    scope?: PermissionRule$1['scope'];
     org?: string;
     project?: string;
     priority?: number;
     description?: string;
-}): PermissionRule;
+}): PermissionRule$1;
 declare const CommonRules: {
-    allowDocs: () => PermissionRule;
-    denyPrivate: () => PermissionRule;
-    readOnlySpecs: () => PermissionRule;
-    adminManage: () => PermissionRule;
+    allowDocs: () => PermissionRule$1;
+    denyPrivate: () => PermissionRule$1;
+    readOnlySpecs: () => PermissionRule$1;
+    adminManage: () => PermissionRule$1;
 };
 
 interface PermissionManagerConfig {
@@ -1956,14 +1968,14 @@ declare class PermissionManager {
     private defaultContext;
     constructor(options?: PermissionManagerConfig);
     isAllowed(path: string, action: PermissionAction, context?: PermissionContext): boolean;
-    hasPermission(path: string, action: PermissionAction, requiredLevel: PermissionLevel, context?: PermissionContext): boolean;
+    hasPermission(path: string, action: PermissionAction, requiredLevel: PermissionLevel$1, context?: PermissionContext): boolean;
     evaluate(path: string, action: PermissionAction, context?: PermissionContext): PermissionResult;
-    filterAllowed(paths: string[], action: PermissionAction, context?: PermissionContext, requiredLevel?: PermissionLevel): string[];
-    addRule(rule: PermissionRule): void;
+    filterAllowed(paths: string[], action: PermissionAction, context?: PermissionContext, requiredLevel?: PermissionLevel$1): string[];
+    addRule(rule: PermissionRule$1): void;
     removeRule(id: string): boolean;
-    getRules(): PermissionRule[];
+    getRules(): PermissionRule$1[];
     clearRules(): void;
-    setRules(rules: PermissionRule[]): void;
+    setRules(rules: PermissionRule$1[]): void;
     getConfig(): PermissionConfig;
     updateConfig(updates: Partial<Omit<PermissionConfig, 'rules'>>): void;
     setDefaultContext(context: PermissionContext): void;
@@ -1971,7 +1983,7 @@ declare class PermissionManager {
     enable(): void;
     disable(): void;
     isEnforced(): boolean;
-    assertPermission(path: string, action: PermissionAction, requiredLevel?: PermissionLevel, context?: PermissionContext): void;
+    assertPermission(path: string, action: PermissionAction, requiredLevel?: PermissionLevel$1, context?: PermissionContext): void;
 }
 declare class PermissionDeniedError extends Error {
     readonly path: string;
@@ -2094,4 +2106,147 @@ declare function hasLegacyReferences(text: string): boolean;
 declare function migrateFileReferences(content: string, options?: ConversionOptions): ReferenceConversionResult;
 declare function generateReferenceMigrationSummary(results: ReferenceConversionResult[]): string;
 
-export { type ArtifactType, type AutoSyncPattern, AutoSyncPatternSchema, BUILT_IN_TYPES, CODEX_URI_PREFIX, type CacheEntry, type CacheEntryMetadata, type CacheEntryStatus, type CacheLookupResult, CacheManager, type CacheManagerConfig, CachePersistence, type CachePersistenceOptions, type CacheStats, type CodexConfig, CodexConfigSchema, CodexError, CommonRules, ConfigurationError, type ConversionOptions, type ConvertedReference, type CustomSyncDestination, type CustomTypeConfig, CustomTypeSchema, DEFAULT_CACHE_DIR, DEFAULT_FETCH_OPTIONS, DEFAULT_MIGRATION_OPTIONS, DEFAULT_PERMISSION_CONFIG, DEFAULT_SYNC_CONFIG, DEFAULT_TYPE, type EvaluationResult, type EvaluationSummary, type FetchOptions, type FetchResult, type FileInfo, FilePluginFileNotFoundError, type FilePluginFileNotFoundErrorOptions, FilePluginStorage, type FilePluginStorageOptions, type FileSyncStatus, GitHubStorage, type GitHubStorageOptions, HttpStorage, type HttpStorageOptions, LEGACY_PATTERNS, LEGACY_REF_PREFIX, type LegacyAutoSyncPattern, type LegacyCodexConfig, type LoadConfigOptions, LocalStorage, type LocalStorageOptions, type Metadata, MetadataSchema, type MigrationChange, type MigrationOptions, type MigrationResult, type ModernCodexConfig, type ModernSyncPattern, PERMISSION_LEVEL_ORDER, type ParseMetadataOptions, type ParseOptions, type ParseResult, type ParsedReference, type PermissionAction, type PermissionConfig, type PermissionContext, PermissionDeniedError, type PermissionLevel, PermissionManager, type PermissionManagerConfig, type PermissionResult, type PermissionRule, type PermissionScope, type PlanStats, type ReferenceConversionResult, type ResolveOptions, type ResolveOrgOptions, type ResolvedReference, type SerializedCacheEntry, type ShouldSyncOptions, StorageManager, type StorageManagerConfig, type StorageProvider, type StorageProviderConfig, type StorageProviderType, type SyncConfig, type SyncDirection, SyncManager, type SyncManagerConfig, type SyncManifest, type SyncManifestEntry, type SyncOperation, type SyncOptions, type SyncPlan, type SyncResult, type SyncRule, type SyncRules, SyncRulesSchema, TTL, TypeRegistry, type TypeRegistryOptions, type TypesConfig, TypesConfigSchema, ValidationError, type VersionDetectionResult, buildUri, calculateCachePath, calculateContentHash, convertLegacyReference, convertLegacyReferences, convertToUri, createCacheEntry, createCacheManager, createCachePersistence, createDefaultRegistry, createEmptyModernConfig, createEmptySyncPlan, createGitHubStorage, createHttpStorage, createLocalStorage, createPermissionManager, createRule, createRulesFromPatterns, createStorageManager, createSyncManager, createSyncPlan, deserializeCacheEntry, detectContentType, detectCurrentProject, detectVersion, estimateSyncTime, evaluatePath, evaluatePaths, evaluatePatterns, evaluatePermission, evaluatePermissions, extendType, extractOrgFromRepoName, extractRawFrontmatter, filterByPatterns, filterByPermission, filterPlanOperations, filterSyncablePaths, findLegacyReferences, formatPlanSummary, generateMigrationReport, generateReferenceMigrationSummary, getBuiltInType, getBuiltInTypeNames, getCacheEntryAge, getCacheEntryStatus, getCurrentContext, getCustomSyncDestinations, getDefaultCacheManager, getDefaultConfig, getDefaultDirectories, getDefaultPermissionManager, getDefaultRules, getDefaultStorageManager, getDirectory, getExtension, getFilename, getMigrationRequirements, getPlanStats, getRelativeCachePath, getRemainingTtl, getTargetRepos, hasContentChanged, hasFrontmatter, hasLegacyReferences, hasPermission as hasPermissionLevel, isBuiltInType, isCacheEntryFresh, isCacheEntryValid, isCurrentProjectUri, isLegacyConfig, isLegacyReference, isModernConfig, isAllowed as isPermissionAllowed, isValidUri, levelGrants, loadConfig, loadCustomTypes, matchAnyPattern, matchPattern, maxLevel, mergeFetchOptions, mergeRules, mergeTypes, migrateConfig, migrateFileReferences, minLevel, needsMigration, parseCustomDestination, parseMetadata, parseReference, parseTtl, resolveOrganization, resolveReference, resolveReferences, ruleMatchesAction, ruleMatchesContext, ruleMatchesPath, sanitizePath, serializeCacheEntry, setDefaultCacheManager, setDefaultPermissionManager, setDefaultStorageManager, shouldSyncToRepo, summarizeEvaluations, touchCacheEntry, validateCustomTypes, validateMetadata, validateMigratedConfig, validateOrg, validatePath, validateRules as validatePermissionRules, validateProject, validateRules$1 as validateRules, validateUri };
+interface ExpandEnvOptions {
+    env?: Record<string, string | undefined>;
+    warnOnMissing?: boolean;
+    onMissing?: (varName: string) => void;
+}
+declare function expandEnvVars(value: string, options?: ExpandEnvOptions): string;
+declare function expandEnvVarsInConfig<T>(config: T, options?: ExpandEnvOptions): T;
+declare function hasEnvVars(value: string): boolean;
+declare function extractEnvVarNames(value: string): string[];
+
+type StorageProviderType = 'local' | 'github' | 'http' | 's3';
+interface LocalStorageConfig {
+    type: 'local';
+    basePath: string;
+    followSymlinks?: boolean;
+    priority?: number;
+}
+interface GitHubStorageConfig {
+    type: 'github';
+    token?: string;
+    apiBaseUrl?: string;
+    rawBaseUrl?: string;
+    branch?: string;
+    priority?: number;
+}
+interface HttpStorageConfig {
+    type: 'http';
+    baseUrl: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    priority?: number;
+}
+interface S3StorageConfig {
+    type: 's3';
+    bucket: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    priority?: number;
+}
+type StorageProviderConfig = LocalStorageConfig | GitHubStorageConfig | HttpStorageConfig | S3StorageConfig;
+interface CacheConfig {
+    directory?: string;
+    cacheDir?: string;
+    defaultTtl?: number;
+    maxSize?: number;
+    maxMemoryEntries?: number;
+    maxMemorySize?: number;
+    enablePersistence?: boolean;
+}
+interface CustomTypeConfig {
+    description?: string;
+    patterns?: string[];
+    defaultTtl?: number;
+    archiveAfterDays?: number | null;
+    archiveStorage?: 'local' | 'cloud' | 'drive' | null;
+}
+interface TypesConfig {
+    custom?: Record<string, CustomTypeConfig>;
+}
+type PermissionLevel = 'none' | 'read' | 'write' | 'admin';
+interface PermissionRule {
+    pattern: string;
+    permission: PermissionLevel;
+    users?: string[];
+}
+interface PermissionsConfig {
+    default?: PermissionLevel;
+    rules?: PermissionRule[];
+}
+interface DirectionalSyncConfig {
+    include: string[];
+    exclude?: string[];
+}
+interface SyncRule {
+    pattern: string;
+    direction?: 'to-codex' | 'from-codex' | 'bidirectional';
+}
+interface SyncConfig {
+    bidirectional?: boolean;
+    conflictResolution?: 'prompt' | 'local' | 'remote' | 'newest' | 'skip';
+    exclude?: string[];
+    rules?: SyncRule[];
+    to_codex?: DirectionalSyncConfig;
+    from_codex?: DirectionalSyncConfig;
+    default_to_codex?: string[];
+    default_from_codex?: string[];
+    environments?: Record<string, string>;
+}
+interface McpConfig {
+    enabled?: boolean;
+    port?: number;
+}
+interface ProjectArchiveConfig {
+    bucket?: string;
+    prefix?: string;
+    storageClass?: string;
+}
+interface ArchiveConfig {
+    projects?: Record<string, ProjectArchiveConfig>;
+}
+interface FileConfig {
+    sources?: Array<{
+        name: string;
+        path: string;
+        type?: string;
+    }>;
+}
+interface CodexYamlConfig {
+    organization: string;
+    project?: string;
+    codex_repo?: string;
+    cacheDir?: string;
+    cache?: CacheConfig;
+    storage?: StorageProviderConfig[];
+    types?: TypesConfig;
+    permissions?: PermissionsConfig;
+    sync?: SyncConfig;
+    mcp?: McpConfig;
+    archive?: ArchiveConfig;
+}
+interface UnifiedConfig {
+    codex?: CodexYamlConfig;
+    file?: FileConfig;
+    [key: string]: unknown;
+}
+interface ReadConfigOptions {
+    expandEnv?: boolean;
+    env?: Record<string, string | undefined>;
+    warnOnMissingEnv?: boolean;
+}
+declare function readCodexConfig(configPath: string, options?: ReadConfigOptions): Promise<CodexYamlConfig>;
+declare function readUnifiedConfig(configPath: string, options?: ReadConfigOptions): Promise<UnifiedConfig>;
+declare function isUnifiedConfig(config: unknown): config is UnifiedConfig;
+
+declare function parseDuration(duration: string | number): number;
+declare function parseSize(size: string | number): number;
+declare function formatBytes(bytes: number): string;
+declare function formatDuration(ms: number): string;
+declare function formatSeconds(seconds: number): string;
+declare function isValidDuration(value: string): boolean;
+declare function isValidSize(value: string): boolean;
+
+export { type ArchiveConfig, type ArtifactType, type AutoSyncPattern, AutoSyncPatternSchema, BUILT_IN_TYPES, CODEX_URI_PREFIX, type CacheEntry, type CacheEntryMetadata, type CacheEntryStatus, type CacheLookupResult, CacheManager, type CacheManagerConfig, CachePersistence, type CachePersistenceOptions, type CacheStats, type CodexConfig, CodexConfigSchema, CodexError, type CodexYamlConfig, CommonRules, ConfigurationError, type ConversionOptions, type ConvertedReference, type CustomSyncDestination, type CustomTypeConfig$1 as CustomTypeConfig, CustomTypeSchema, DEFAULT_CACHE_DIR, DEFAULT_FETCH_OPTIONS, DEFAULT_MIGRATION_OPTIONS, DEFAULT_PERMISSION_CONFIG, DEFAULT_SYNC_CONFIG, DEFAULT_TYPE, type DirectionalSyncConfig, type EvaluationResult, type EvaluationSummary, type ExpandEnvOptions, type FetchOptions, type FetchResult, type FileConfig, type FileInfo, FilePluginFileNotFoundError, type FilePluginFileNotFoundErrorOptions, FilePluginStorage, type FilePluginStorageOptions, type FileSyncStatus, GitHubStorage, type GitHubStorageOptions, HttpStorage, type HttpStorageOptions, LEGACY_PATTERNS, LEGACY_REF_PREFIX, type LegacyAutoSyncPattern, type LegacyCodexConfig, type LoadConfigOptions, LocalStorage, type LocalStorageOptions, type Metadata, MetadataSchema, type MigrationChange, type MigrationOptions, type MigrationResult, type ModernCodexConfig, type ModernSyncPattern, PERMISSION_LEVEL_ORDER, type ParseMetadataOptions, type ParseOptions, type ParseResult, type ParsedReference, type PermissionAction, type PermissionConfig, type PermissionContext, PermissionDeniedError, type PermissionLevel$1 as PermissionLevel, PermissionManager, type PermissionManagerConfig, type PermissionResult, type PermissionRule$1 as PermissionRule, type PermissionScope, type PlanStats, type ReadConfigOptions, type ReferenceConversionResult, type ResolveOptions, type ResolveOrgOptions, type ResolvedReference, type SerializedCacheEntry, type ShouldSyncOptions, StorageManager, type StorageManagerConfig, type StorageProvider, type StorageProviderConfig$1 as StorageProviderConfig, type StorageProviderType$1 as StorageProviderType, type SyncConfig$1 as SyncConfig, type SyncDirection, SyncManager, type SyncManagerConfig, type SyncManifest, type SyncManifestEntry, type SyncOperation, type SyncOptions, type SyncPlan, type SyncResult, type SyncRule$1 as SyncRule, type SyncRules, SyncRulesSchema, TTL, TypeRegistry, type TypeRegistryOptions, type TypesConfig$1 as TypesConfig, TypesConfigSchema, type UnifiedConfig, ValidationError, type VersionDetectionResult, type CacheConfig as YamlCacheConfig, type CustomTypeConfig as YamlCustomTypeConfig, type GitHubStorageConfig as YamlGitHubStorageConfig, type HttpStorageConfig as YamlHttpStorageConfig, type LocalStorageConfig as YamlLocalStorageConfig, type McpConfig as YamlMcpConfig, type PermissionLevel as YamlPermissionLevel, type PermissionRule as YamlPermissionRule, type PermissionsConfig as YamlPermissionsConfig, type S3StorageConfig as YamlS3StorageConfig, type StorageProviderConfig as YamlStorageProviderConfig, type StorageProviderType as YamlStorageProviderType, type SyncConfig as YamlSyncConfig, type SyncRule as YamlSyncRule, type TypesConfig as YamlTypesConfig, buildUri, calculateCachePath, calculateContentHash, convertLegacyReference, convertLegacyReferences, convertToUri, createCacheEntry, createCacheManager, createCachePersistence, createDefaultRegistry, createEmptyModernConfig, createEmptySyncPlan, createGitHubStorage, createHttpStorage, createLocalStorage, createPermissionManager, createRule, createRulesFromPatterns, createStorageManager, createSyncManager, createSyncPlan, deserializeCacheEntry, detectContentType, detectCurrentProject, detectVersion, estimateSyncTime, evaluatePath, evaluatePaths, evaluatePatterns, evaluatePermission, evaluatePermissions, expandEnvVars, expandEnvVarsInConfig, extendType, extractEnvVarNames, extractOrgFromRepoName, extractRawFrontmatter, filterByPatterns, filterByPermission, filterPlanOperations, filterSyncablePaths, findLegacyReferences, formatBytes, formatDuration, formatPlanSummary, formatSeconds, generateMigrationReport, generateReferenceMigrationSummary, getBuiltInType, getBuiltInTypeNames, getCacheEntryAge, getCacheEntryStatus, getCurrentContext, getCustomSyncDestinations, getDefaultCacheManager, getDefaultConfig, getDefaultDirectories, getDefaultPermissionManager, getDefaultRules, getDefaultStorageManager, getDirectory, getExtension, getFilename, getMigrationRequirements, getPlanStats, getRelativeCachePath, getRemainingTtl, getTargetRepos, hasContentChanged, hasEnvVars, hasFrontmatter, hasLegacyReferences, hasPermission as hasPermissionLevel, isBuiltInType, isCacheEntryFresh, isCacheEntryValid, isCurrentProjectUri, isLegacyConfig, isLegacyReference, isModernConfig, isAllowed as isPermissionAllowed, isUnifiedConfig, isValidDuration, isValidSize, isValidUri, levelGrants, loadConfig, loadCustomTypes, matchAnyPattern, matchPattern, maxLevel, mergeFetchOptions, mergeRules, mergeTypes, migrateConfig, migrateFileReferences, minLevel, needsMigration, parseCustomDestination, parseDuration, parseMetadata, parseReference, parseSize, parseTtl, readCodexConfig, readUnifiedConfig, resolveOrganization, resolveReference, resolveReferences, ruleMatchesAction, ruleMatchesContext, ruleMatchesPath, sanitizePath, serializeCacheEntry, setDefaultCacheManager, setDefaultPermissionManager, setDefaultStorageManager, shouldSyncToRepo, summarizeEvaluations, touchCacheEntry, validateCustomTypes, validateMetadata, validateMigratedConfig, validateOrg, validatePath, validateRules as validatePermissionRules, validateProject, validateRules$1 as validateRules, validateUri };