@cldmv/slothlet-types 3.10.0

package/lib/handlers/permission-manager.d.mts

@@ -0,0 +1,55 @@
+export class PermissionManager extends ComponentBase {
+    static slothletProperty: string;
+    addRule(rule: any, ownerModuleID?: null, ruleId?: null): string;
+    removeRule(ruleId: any, callerModuleID?: null): boolean;
+    checkAccess(callerPath: any, targetPath: any, callerFilePath?: null, targetFilePath?: null, runtimeContext?: null, options?: null): any;
+    matchesCondition(condition: any, runtimeContext?: null): boolean;
+    enforceAccess(callerPath: any, targetPath: any, callerFilePath?: null, targetFilePath?: null, runtimeContext?: null): any;
+    enforceHookAccess(callerPath: any, hookPath: any, hookType: any, callerFilePath?: null, targetFilePath?: null, runtimeContext?: null): any;
+    checkHookAccess(callerPath: any, hookPath: any, hookType: any, callerFilePath?: null, targetFilePath?: null, runtimeContext?: null): any;
+    getRulesForPath(targetPath: any): {
+        id: any;
+        caller: any;
+        target: any;
+        effect: any;
+        condition: any;
+        ownerModuleID: any;
+        registeredAt: any;
+    }[];
+    getRulesByModule(moduleID: any): {
+        id: any;
+        caller: any;
+        target: any;
+        effect: any;
+        condition: any;
+        ownerModuleID: any;
+        registeredAt: any;
+    }[];
+    getRulesForCaller(callerPath: any): {
+        id: any;
+        caller: any;
+        target: any;
+        effect: any;
+        condition: any;
+        ownerModuleID: any;
+        registeredAt: any;
+    }[];
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    isReadGatingEnabled(): boolean;
+    setReadGating(value: any): void;
+    exportRules(): {
+        rule: {
+            caller: any;
+            target: any;
+            effect: any;
+        };
+        ownerModuleID: any;
+    }[];
+    importRules(registrations: any): void;
+    shutdown(): Promise<void>;
+    debug(category: any, data: any): void;
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/handlers/unified-wrapper.d.mts

@@ -0,0 +1,36 @@
+export namespace TYPE_STATES {
+    let UNMATERIALIZED: symbol;
+    let IN_FLIGHT: symbol;
+}
+export class UnifiedWrapper extends ComponentBase {
+    static _cloneImpl(value: any): any;
+    static _extractFullImpl(wrapper: any): any;
+    constructor(slothlet: any, { mode, apiPath, initialImpl, materializeFunc, isCallable, materializeOnCreate, filePath, moduleID, sourceFolder }: {
+        mode: any;
+        apiPath: any;
+        initialImpl?: null | undefined;
+        materializeFunc?: null | undefined;
+        isCallable: any;
+        materializeOnCreate?: boolean | undefined;
+        filePath?: null | undefined;
+        moduleID?: null | undefined;
+        sourceFolder?: null | undefined;
+    });
+    get ____slothletInternal(): null | undefined;
+    ____inspectCustom(____depth: any, ____options: any, ____inspect: any): any;
+    get __impl(): any;
+    _applyNewImpl(newImpl: any, forceReuseChildren?: boolean): void;
+    ___setImpl(newImpl: any, moduleID?: null, forceReuseChildren?: boolean): void;
+    ___resetLazy(newMaterializeFunc: any): void;
+    ___materialize(): Promise<any>;
+    _materialize(): Promise<any>;
+    ___invalidate(): void;
+    ___adoptImplChildren(forceReuseChildren?: boolean): void;
+    ___createChildWrapper(key: any, value: any): any;
+    ___createWaitingProxy(propChain?: any[]): any;
+    createProxy(): any;
+    lastSyncError: unknown;
+    #private;
+}
+export function resolveWrapper(value: any): any;
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/handlers/version-manager.d.mts

@@ -0,0 +1,36 @@
+export class VersionManager extends ComponentBase {
+    static slothletProperty: string;
+    registerVersion(logicalPath: any, versionTag: any, moduleID: any, versionMeta: any, isDefault: any): void;
+    unregisterVersion(logicalPath: any, versionTag: any): boolean;
+    getVersionKeyForModule(moduleID: any): any;
+    hasDispatcher(logicalPath: any): boolean;
+    getVersionMetadata(moduleID: any): any;
+    getVersionMetadataByPath(logicalPath: any, versionTag: any): any;
+    setVersionMetadataByPath(logicalPath: any, versionTag: any, patch: any): void;
+    list(logicalPath: any): {
+        versions: {};
+        default: any;
+    } | undefined;
+    setDefault(logicalPath: any, versionTag: any): void;
+    getDefaultVersion(logicalPath: any): any;
+    resolveForPath(logicalPath: any, allVersions: any, caller: any): any;
+    buildAllVersionsArg(logicalPath: any): {};
+    buildCallerArg(callerWrapper: any): {
+        version: null;
+        default: null;
+        metadata: any;
+        versionMetadata: null;
+    } | {
+        version: any;
+        default: boolean;
+        metadata: any;
+        versionMetadata: any;
+    };
+    createDispatcher(logicalPath: any): any;
+    updateDispatcher(logicalPath: any): void;
+    teardownDispatcher(logicalPath: any): void;
+    onVersionedModuleReload(moduleID: any): void;
+    shutdown(): void;
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/helpers/class-instance-wrapper.d.mts

@@ -0,0 +1,3 @@
+export function runtime_isClassInstance(val: any): boolean;
+export function runtime_shouldWrapMethod(value: any, prop: any): boolean;
+export function runtime_wrapClassInstance(instance: any, contextManager: any, instanceID: any, instanceCache: any): any;

package/lib/helpers/config.d.mts

@@ -0,0 +1,152 @@
+export class Config extends ComponentBase {
+    static slothletProperty: string;
+    normalizeCollision(collision: any): {
+        initial: string;
+        api: string;
+    };
+    normalizeRuntime(runtime: any): "async" | "live";
+    normalizeMode(mode: any): "eager" | "lazy";
+    normalizeMutations(mutations: any): {
+        add: boolean;
+        remove: boolean;
+        reload: boolean;
+        permissions: boolean;
+    };
+    normalizeDebug(debug: any): {
+        builder: any;
+        api: any;
+        index: any;
+        modes: any;
+        wrapper: any;
+        ownership: any;
+        context: any;
+        initialization: any;
+        materialize: any;
+        versioning: any;
+        permissions: any;
+    };
+    normalizeEnvTarget(platform: any, hasManifest?: boolean): "browser" | "node";
+    normalizeHook(hook: any): {
+        enabled: boolean;
+        pattern: string;
+        suppressErrors: boolean;
+        pin: boolean;
+    };
+    transformConfig(config?: {}): {
+        base: any;
+        dir: any;
+        manifest: any;
+        resolveModuleSpecifier: any;
+        envTarget: string;
+        mode: string;
+        runtime: string;
+        apiDepth: any;
+        reference: any;
+        context: any;
+        i18n: {
+            language: any;
+        } | null;
+        debug: {
+            builder: any;
+            api: any;
+            index: any;
+            modes: any;
+            wrapper: any;
+            ownership: any;
+            context: any;
+            initialization: any;
+            materialize: any;
+            versioning: any;
+            permissions: any;
+        };
+        diagnostics: boolean;
+        hook: {
+            enabled: boolean;
+            pattern: string;
+            suppressErrors: boolean;
+            pin: boolean;
+        };
+        collision: {
+            initial: string;
+            api: string;
+        };
+        api: {
+            collision: {
+                initial: string;
+                api: string;
+            };
+            mutations: {
+                add: boolean;
+                remove: boolean;
+                reload: boolean;
+                permissions: boolean;
+            } | {
+                add: boolean;
+                remove: boolean;
+                reload: boolean;
+            };
+        };
+        scope: any;
+        tracking: {
+            materialization: boolean;
+        };
+        backgroundMaterialize: boolean;
+        silent: boolean;
+        typescript: {
+            enabled: boolean;
+            mode: string;
+            types?: undefined;
+            target?: undefined;
+            sourcemap?: undefined;
+        } | {
+            enabled: boolean;
+            mode: string;
+            types: any;
+            target: any;
+            sourcemap: any;
+        } | null;
+        env: {
+            include: any;
+        } | null;
+        versionDispatcher: any;
+        permissions: {
+            defaultPolicy: string;
+            enabled: boolean;
+            audit: string;
+            readGating: boolean;
+            rules: any;
+        } | null;
+        suppressFixes: Set<any>;
+    };
+    normalizeSuppressFixes(suppressFixes: any, silent: any): Set<any>;
+    normalizeTypeScript(typescript: any): {
+        enabled: boolean;
+        mode: string;
+        types?: undefined;
+        target?: undefined;
+        sourcemap?: undefined;
+    } | {
+        enabled: boolean;
+        mode: string;
+        types: any;
+        target: any;
+        sourcemap: any;
+    } | null;
+    normalizeEnv(env: any): {
+        include: any;
+    } | null;
+    normalizePermissions(permissions: any): {
+        defaultPolicy: string;
+        enabled: boolean;
+        audit: string;
+        readGating: boolean;
+        rules: any;
+    } | null;
+}
+export function normalizeHookConfig(hook: any): {
+    enabled: boolean;
+    pattern: string;
+    suppressErrors: boolean;
+    pin: boolean;
+};
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/helpers/eventemitter-context.d.mts

@@ -0,0 +1,4 @@
+export function cleanupEventEmitterResources(): void;
+export function disableEventEmitterPatching(): void;
+export function enableEventEmitterPatching(): void;
+export function setApiContextChecker(checker: any): void;

package/lib/helpers/generate-manifest.d.mts

@@ -0,0 +1,11 @@
+export function collectSlothletSpecifiers(root: any): Promise<Set<string>>;
+export function generateBrowserAssets(apiDir: any, options?: {}): Promise<{
+    manifest: any;
+    importmap: {
+        imports: {};
+    };
+}>;
+export function generateImportMap(slothletBase?: string): Promise<{
+    imports: {};
+}>;
+export function generateManifest(dir: any): Promise<any>;

package/lib/helpers/hint-detector.d.mts

@@ -0,0 +1,6 @@
+export class HintDetector extends ComponentBase {
+    static slothletProperty: string;
+    detectHint(error: any, errorCode: any): string;
+}
+export function detectHint(error: any, errorCode: any): string;
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/helpers/manifest-resolver.d.mts

@@ -0,0 +1 @@
+export function createManifestResolver(base: any): (entry: any) => string;

package/lib/helpers/modes-utils.d.mts

@@ -0,0 +1,7 @@
+export class ModesUtils extends ComponentBase {
+    static slothletProperty: string;
+    ensureNamedExportFunction(fn: any, ____nameHint: any): any;
+    cloneWrapperImpl(value: any, mode: any): any;
+    getOwnershipCollisionMode(config: any, collisionContext?: string): any;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/helpers/module-discovery.d.mts

@@ -0,0 +1,7 @@
+export function discoverModules(options?: {}): Promise<Readonly<{
+    packageName: any;
+    packageRoot: any;
+    mountPath: readonly any[];
+    apiDir: any;
+    manifest: any;
+}>[]>;

package/lib/helpers/module-manifest-validator.d.mts

@@ -0,0 +1,13 @@
+export function validateModuleManifest(manifest: any, packageContext: any): {
+    schemaVersion: number;
+    name: any;
+    version: any;
+    description: any;
+    mountPath: any[];
+    apiDir: any;
+    kind: any;
+    priority: any;
+    dependencies: any;
+    permissions: any;
+    metadata: any;
+};

package/lib/helpers/module-sort.d.mts

@@ -0,0 +1 @@
+export function sortModules(results: any, comparator: any): any[];

package/lib/helpers/pattern-matcher.d.mts

@@ -0,0 +1,3 @@
+export function compilePattern(pattern: any, options?: {}): any;
+export function expandBraces(pattern: any, depth?: number, maxDepth?: number, options?: {}): any;
+export function splitBraceAlternatives(content: any): string[];

package/lib/helpers/platform.d.mts

@@ -0,0 +1,11 @@
+export let AsyncLocalStorage: null;
+export let AsyncResource: null;
+export let EventEmitter: null;
+export let createRequire: null;
+export let fs: null;
+export let fsp: null;
+export const isNode: boolean;
+export function loadJson(ref: any): any;
+export let path: null;
+export let url: null;
+export let util: null;

package/lib/helpers/resolve-from-caller.d.mts

@@ -0,0 +1,8 @@
+export class Resolver extends ComponentBase {
+    static slothletProperty: string;
+    getStack(skipFn: any): string | undefined;
+    toFsPath(v: any): any;
+    resolvePathFromCaller(rel: any): any;
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/helpers/sanitize.d.mts

@@ -0,0 +1,9 @@
+export class Sanitize extends ComponentBase {
+    static slothletProperty: string;
+    sanitizePropertyName(input: any, options?: {}): string;
+    getModuleId(filePath: any, baseDir: any): any;
+    shouldPreserveFunctionCase(name: any): boolean;
+    #private;
+}
+export function sanitizePropertyName(input: any, options?: {}): string;
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/helpers/utilities.d.mts

@@ -0,0 +1,8 @@
+export class Utilities extends ComponentBase {
+    static slothletProperty: string;
+    isPlainObject(obj: any): boolean;
+    deepMerge(target: any, source: any): any;
+    deepClone(obj: any): any;
+    generateId(): string;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/i18n/translations.d.mts

@@ -0,0 +1,6 @@
+export function getLanguage(): string;
+export function initI18n(options?: {}): void;
+export function setLanguage(lang: any): void;
+export function setLanguageAsync(lang: any): Promise<void>;
+export function t(errorCode: any, params?: {}): any;
+export function translate(errorCode: any, params?: {}): any;

package/lib/modes/eager.d.mts

@@ -0,0 +1,16 @@
+export class EagerMode extends ComponentBase {
+    static slothletProperty: string;
+    buildAPI({ dir, apiPathPrefix, collisionContext, moduleID, apiDepth, cacheBust, fileFilter, hidden, scanHiddenFolders, preloadedStructure }: {
+        dir: any;
+        apiPathPrefix?: string | undefined;
+        collisionContext?: string | undefined;
+        moduleID: any;
+        apiDepth?: number | undefined;
+        cacheBust?: null | undefined;
+        fileFilter?: null | undefined;
+        hidden?: null | undefined;
+        scanHiddenFolders?: boolean | undefined;
+        preloadedStructure?: null | undefined;
+    }): Promise<any>;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/modes/lazy.d.mts

@@ -0,0 +1,18 @@
+export class LazyMode extends ComponentBase {
+    static slothletProperty: string;
+    createNamedMaterializeFunc(apiPath: any, handler: any): (...args: any[]) => Promise<any>;
+    buildAPI({ dir, apiPathPrefix, collisionContext, collisionMode, moduleID, apiDepth, cacheBust, fileFilter, hidden, scanHiddenFolders, preloadedStructure }: {
+        dir: any;
+        apiPathPrefix?: string | undefined;
+        collisionContext?: string | undefined;
+        collisionMode?: null | undefined;
+        moduleID: any;
+        apiDepth?: number | undefined;
+        cacheBust?: null | undefined;
+        fileFilter?: null | undefined;
+        hidden?: null | undefined;
+        scanHiddenFolders?: boolean | undefined;
+        preloadedStructure?: null | undefined;
+    }): Promise<any>;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/processors/flatten.d.mts

@@ -0,0 +1,62 @@
+export class Flatten extends ComponentBase {
+    static slothletProperty: string;
+    getFlatteningDecision(options: any): Promise<{
+        preserveAsNamespace: boolean;
+        reason: any;
+        flattenToRoot?: undefined;
+    } | {
+        flattenToRoot: boolean;
+        reason: any;
+        preserveAsNamespace?: undefined;
+    } | {
+        flattenToCategory: boolean;
+        flattenType: string;
+        reason: any;
+        useAutoFlattening?: undefined;
+        preserveAsNamespace?: undefined;
+        preferredName?: undefined;
+    } | {
+        useAutoFlattening: boolean;
+        reason: any;
+        flattenToCategory?: undefined;
+        flattenType?: undefined;
+        preserveAsNamespace?: undefined;
+        preferredName?: undefined;
+    } | {
+        flattenToCategory: boolean;
+        reason: any;
+        flattenType?: undefined;
+        useAutoFlattening?: undefined;
+        preserveAsNamespace?: undefined;
+        preferredName?: undefined;
+    } | {
+        preserveAsNamespace: boolean;
+        preferredName: any;
+        reason: any;
+        flattenToCategory?: undefined;
+        flattenType?: undefined;
+        useAutoFlattening?: undefined;
+    }>;
+    processModuleForAPI(options: any): {
+        moduleContent: any;
+    };
+    buildCategoryDecisions(options: any): Promise<{
+        shouldFlatten: boolean;
+        flattenType: string;
+        reason: any;
+        preferredName?: undefined;
+    } | {
+        shouldFlatten: boolean;
+        flattenType: string;
+        preferredName: any;
+        reason: any;
+    } | {
+        shouldFlatten: boolean;
+        preferredName: any;
+        reason: any;
+        flattenType?: undefined;
+    }>;
+    shouldAttachNamedExport(key: any, value: any, defaultFunc: any, originalDefault: any): boolean;
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/processors/loader.d.mts

@@ -0,0 +1,11 @@
+export class Loader extends ComponentBase {
+    static slothletProperty: string;
+    loadModule(filePath: any, instanceID: any, moduleID: any, cacheBust?: null): Promise<any>;
+    scanDirectory(dir: any, options?: {}): Promise<{
+        files: never[];
+        directories: never[];
+    }>;
+    extractExports(module: any): {};
+    #private;
+}
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/lib/processors/type-generator.d.mts

@@ -0,0 +1,4 @@
+export function generateTypes(api: any, options: any): Promise<{
+    output: string;
+    filePath: any;
+}>;

package/lib/processors/typescript.d.mts

@@ -0,0 +1,17 @@
+export function createDataUrl(code: any): string;
+export function formatDiagnostics(diagnostics: any, ts: any): any;
+export function maskStringsAndComments(code: any): Uint8Array<any>;
+export function resolveModuleFile(absoluteTarget: any): {
+    path: any;
+    isTS: boolean;
+};
+export function rewriteRelativeSpecifiers(code: any, sourcePath: any, resolve: any): any;
+export function transformTypeScript(filePath: any, options?: {}): Promise<any>;
+export function transformTypeScriptStrict(filePath: any, options?: {}): Promise<{
+    code: any;
+    diagnostics: any[];
+}>;
+export function writeTransformedToCache(originalPath: any, code: any, instanceID: any, transform: any): Promise<{
+    url: any;
+    cacheDir: any;
+}>;

package/lib/runtime/runtime-asynclocalstorage.d.mts

@@ -0,0 +1,3 @@
+export const context: {};
+export const instanceID: {};
+export const self: {};

package/lib/runtime/runtime-livebindings.d.mts

@@ -0,0 +1,2 @@
+export const context: {};
+export const self: {};

package/lib/runtime/runtime.d.mts

@@ -0,0 +1,3 @@
+export const context: {};
+export const instanceID: {};
+export const self: {};

package/lib/typegen/typegen.d.mts

@@ -0,0 +1,4 @@
+export function generateTypes(options?: {}): Promise<{
+    filePath: any;
+    content: string;
+}>;

package/package.json

@@ -0,0 +1,105 @@
+{
+	"name": "@cldmv/slothlet-types",
+	"version": "3.10.0",
+	"description": "TypeScript declaration files (.d.mts) for @cldmv/slothlet. Install alongside @cldmv/slothlet for editor and type-checker support.",
+	"keywords": [
+		"slothlet",
+		"types",
+		"typescript",
+		"type-definitions",
+		"declarations",
+		"dts"
+	],
+	"license": "Apache-2.0",
+	"author": {
+		"name": "Shinrai",
+		"company": "CLDMV",
+		"email": "git+npm@cldmv.net",
+		"url": "https://cldmv.net"
+	},
+	"contributors": [
+		{
+			"name": "CLDMV",
+			"url": "https://github.com/CLDMV"
+		}
+	],
+	"funding": {
+		"type": "github",
+		"url": "https://github.com/sponsors/shinrai"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/CLDMV/slothlet.git",
+		"directory": "packaging/slothlet-types"
+	},
+	"bugs": {
+		"url": "https://github.com/CLDMV/slothlet/issues"
+	},
+	"homepage": "https://github.com/CLDMV/slothlet#readme",
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"engines": {
+		"node": ">=22.0.0"
+	},
+	"sideEffects": false,
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./index.d.mts"
+		},
+		"./typegen": {
+			"types": "./lib/typegen/typegen.d.mts"
+		},
+		"./slothlet": {
+			"types": "./slothlet.d.mts"
+		},
+		"./runtime": {
+			"types": "./lib/runtime/runtime.d.mts"
+		},
+		"./runtime/async": {
+			"types": "./lib/runtime/runtime-asynclocalstorage.d.mts"
+		},
+		"./runtime/live": {
+			"types": "./lib/runtime/runtime-livebindings.d.mts"
+		},
+		"./helpers/*": {
+			"types": "./lib/helpers/*.d.mts"
+		},
+		"./modes/*": {
+			"types": "./lib/modes/*.d.mts"
+		},
+		"./builders/*": {
+			"types": "./lib/builders/*.d.mts"
+		},
+		"./handlers/*": {
+			"types": "./lib/handlers/*.d.mts"
+		},
+		"./processors/*": {
+			"types": "./lib/processors/*.d.mts"
+		},
+		"./factories/*": {
+			"types": "./lib/factories/*.d.mts"
+		},
+		"./errors": {
+			"types": "./lib/errors.d.mts"
+		},
+		"./i18n": {
+			"types": "./lib/i18n/translations.d.mts"
+		}
+	},
+	"files": [
+		"**/*.d.mts",
+		"README.md",
+		"LICENSE"
+	],
+	"peerDependencies": {
+		"@cldmv/slothlet": "3.10.0"
+	},
+	"peerDependenciesMeta": {
+		"@cldmv/slothlet": {
+			"optional": true
+		}
+	}
+}

package/slothlet.d.mts

@@ -0,0 +1,3 @@
+declare function stdin_default(config: any): Promise<{}>;
+export function slothlet(config: any): Promise<{}>;
+export { stdin_default as default };