@fractary/codex 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -12,11 +12,252 @@ declare class ValidationError extends CodexError {
     constructor(message: string, options?: ErrorOptions);
 }
 
+interface ParsedReference {
+    uri: string;
+    org: string;
+    project: string;
+    path: string;
+}
+interface ParseOptions {
+    sanitize?: boolean;
+    strict?: boolean;
+}
+declare const CODEX_URI_PREFIX = "codex://";
+declare const LEGACY_REF_PREFIX = "@codex/";
+declare function isValidUri(uri: string): boolean;
+declare function isLegacyReference(ref: string): boolean;
+declare function convertLegacyReference(ref: string, defaultOrg: string): string | null;
+declare function parseReference(uri: string, options?: ParseOptions): ParsedReference | null;
+declare function buildUri(org: string, project: string, path?: string): string;
+declare function getExtension(uri: string): string;
+declare function getFilename(uri: string): string;
+declare function getDirectory(uri: string): string;
+
+interface ResolvedReference extends ParsedReference {
+    cachePath: string;
+    isCurrentProject: boolean;
+    localPath?: string;
+}
+interface ResolveOptions {
+    cacheDir?: string;
+    currentOrg?: string;
+    currentProject?: string;
+    cwd?: string;
+}
+declare const DEFAULT_CACHE_DIR = ".fractary/plugins/codex/cache";
+declare function detectCurrentProject(cwd?: string): {
+    org: string | null;
+    project: string | null;
+};
+declare function getCurrentContext(options?: ResolveOptions): {
+    org: string | null;
+    project: string | null;
+};
+declare function calculateCachePath(org: string, project: string, filePath: string, cacheDir: string): string;
+declare function resolveReference(uri: string, options?: ResolveOptions): ResolvedReference | null;
+declare function resolveReferences(uris: string[], options?: ResolveOptions): ResolvedReference[];
+declare function isCurrentProjectUri(uri: string, options?: ResolveOptions): boolean;
+declare function getRelativeCachePath(uri: string): string | null;
+
+declare function validatePath(filePath: string): boolean;
+declare function sanitizePath(filePath: string): string;
+declare function validateOrg(org: string): boolean;
+declare function validateProject(project: string): boolean;
+declare function validateUri(uri: string): boolean;
+
+interface ArtifactType {
+    name: string;
+    description: string;
+    patterns: string[];
+    defaultTtl: number;
+    archiveAfterDays: number | null;
+    archiveStorage: 'local' | 'cloud' | 'drive' | null;
+    syncPatterns?: string[];
+    excludePatterns?: string[];
+    permissions?: {
+        include: string[];
+        exclude: string[];
+    };
+}
+declare const TTL: {
+    readonly ONE_HOUR: 3600;
+    readonly ONE_DAY: 86400;
+    readonly ONE_WEEK: 604800;
+    readonly TWO_WEEKS: 1209600;
+    readonly ONE_MONTH: 2592000;
+    readonly ONE_YEAR: 31536000;
+};
+declare const BUILT_IN_TYPES: Record<string, ArtifactType>;
+declare const DEFAULT_TYPE: ArtifactType;
+declare function getBuiltInType(name: string): ArtifactType | undefined;
+declare function getBuiltInTypeNames(): string[];
+declare function isBuiltInType(name: string): boolean;
+
+interface TypeRegistryOptions {
+    includeBuiltIn?: boolean;
+    customTypes?: Record<string, Partial<ArtifactType>>;
+}
+declare class TypeRegistry {
+    private types;
+    private patternCache;
+    constructor(options?: TypeRegistryOptions);
+    get(name: string): ArtifactType | undefined;
+    register(type: ArtifactType): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    list(): ArtifactType[];
+    listNames(): string[];
+    detectType(filePath: string): string;
+    getTtl(filePath: string, override?: number): number;
+    getArchiveConfig(filePath: string): {
+        afterDays: number;
+        storage: 'local' | 'cloud' | 'drive';
+    } | null;
+    filterByType(typeName: string, files: string[]): string[];
+    isBuiltIn(name: string): boolean;
+    get size(): number;
+    clearCache(): void;
+}
+declare function createDefaultRegistry(): TypeRegistry;
+
+declare const CustomTypeSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    patterns: z.ZodArray<z.ZodString, "many">;
+    defaultTtl: z.ZodOptional<z.ZodNumber>;
+    archiveAfterDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    archiveStorage: z.ZodOptional<z.ZodNullable<z.ZodEnum<["local", "cloud", "drive"]>>>;
+    syncPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    permissions: z.ZodOptional<z.ZodObject<{
+        include: z.ZodArray<z.ZodString, "many">;
+        exclude: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        include: string[];
+        exclude: string[];
+    }, {
+        include: string[];
+        exclude: string[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    patterns: string[];
+    description?: string | undefined;
+    defaultTtl?: number | undefined;
+    archiveAfterDays?: number | null | undefined;
+    archiveStorage?: "local" | "cloud" | "drive" | null | undefined;
+    syncPatterns?: string[] | undefined;
+    excludePatterns?: string[] | undefined;
+    permissions?: {
+        include: string[];
+        exclude: string[];
+    } | undefined;
+}, {
+    patterns: string[];
+    description?: string | undefined;
+    defaultTtl?: number | undefined;
+    archiveAfterDays?: number | null | undefined;
+    archiveStorage?: "local" | "cloud" | "drive" | null | undefined;
+    syncPatterns?: string[] | undefined;
+    excludePatterns?: string[] | undefined;
+    permissions?: {
+        include: string[];
+        exclude: string[];
+    } | undefined;
+}>;
+type CustomTypeConfig = z.infer<typeof CustomTypeSchema>;
+declare const TypesConfigSchema: z.ZodObject<{
+    custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        patterns: z.ZodArray<z.ZodString, "many">;
+        defaultTtl: z.ZodOptional<z.ZodNumber>;
+        archiveAfterDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        archiveStorage: z.ZodOptional<z.ZodNullable<z.ZodEnum<["local", "cloud", "drive"]>>>;
+        syncPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        permissions: z.ZodOptional<z.ZodObject<{
+            include: z.ZodArray<z.ZodString, "many">;
+            exclude: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            include: string[];
+            exclude: string[];
+        }, {
+            include: string[];
+            exclude: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        patterns: string[];
+        description?: string | undefined;
+        defaultTtl?: number | undefined;
+        archiveAfterDays?: number | null | undefined;
+        archiveStorage?: "local" | "cloud" | "drive" | null | undefined;
+        syncPatterns?: string[] | undefined;
+        excludePatterns?: string[] | undefined;
+        permissions?: {
+            include: string[];
+            exclude: string[];
+        } | undefined;
+    }, {
+        patterns: string[];
+        description?: string | undefined;
+        defaultTtl?: number | undefined;
+        archiveAfterDays?: number | null | undefined;
+        archiveStorage?: "local" | "cloud" | "drive" | null | undefined;
+        syncPatterns?: string[] | undefined;
+        excludePatterns?: string[] | undefined;
+        permissions?: {
+            include: string[];
+            exclude: string[];
+        } | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    custom?: Record<string, {
+        patterns: string[];
+        description?: string | undefined;
+        defaultTtl?: number | undefined;
+        archiveAfterDays?: number | null | undefined;
+        archiveStorage?: "local" | "cloud" | "drive" | null | undefined;
+        syncPatterns?: string[] | undefined;
+        excludePatterns?: string[] | undefined;
+        permissions?: {
+            include: string[];
+            exclude: string[];
+        } | undefined;
+    }> | undefined;
+}, {
+    custom?: Record<string, {
+        patterns: string[];
+        description?: string | undefined;
+        defaultTtl?: number | undefined;
+        archiveAfterDays?: number | null | undefined;
+        archiveStorage?: "local" | "cloud" | "drive" | null | undefined;
+        syncPatterns?: string[] | undefined;
+        excludePatterns?: string[] | undefined;
+        permissions?: {
+            include: string[];
+            exclude: string[];
+        } | undefined;
+    }> | undefined;
+}>;
+type TypesConfig = z.infer<typeof TypesConfigSchema>;
+interface ValidationResult {
+    valid: boolean;
+    errors: Array<{
+        name: string;
+        field: string;
+        message: string;
+    }>;
+}
+declare function parseTtl(value: string | number): number;
+declare function validateCustomTypes(config: unknown): ValidationResult;
+declare function loadCustomTypes(config: TypesConfig): 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>;
+
 declare const MetadataSchema: z.ZodObject<{
     org: z.ZodOptional<z.ZodString>;
     system: z.ZodOptional<z.ZodString>;
     codex_sync_include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     codex_sync_exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    codex_sync_custom: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     visibility: z.ZodOptional<z.ZodEnum<["public", "internal", "private"]>>;
@@ -29,6 +270,7 @@ declare const MetadataSchema: z.ZodObject<{
     system: z.ZodOptional<z.ZodString>;
     codex_sync_include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     codex_sync_exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    codex_sync_custom: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     visibility: z.ZodOptional<z.ZodEnum<["public", "internal", "private"]>>;
@@ -41,6 +283,7 @@ declare const MetadataSchema: z.ZodObject<{
     system: z.ZodOptional<z.ZodString>;
     codex_sync_include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     codex_sync_exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    codex_sync_custom: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     visibility: z.ZodOptional<z.ZodEnum<["public", "internal", "private"]>>;
@@ -56,12 +299,12 @@ declare const AutoSyncPatternSchema: z.ZodObject<{
     include: z.ZodArray<z.ZodString, "many">;
     exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    pattern: string;
     include: string[];
+    pattern: string;
     exclude?: string[] | undefined;
 }, {
-    pattern: string;
     include: string[];
+    pattern: string;
     exclude?: string[] | undefined;
 }>;
 type AutoSyncPattern = z.infer<typeof AutoSyncPatternSchema>;
@@ -71,12 +314,12 @@ declare const SyncRulesSchema: z.ZodObject<{
         include: z.ZodArray<z.ZodString, "many">;
         exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
-        pattern: string;
         include: string[];
+        pattern: string;
         exclude?: string[] | undefined;
     }, {
-        pattern: string;
         include: string[];
+        pattern: string;
         exclude?: string[] | undefined;
     }>, "many">>;
     preventSelfSync: z.ZodOptional<z.ZodBoolean>;
@@ -86,8 +329,8 @@ declare const SyncRulesSchema: z.ZodObject<{
     defaultExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     autoSyncPatterns?: {
-        pattern: string;
         include: string[];
+        pattern: string;
         exclude?: string[] | undefined;
     }[] | undefined;
     preventSelfSync?: boolean | undefined;
@@ -97,8 +340,8 @@ declare const SyncRulesSchema: z.ZodObject<{
     defaultExclude?: string[] | undefined;
 }, {
     autoSyncPatterns?: {
-        pattern: string;
         include: string[];
+        pattern: string;
         exclude?: string[] | undefined;
     }[] | undefined;
     preventSelfSync?: boolean | undefined;
@@ -115,13 +358,13 @@ declare const CodexConfigSchema: z.ZodObject<{
         target: z.ZodOptional<z.ZodString>;
         systems: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        systems?: string | undefined;
         source?: string | undefined;
         target?: string | undefined;
-        systems?: string | undefined;
     }, {
+        systems?: string | undefined;
         source?: string | undefined;
         target?: string | undefined;
-        systems?: string | undefined;
     }>>;
     rules: z.ZodOptional<z.ZodObject<{
         autoSyncPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -129,12 +372,12 @@ declare const CodexConfigSchema: z.ZodObject<{
             include: z.ZodArray<z.ZodString, "many">;
             exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
-            pattern: string;
             include: string[];
+            pattern: string;
             exclude?: string[] | undefined;
         }, {
-            pattern: string;
             include: string[];
+            pattern: string;
             exclude?: string[] | undefined;
         }>, "many">>;
         preventSelfSync: z.ZodOptional<z.ZodBoolean>;
@@ -144,8 +387,8 @@ declare const CodexConfigSchema: z.ZodObject<{
         defaultExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         autoSyncPatterns?: {
-            pattern: string;
             include: string[];
+            pattern: string;
             exclude?: string[] | undefined;
         }[] | undefined;
         preventSelfSync?: boolean | undefined;
@@ -155,8 +398,8 @@ declare const CodexConfigSchema: z.ZodObject<{
         defaultExclude?: string[] | undefined;
     }, {
         autoSyncPatterns?: {
-            pattern: string;
             include: string[];
+            pattern: string;
             exclude?: string[] | undefined;
         }[] | undefined;
         preventSelfSync?: boolean | undefined;
@@ -168,14 +411,14 @@ declare const CodexConfigSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     organizationSlug: string;
     directories?: {
+        systems?: string | undefined;
         source?: string | undefined;
         target?: string | undefined;
-        systems?: string | undefined;
     } | undefined;
     rules?: {
         autoSyncPatterns?: {
-            pattern: string;
             include: string[];
+            pattern: string;
             exclude?: string[] | undefined;
         }[] | undefined;
         preventSelfSync?: boolean | undefined;
@@ -187,14 +430,14 @@ declare const CodexConfigSchema: z.ZodObject<{
 }, {
     organizationSlug: string;
     directories?: {
+        systems?: string | undefined;
         source?: string | undefined;
         target?: string | undefined;
-        systems?: string | undefined;
     } | undefined;
     rules?: {
         autoSyncPatterns?: {
-            pattern: string;
             include: string[];
+            pattern: string;
             exclude?: string[] | undefined;
         }[] | undefined;
         preventSelfSync?: boolean | undefined;
@@ -271,4 +514,740 @@ declare function getTargetRepos(options: {
     rules?: SyncRules;
 }): string[];
 
-export { type AutoSyncPattern, AutoSyncPatternSchema, type CodexConfig, CodexConfigSchema, CodexError, ConfigurationError, type LoadConfigOptions, type Metadata, MetadataSchema, type ParseMetadataOptions, type ParseResult, type ResolveOrgOptions, type ShouldSyncOptions, type SyncRules, SyncRulesSchema, ValidationError, evaluatePatterns, extractOrgFromRepoName, extractRawFrontmatter, filterByPatterns, getDefaultConfig, getDefaultDirectories, getDefaultRules, getTargetRepos, hasFrontmatter, loadConfig, matchAnyPattern, matchPattern, parseMetadata, resolveOrganization, shouldSyncToRepo, validateMetadata };
+interface CustomSyncDestination {
+    repo: string;
+    path: string;
+}
+declare function parseCustomDestination(value: string): CustomSyncDestination;
+declare function getCustomSyncDestinations(metadata: Metadata): CustomSyncDestination[];
+
+type StorageProviderType = 'local' | 'github' | 'http' | 's3' | 'r2' | 'gcs' | 'drive';
+interface FetchResult {
+    content: Buffer;
+    contentType: string;
+    size: number;
+    source: string;
+    metadata?: Record<string, unknown>;
+}
+interface FetchOptions {
+    timeout?: number;
+    maxRetries?: number;
+    token?: string;
+    branch?: string;
+    followRedirects?: boolean;
+    maxSize?: number;
+}
+interface StorageProvider {
+    readonly name: string;
+    readonly type: StorageProviderType;
+    fetch(reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
+    exists(reference: ResolvedReference, options?: FetchOptions): Promise<boolean>;
+    canHandle(reference: ResolvedReference): boolean;
+}
+interface StorageProviderConfig {
+    type: StorageProviderType;
+    options?: Record<string, unknown>;
+    timeout?: number;
+    maxRetries?: number;
+    auth?: {
+        tokenEnv?: string;
+        token?: string;
+    };
+}
+declare const DEFAULT_FETCH_OPTIONS: Required<FetchOptions>;
+declare function mergeFetchOptions(options?: FetchOptions): Required<FetchOptions>;
+declare function detectContentType(path: string): string;
+
+interface LocalStorageOptions {
+    baseDir?: string;
+}
+declare class LocalStorage implements StorageProvider {
+    readonly name = "local";
+    readonly type: "local";
+    private baseDir;
+    constructor(options?: LocalStorageOptions);
+    canHandle(reference: ResolvedReference): boolean;
+    fetch(reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
+    exists(reference: ResolvedReference): Promise<boolean>;
+    readText(filePath: string): Promise<string>;
+    write(filePath: string, content: string | Buffer): Promise<void>;
+    delete(filePath: string): Promise<boolean>;
+    list(dirPath: string): Promise<string[]>;
+}
+declare function createLocalStorage(options?: LocalStorageOptions): LocalStorage;
+
+interface GitHubStorageOptions {
+    token?: string;
+    tokenEnv?: string;
+    apiBaseUrl?: string;
+    rawBaseUrl?: string;
+    defaultBranch?: string;
+}
+declare class GitHubStorage implements StorageProvider {
+    readonly name = "github";
+    readonly type: "github";
+    private apiBaseUrl;
+    private rawBaseUrl;
+    private defaultBranch;
+    private token?;
+    constructor(options?: GitHubStorageOptions);
+    canHandle(reference: ResolvedReference): boolean;
+    fetch(reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
+    private fetchRaw;
+    private fetchApi;
+    exists(reference: ResolvedReference, options?: FetchOptions): Promise<boolean>;
+    getRepoInfo(org: string, project: string): Promise<{
+        defaultBranch: string;
+        private: boolean;
+        size: number;
+    } | null>;
+}
+declare function createGitHubStorage(options?: GitHubStorageOptions): GitHubStorage;
+
+interface HttpStorageOptions {
+    timeout?: number;
+    maxSize?: number;
+    headers?: Record<string, string>;
+    userAgent?: string;
+}
+declare class HttpStorage implements StorageProvider {
+    readonly name = "http";
+    readonly type: "http";
+    private defaultTimeout;
+    private defaultMaxSize;
+    private defaultHeaders;
+    constructor(options?: HttpStorageOptions);
+    canHandle(_reference: ResolvedReference): boolean;
+    fetch(reference: ResolvedReference, options?: FetchOptions): Promise<FetchResult>;
+    fetchUrl(url: string, options?: FetchOptions): Promise<FetchResult>;
+    exists(reference: ResolvedReference, options?: FetchOptions): Promise<boolean>;
+    urlExists(url: string, options?: FetchOptions): Promise<boolean>;
+}
+declare function createHttpStorage(options?: HttpStorageOptions): HttpStorage;
+
+interface StorageManagerConfig {
+    local?: LocalStorageOptions;
+    github?: GitHubStorageOptions;
+    http?: HttpStorageOptions;
+    priority?: StorageProviderType[];
+    enableCaching?: boolean;
+}
+declare class StorageManager {
+    private providers;
+    private priority;
+    constructor(config?: StorageManagerConfig);
+    registerProvider(provider: StorageProvider): void;
+    removeProvider(type: StorageProviderType): boolean;
+    getProvider(type: StorageProviderType): 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>;
+    fetchMany(references: ResolvedReference[], options?: FetchOptions): Promise<Map<string, FetchResult | Error>>;
+    getStatus(): Array<{
+        type: StorageProviderType;
+        name: string;
+        priority: number;
+    }>;
+}
+declare function createStorageManager(config?: StorageManagerConfig): StorageManager;
+declare function getDefaultStorageManager(): StorageManager;
+declare function setDefaultStorageManager(manager: StorageManager): void;
+
+type CacheEntryStatus = 'fresh' | 'stale' | 'expired';
+interface CacheEntryMetadata {
+    uri: string;
+    cachedAt: number;
+    expiresAt: number;
+    ttl: number;
+    etag?: string;
+    lastModified?: string;
+    contentHash: string;
+    size: number;
+    contentType: string;
+    source: string;
+    accessCount: number;
+    lastAccessedAt: number;
+    providerMetadata?: Record<string, unknown>;
+}
+interface CacheEntry {
+    metadata: CacheEntryMetadata;
+    content: Buffer;
+}
+interface SerializedCacheEntry {
+    metadata: CacheEntryMetadata;
+    content: string;
+}
+declare function calculateContentHash(content: Buffer): string;
+declare function createCacheEntry(uri: string, result: FetchResult, ttl: number): CacheEntry;
+declare function getCacheEntryStatus(entry: CacheEntry): CacheEntryStatus;
+declare function isCacheEntryValid(entry: CacheEntry): boolean;
+declare function isCacheEntryFresh(entry: CacheEntry): boolean;
+declare function touchCacheEntry(entry: CacheEntry): void;
+declare function serializeCacheEntry(entry: CacheEntry): SerializedCacheEntry;
+declare function deserializeCacheEntry(serialized: SerializedCacheEntry): CacheEntry;
+declare function getRemainingTtl(entry: CacheEntry): number;
+declare function hasContentChanged(entry: CacheEntry, newContent: Buffer): boolean;
+declare function getCacheEntryAge(entry: CacheEntry): number;
+
+interface CachePersistenceOptions {
+    cacheDir: string;
+    extension?: string;
+    atomicWrites?: boolean;
+}
+interface CacheStats {
+    entryCount: number;
+    totalSize: number;
+    freshCount: number;
+    staleCount: number;
+    expiredCount: number;
+}
+declare class CachePersistence {
+    private cacheDir;
+    private extension;
+    private atomicWrites;
+    constructor(options: CachePersistenceOptions);
+    getCachePath(uri: string): string;
+    getMetadataPath(uri: string): string;
+    read(uri: string): Promise<CacheEntry | null>;
+    write(entry: CacheEntry): Promise<void>;
+    delete(uri: string): Promise<boolean>;
+    exists(uri: string): Promise<boolean>;
+    list(): Promise<string[]>;
+    private listFilesRecursive;
+    clear(): Promise<number>;
+    clearExpired(): Promise<number>;
+    getStats(): Promise<CacheStats>;
+    ensureDir(): Promise<void>;
+    getCacheDir(): string;
+}
+declare function createCachePersistence(options: CachePersistenceOptions): CachePersistence;
+
+interface CacheManagerConfig {
+    cacheDir: string;
+    defaultTtl?: number;
+    maxMemoryEntries?: number;
+    maxMemorySize?: number;
+    enablePersistence?: boolean;
+    staleWhileRevalidate?: boolean;
+    backgroundRefreshThreshold?: number;
+}
+interface CacheLookupResult {
+    entry: CacheEntry | null;
+    hit: boolean;
+    fresh: boolean;
+    source: 'memory' | 'disk' | 'network' | 'none';
+}
+declare class CacheManager {
+    private memoryCache;
+    private persistence;
+    private storage;
+    private config;
+    private accessOrder;
+    private refreshPromises;
+    constructor(config: CacheManagerConfig);
+    setStorageManager(storage: StorageManager): void;
+    get(reference: ResolvedReference, options?: FetchOptions & {
+        ttl?: number;
+    }): Promise<FetchResult>;
+    has(uri: string): Promise<boolean>;
+    lookup(uri: string): Promise<CacheLookupResult>;
+    set(uri: string, result: FetchResult, ttl?: number): Promise<CacheEntry>;
+    invalidate(uri: string): Promise<boolean>;
+    invalidatePattern(pattern: RegExp): Promise<number>;
+    clear(): Promise<void>;
+    clearExpired(): Promise<number>;
+    getStats(): Promise<CacheStats & {
+        memoryEntries: number;
+        memorySize: number;
+    }>;
+    preload(references: ResolvedReference[], options?: FetchOptions): Promise<void>;
+    getMetadata(uri: string): Promise<CacheEntryMetadata | null>;
+    getTtl(uri: string): Promise<number | null>;
+    private fetchAndCache;
+    private backgroundRefresh;
+    private setMemoryEntry;
+    private evictIfNeeded;
+    private evictOldest;
+    private removeFromAccessOrder;
+    private entryToResult;
+}
+declare function createCacheManager(config: CacheManagerConfig): CacheManager;
+declare function getDefaultCacheManager(): CacheManager;
+declare function setDefaultCacheManager(manager: CacheManager): void;
+
+interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+interface McpResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+interface McpResourceTemplate {
+    uriTemplate: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+interface FetchToolArgs {
+    uri: string;
+    branch?: string;
+    noCache?: boolean;
+}
+interface SearchToolArgs {
+    query: string;
+    org?: string;
+    project?: string;
+    limit?: number;
+    type?: string;
+}
+interface ListToolArgs {
+    org?: string;
+    project?: string;
+    includeExpired?: boolean;
+}
+interface InvalidateToolArgs {
+    pattern: string;
+}
+interface ToolResult {
+    content: Array<{
+        type: 'text' | 'resource';
+        text?: string;
+        resource?: {
+            uri: string;
+            mimeType?: string;
+            text?: string;
+            blob?: string;
+        };
+    }>;
+    isError?: boolean;
+}
+interface ResourceContent {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+interface McpCapabilities {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+}
+interface McpServerInfo {
+    name: string;
+    version: string;
+    capabilities: McpCapabilities;
+}
+interface SearchResult {
+    uri: string;
+    title?: string;
+    snippet?: string;
+    score?: number;
+    metadata?: Record<string, unknown>;
+}
+
+declare const CODEX_TOOLS: McpTool[];
+interface ToolHandlerContext {
+    cache: CacheManager;
+    storage: StorageManager;
+}
+declare function handleFetch(args: FetchToolArgs, ctx: ToolHandlerContext): Promise<ToolResult>;
+declare function handleSearch(args: SearchToolArgs, ctx: ToolHandlerContext): Promise<ToolResult>;
+declare function handleList(args: ListToolArgs, ctx: ToolHandlerContext): Promise<ToolResult>;
+declare function handleInvalidate(args: InvalidateToolArgs, ctx: ToolHandlerContext): Promise<ToolResult>;
+declare function handleToolCall(name: string, args: Record<string, unknown>, ctx: ToolHandlerContext): Promise<ToolResult>;
+
+interface McpServerConfig {
+    name?: string;
+    version?: string;
+    cache: CacheManager;
+    storage: StorageManager;
+}
+declare class McpServer {
+    private config;
+    private toolContext;
+    constructor(config: McpServerConfig);
+    getServerInfo(): McpServerInfo;
+    getCapabilities(): McpCapabilities;
+    listTools(): McpTool[];
+    callTool(name: string, args: Record<string, unknown>): Promise<ToolResult>;
+    listResources(): Promise<McpResource[]>;
+    listResourceTemplates(): McpResourceTemplate[];
+    readResource(uri: string): Promise<ResourceContent[]>;
+    handleRequest(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    processMessage(message: string): Promise<string>;
+}
+declare function createMcpServer(config: McpServerConfig): McpServer;
+
+type SyncDirection = 'to-codex' | 'from-codex' | 'bidirectional';
+type SyncOperation = 'create' | 'update' | 'delete' | 'skip' | 'conflict';
+interface FileSyncStatus {
+    path: string;
+    operation: SyncOperation;
+    size?: number;
+    mtime?: number;
+    hash?: string;
+    reason?: string;
+}
+interface SyncManifestEntry {
+    path: string;
+    hash: string;
+    size: number;
+    syncedAt: number;
+    source: 'local' | 'remote';
+}
+interface SyncManifest {
+    version: number;
+    org: string;
+    project: string;
+    lastSync: number;
+    entries: Record<string, SyncManifestEntry>;
+}
+interface SyncPlan {
+    direction: SyncDirection;
+    source: string;
+    target: string;
+    files: FileSyncStatus[];
+    totalFiles: number;
+    totalBytes: number;
+    estimatedTime?: number;
+    conflicts: FileSyncStatus[];
+    skipped: FileSyncStatus[];
+}
+interface SyncResult {
+    success: boolean;
+    plan: SyncPlan;
+    synced: number;
+    failed: number;
+    skipped: number;
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+    duration: number;
+    timestamp: number;
+}
+interface SyncOptions {
+    direction?: SyncDirection;
+    dryRun?: boolean;
+    force?: boolean;
+    delete?: boolean;
+    include?: string[];
+    exclude?: string[];
+    maxFiles?: number;
+    timeout?: number;
+    onProgress?: (current: number, total: number, file: string) => void;
+}
+interface SyncRule {
+    pattern: string;
+    include: boolean;
+    priority?: number;
+    direction?: SyncDirection;
+}
+interface SyncConfig {
+    defaultDirection: SyncDirection;
+    rules: SyncRule[];
+    defaultExcludes: string[];
+    deleteOrphans: boolean;
+    conflictStrategy: 'newest' | 'local' | 'remote' | 'manual';
+}
+declare const DEFAULT_SYNC_CONFIG: SyncConfig;
+
+interface EvaluationResult {
+    path: string;
+    shouldSync: boolean;
+    matchedRule?: SyncRule;
+    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[];
+interface EvaluationSummary {
+    total: number;
+    included: number;
+    excluded: number;
+    byReason: Record<string, number>;
+}
+declare function summarizeEvaluations(results: Map<string, EvaluationResult>): EvaluationSummary;
+declare function validateRules$1(rules: SyncRule[]): string[];
+
+interface FileInfo {
+    path: string;
+    size: number;
+    mtime: number;
+    hash?: string;
+}
+declare function createSyncPlan(sourceFiles: FileInfo[], targetFiles: FileInfo[], options: SyncOptions, config: SyncConfig): 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;
+interface PlanStats {
+    creates: number;
+    updates: number;
+    deletes: number;
+    skips: number;
+    conflicts: number;
+    totalBytes: number;
+}
+declare function getPlanStats(plan: SyncPlan): PlanStats;
+declare function formatPlanSummary(plan: SyncPlan): string;
+
+interface SyncManagerConfig {
+    localStorage: LocalStorage;
+    config?: Partial<SyncConfig>;
+    manifestPath?: string;
+}
+declare class SyncManager {
+    private localStorage;
+    private config;
+    private manifestPath;
+    private manifest;
+    constructor(options: SyncManagerConfig);
+    loadManifest(): Promise<SyncManifest | null>;
+    saveManifest(manifest: SyncManifest): Promise<void>;
+    getOrCreateManifest(org: string, project: string): Promise<SyncManifest>;
+    listLocalFiles(directory: string): Promise<FileInfo[]>;
+    createPlan(_org: string, _project: string, sourceDir: string, targetFiles: FileInfo[], options?: SyncOptions): Promise<SyncPlan>;
+    executePlan(plan: SyncPlan, options?: SyncOptions): Promise<SyncResult>;
+    updateManifest(org: string, project: string, syncedFiles: FileSyncStatus[]): Promise<void>;
+    getFileStatus(path: string): Promise<SyncManifestEntry | null>;
+    isFileSynced(path: string): Promise<boolean>;
+    getLastSyncTime(): Promise<number | null>;
+    clearManifest(): Promise<void>;
+    getConfig(): SyncConfig;
+    updateConfig(updates: Partial<SyncConfig>): void;
+}
+declare function createSyncManager(config: SyncManagerConfig): SyncManager;
+
+type PermissionLevel = 'none' | 'read' | 'write' | 'admin';
+type PermissionScope = 'global' | 'org' | 'project' | 'path';
+type PermissionAction = 'fetch' | 'cache' | 'sync' | 'invalidate' | 'manage';
+interface PermissionRule {
+    id?: string;
+    pattern: string;
+    actions: PermissionAction[];
+    level: PermissionLevel;
+    scope: PermissionScope;
+    org?: string;
+    project?: string;
+    priority?: number;
+    description?: string;
+    enabled?: boolean;
+}
+interface PermissionContext {
+    org?: string;
+    project?: string;
+    environment?: string;
+    identity?: string;
+    metadata?: Record<string, unknown>;
+}
+interface PermissionResult {
+    allowed: boolean;
+    level: PermissionLevel;
+    matchedRule?: PermissionRule;
+    reason: string;
+}
+interface PermissionConfig {
+    defaultLevel: PermissionLevel;
+    defaultAllow: boolean;
+    rules: PermissionRule[];
+    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 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 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 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 createRule(options: {
+    pattern: string;
+    actions: PermissionAction[];
+    level: PermissionLevel;
+    scope?: PermissionRule['scope'];
+    org?: string;
+    project?: string;
+    priority?: number;
+    description?: string;
+}): PermissionRule;
+declare const CommonRules: {
+    allowDocs: () => PermissionRule;
+    denyPrivate: () => PermissionRule;
+    readOnlySpecs: () => PermissionRule;
+    adminManage: () => PermissionRule;
+};
+
+interface PermissionManagerConfig {
+    config?: Partial<PermissionConfig>;
+    defaultContext?: PermissionContext;
+}
+declare class PermissionManager {
+    private config;
+    private defaultContext;
+    constructor(options?: PermissionManagerConfig);
+    isAllowed(path: string, action: PermissionAction, context?: PermissionContext): boolean;
+    hasPermission(path: string, action: PermissionAction, requiredLevel: PermissionLevel, 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;
+    removeRule(id: string): boolean;
+    getRules(): PermissionRule[];
+    clearRules(): void;
+    setRules(rules: PermissionRule[]): void;
+    getConfig(): PermissionConfig;
+    updateConfig(updates: Partial<Omit<PermissionConfig, 'rules'>>): void;
+    setDefaultContext(context: PermissionContext): void;
+    getDefaultContext(): PermissionContext;
+    enable(): void;
+    disable(): void;
+    isEnforced(): boolean;
+    assertPermission(path: string, action: PermissionAction, requiredLevel?: PermissionLevel, context?: PermissionContext): void;
+}
+declare class PermissionDeniedError extends Error {
+    readonly path: string;
+    readonly action: PermissionAction;
+    readonly result: PermissionResult;
+    constructor(message: string, path: string, action: PermissionAction, result: PermissionResult);
+}
+declare function createPermissionManager(config?: PermissionManagerConfig): PermissionManager;
+declare function getDefaultPermissionManager(): PermissionManager;
+declare function setDefaultPermissionManager(manager: PermissionManager): void;
+
+interface LegacyCodexConfig {
+    org?: string;
+    defaultOrg?: string;
+    codexRepo?: string;
+    codexPath?: string;
+    autoSync?: LegacyAutoSyncPattern[];
+    syncRules?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    environments?: Record<string, Partial<LegacyCodexConfig>>;
+}
+interface LegacyAutoSyncPattern {
+    pattern: string;
+    destination?: string;
+    targets?: string[];
+    bidirectional?: boolean;
+}
+interface ModernCodexConfig {
+    version: '3.0';
+    organization: {
+        name: string;
+        codexRepo: string;
+    };
+    sync: {
+        patterns: ModernSyncPattern[];
+        include: string[];
+        exclude: string[];
+        defaultDirection: 'to-codex' | 'from-codex' | 'bidirectional';
+    };
+    cache?: {
+        directory?: string;
+        defaultTtl?: number;
+        maxSize?: number;
+    };
+    environments?: Record<string, Partial<Omit<ModernCodexConfig, 'version'>>>;
+}
+interface ModernSyncPattern {
+    pattern: string;
+    target?: string;
+    direction?: 'to-codex' | 'from-codex' | 'bidirectional';
+    priority?: number;
+}
+interface MigrationResult {
+    success: boolean;
+    config?: ModernCodexConfig;
+    warnings: string[];
+    errors: string[];
+    changes: MigrationChange[];
+}
+interface MigrationChange {
+    type: 'renamed' | 'converted' | 'removed' | 'added' | 'transformed';
+    path: string;
+    oldValue?: unknown;
+    newValue?: unknown;
+    description: string;
+}
+interface MigrationOptions {
+    preserveUnknown?: boolean;
+    strict?: boolean;
+    defaultOrg?: string;
+    defaultCodexRepo?: string;
+}
+interface VersionDetectionResult {
+    version: '2.x' | '3.0' | 'unknown';
+    confidence: 'high' | 'medium' | 'low';
+    reason: string;
+}
+
+declare function detectVersion(config: unknown): VersionDetectionResult;
+declare function isModernConfig(config: unknown): config is ModernCodexConfig;
+declare function isLegacyConfig(config: unknown): config is LegacyCodexConfig;
+declare function needsMigration(config: unknown): boolean;
+declare function getMigrationRequirements(config: unknown): string[];
+
+declare const DEFAULT_MIGRATION_OPTIONS: MigrationOptions;
+declare function migrateConfig(config: unknown, options?: MigrationOptions): MigrationResult;
+declare function validateMigratedConfig(config: ModernCodexConfig): string[];
+declare function generateMigrationReport(result: MigrationResult): string;
+declare function createEmptyModernConfig(org: string, codexRepo: string): ModernCodexConfig;
+
+declare const LEGACY_PATTERNS: {
+    CODEX_TAG: RegExp;
+    CODEX_BRACKET: RegExp;
+    CODEX_MUSTACHE: RegExp;
+    SIMPLE_PATH: RegExp;
+};
+interface ReferenceConversionResult {
+    original: string;
+    converted: string;
+    references: ConvertedReference[];
+    modified: boolean;
+}
+interface ConvertedReference {
+    original: string;
+    uri: string;
+    position: number;
+    format: 'codex-tag' | 'codex-bracket' | 'codex-mustache' | 'simple-path';
+}
+interface ConversionOptions {
+    defaultOrg?: string;
+    defaultProject?: string;
+    preserveWrapper?: boolean;
+}
+declare function convertLegacyReferences(text: string, options?: ConversionOptions): ReferenceConversionResult;
+declare function convertToUri(reference: string, options?: ConversionOptions): string;
+declare function findLegacyReferences(text: string): ConvertedReference[];
+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_TOOLS, 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 FetchToolArgs, type FileInfo, type FileSyncStatus, GitHubStorage, type GitHubStorageOptions, HttpStorage, type HttpStorageOptions, type InvalidateToolArgs, LEGACY_PATTERNS, LEGACY_REF_PREFIX, type LegacyAutoSyncPattern, type LegacyCodexConfig, type ListToolArgs, type LoadConfigOptions, LocalStorage, type LocalStorageOptions, type McpCapabilities, type McpResource, type McpResourceTemplate, McpServer, type McpServerConfig, type McpServerInfo, type McpTool, 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 ResourceContent, type SearchResult, type SearchToolArgs, 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, type ToolHandlerContext, type ToolResult, TypeRegistry, type TypeRegistryOptions, type TypesConfig, TypesConfigSchema, ValidationError, type VersionDetectionResult, buildUri, calculateCachePath, calculateContentHash, convertLegacyReference, convertLegacyReferences, convertToUri, createCacheEntry, createCacheManager, createCachePersistence, createDefaultRegistry, createEmptyModernConfig, createEmptySyncPlan, createGitHubStorage, createHttpStorage, createLocalStorage, createMcpServer, 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, handleFetch, handleInvalidate, handleList, handleSearch, handleToolCall, 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 };