semantic-primitives 0.1.0

package/dist/types/map/prompts.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Prompts for SemanticMap LLM operations
+ * These prompts enable semantic operations on Map key-value collections
+ */
+/**
+ * System prompt for map semantic operations
+ */
+export declare const MAP_SYSTEM_PROMPT = "You are a semantic map analyzer. Your task is to analyze Map key-value pairs to provide semantic understanding of keys, values, and their relationships.\n\nYou must respond with valid JSON only, no additional text or explanation.\n\nGuidelines:\n- Consider key meanings, synonyms, and naming conventions\n- Understand value relationships and patterns\n- Provide confidence scores from 0.0 to 1.0\n- Be precise and consistent in your analysis\n- Handle both primitive and complex object values";
+/**
+ * Prompt for semantic key lookup
+ */
+export declare function createSemanticGetPrompt(keys: string[], query: string, context?: Record<string, unknown>): string;
+/**
+ * Prompt for semantic has check
+ */
+export declare function createSemanticHasPrompt(keys: string[], query: string): string;
+/**
+ * Prompt for semantic equality comparison
+ */
+export declare function createSemanticallyEqualsPrompt(map1Entries: [string, unknown][], map2Entries: [string, unknown][]): string;
+/**
+ * Prompt for finding keys by criteria
+ */
+export declare function createFindKeysPrompt(entries: [string, unknown][], criteria: string): string;
+/**
+ * Prompt for finding values by criteria
+ */
+export declare function createFindValuesPrompt(entries: [string, unknown][], criteria: string): string;
+/**
+ * Prompt for semantic merge
+ */
+export declare function createSemanticMergePrompt(thisEntries: [string, unknown][], otherEntries: [string, unknown][], conflictResolution: 'prefer-this' | 'prefer-other' | 'combine'): string;
+/**
+ * Prompt for validation
+ */
+export declare function createValidatePrompt(entries: [string, unknown][], rules: {
+    keys?: string;
+    values?: string;
+}): string;
+/**
+ * Prompt for suggesting missing keys
+ */
+export declare function createSuggestMissingKeysPrompt(entries: [string, unknown][]): string;
+/**
+ * Prompt for grouping entries
+ */
+export declare function createGroupByPrompt(entries: [string, unknown][], criteria: string): string;
+/**
+ * Prompt for summarization
+ */
+export declare function createSummarizePrompt(entries: [string, unknown][], mapSize: number): string;
+/**
+ * Prompt for inferring purpose
+ */
+export declare function createInferPurposePrompt(entries: [string, unknown][]): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/map/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/types/map/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,ifASoB,CAAC;AAEnD;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CA2BR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiB7E;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAChC,WAAW,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC/B,MAAM,CAmBR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC5B,QAAQ,EAAE,MAAM,GACf,MAAM,CAkBR;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC5B,QAAQ,EAAE,MAAM,GACf,MAAM,CAkBR;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAChC,YAAY,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACjC,kBAAkB,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,GAC7D,MAAM,CAsBR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC5B,KAAK,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,MAAM,CAqBR;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC3B,MAAM,CAkBR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC5B,QAAQ,EAAE,MAAM,GACf,MAAM,CAkBR;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAC5B,OAAO,EAAE,MAAM,GACd,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAe7E"}

package/dist/types/never/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SemanticNever exports
+ */
+export { SemanticNever, type UnreachabilityType, type ExhaustiveResult, type UnreachabilityResult, type DeadCodeResult, type ExhaustiveHandlerResult, type ValidateExhaustivenessResult, type ShouldReturnNeverResult, type IntersectionAnalysisResult, type NeverPattern, } from './never.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/never/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/never/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,aAAa,EACb,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,YAAY,GAClB,MAAM,YAAY,CAAC"}

package/dist/types/never/never.d.ts

@@ -0,0 +1,220 @@
+/**
+ * SemanticNever
+ * A semantic wrapper for TypeScript's never type with LLM-powered analysis
+ *
+ * Since 'never' represents values that never occur, this class provides
+ * static methods for analyzing unreachable code, exhaustiveness checking,
+ * and explaining the never type's semantics.
+ *
+ * Note: SemanticNever has no instances - all methods are static because
+ * 'never' is the bottom type with no values.
+ */
+import type { LLMClient } from '../../llm/client.ts';
+/** Unreachability type classification */
+export type UnreachabilityType = 'control-flow' | 'type-narrowing' | 'exhaustive-check' | 'impossible-state';
+/** Result of exhaustiveness check */
+export interface ExhaustiveResult {
+    exhaustive: boolean;
+    missing: string[];
+}
+/** Result of unreachability explanation */
+export interface UnreachabilityResult {
+    reason: string;
+    type: UnreachabilityType;
+    suggestion: string;
+}
+/** Result of dead code analysis */
+export interface DeadCodeResult {
+    isDead: boolean;
+    reason: string;
+    safeToRemove: boolean;
+}
+/** Result of exhaustive handler suggestion */
+export interface ExhaustiveHandlerResult {
+    code: string;
+    usage: string;
+}
+/** Result of exhaustiveness validation */
+export interface ValidateExhaustivenessResult {
+    valid: boolean;
+    covers: string[];
+    missing?: string[];
+    suggestion?: string;
+}
+/** Result of should-return-never analysis */
+export interface ShouldReturnNeverResult {
+    shouldReturn: boolean;
+    reason: string;
+}
+/** Result of type intersection analysis */
+export interface IntersectionAnalysisResult {
+    resultsInNever: boolean;
+    reason: string;
+}
+/** Pattern where never is appropriate */
+export interface NeverPattern {
+    pattern: string;
+    description: string;
+    example: string;
+}
+/**
+ * SemanticNever - Static utilities for never type analysis
+ *
+ * This class provides LLM-powered analysis of:
+ * - Exhaustiveness checking for discriminated unions
+ * - Dead code detection
+ * - Unreachability explanation
+ * - Type intersection analysis
+ *
+ * All methods are static because 'never' has no values to instantiate.
+ */
+export declare class SemanticNever {
+    /**
+     * Private constructor - SemanticNever cannot be instantiated
+     * The never type represents values that never occur, so there can be no instances.
+     */
+    private constructor();
+    /**
+     * Check if a switch statement or conditional is exhaustive.
+     *
+     * @param type - The union type being checked (e.g., "Status", "Result")
+     * @param handledCases - Array of cases that are handled
+     * @param client - Optional LLM client for dependency injection
+     * @returns Exhaustiveness check result with any missing cases
+     *
+     * @example
+     * await SemanticNever.isExhaustive("Status", ["pending", "active"])
+     * // { exhaustive: false, missing: ["completed"] }
+     *
+     * await SemanticNever.isExhaustive("Direction", ["up", "down", "left", "right"])
+     * // { exhaustive: true, missing: [] }
+     */
+    static isExhaustive(type: string, handledCases: string[], client?: LLMClient): Promise<ExhaustiveResult>;
+    /**
+     * Explain why a code path is unreachable (never).
+     *
+     * @param context - The code context to analyze
+     * @param client - Optional LLM client for dependency injection
+     * @returns Explanation with type classification and suggestion
+     *
+     * @example
+     * await SemanticNever.explainUnreachability("after throw statement")
+     * // {
+     * //   reason: "Code after a throw statement cannot execute",
+     * //   type: "control-flow",
+     * //   suggestion: "Remove dead code after throw"
+     * // }
+     */
+    static explainUnreachability(context: string, client?: LLMClient): Promise<UnreachabilityResult>;
+    /**
+     * Check if a code path is actually dead code.
+     *
+     * @param code - Code snippet or description to analyze
+     * @param context - Optional surrounding context
+     * @param client - Optional LLM client for dependency injection
+     * @returns Dead code analysis with removal safety
+     *
+     * @example
+     * await SemanticNever.isDeadCode("return statement after return")
+     * // { isDead: true, reason: "First return already exits the function", safeToRemove: true }
+     */
+    static isDeadCode(code: string, context?: string, client?: LLMClient): Promise<DeadCodeResult>;
+    /**
+     * Suggest an exhaustive switch handler (assertNever pattern).
+     *
+     * @param typeName - The discriminated union type name
+     * @param client - Optional LLM client for dependency injection
+     * @returns Suggested code and usage example
+     *
+     * @example
+     * await SemanticNever.suggestExhaustiveHandler("Status")
+     * // {
+     * //   code: "function assertNever(x: never): never { throw new Error(`Unexpected value: ${x}`); }",
+     * //   usage: "default: return assertNever(status);"
+     * // }
+     */
+    static suggestExhaustiveHandler(typeName: string, client?: LLMClient): Promise<ExhaustiveHandlerResult>;
+    /**
+     * Validate that a function properly uses never for exhaustiveness.
+     *
+     * @param fnCode - Function code to validate
+     * @param client - Optional LLM client for dependency injection
+     * @returns Validation result with covered cases and suggestions
+     *
+     * @example
+     * await SemanticNever.validateExhaustivenessCheck(`
+     *   function handleStatus(status: Status) {
+     *     switch (status) {
+     *       case "pending": return "Waiting...";
+     *       case "active": return "In progress";
+     *       case "completed": return "Done!";
+     *       default: return assertNever(status);
+     *     }
+     *   }
+     * `)
+     * // { valid: true, covers: ["pending", "active", "completed"] }
+     */
+    static validateExhaustivenessCheck(fnCode: string, client?: LLMClient): Promise<ValidateExhaustivenessResult>;
+    /**
+     * Identify if a function should return never based on its behavior.
+     *
+     * @param fnName - Function name
+     * @param behavior - Description of function behavior
+     * @param client - Optional LLM client for dependency injection
+     * @returns Analysis with recommendation
+     *
+     * @example
+     * await SemanticNever.shouldReturnNever("throwError", "always throws an exception")
+     * // { shouldReturn: true, reason: "Function always throws, never returns normally" }
+     *
+     * await SemanticNever.shouldReturnNever("maybeThrow", "throws on invalid input")
+     * // { shouldReturn: false, reason: "Function may return normally with valid input" }
+     */
+    static shouldReturnNever(fnName: string, behavior: string, client?: LLMClient): Promise<ShouldReturnNeverResult>;
+    /**
+     * Explain the never type to developers.
+     *
+     * @param context - Optional usage context for tailored explanation
+     * @param client - Optional LLM client for dependency injection
+     * @returns Educational explanation string
+     *
+     * @example
+     * await SemanticNever.explain()
+     * // "The 'never' type represents values that never occur..."
+     *
+     * await SemanticNever.explain("in function return type")
+     * // "A function returning 'never' will never complete normally..."
+     */
+    static explain(context?: string, client?: LLMClient): Promise<string>;
+    /**
+     * Detect if type intersection results in never.
+     *
+     * @param types - Array of type names to intersect
+     * @param client - Optional LLM client for dependency injection
+     * @returns Analysis of whether intersection is never
+     *
+     * @example
+     * await SemanticNever.analyzeIntersection(["string", "number"])
+     * // { resultsInNever: true, reason: "A value cannot be both string and number" }
+     *
+     * await SemanticNever.analyzeIntersection(["{ name: string }", "{ age: number }"])
+     * // { resultsInNever: false, reason: "Object types can be merged" }
+     */
+    static analyzeIntersection(types: string[], client?: LLMClient): Promise<IntersectionAnalysisResult>;
+    /**
+     * Get common patterns where never is appropriate.
+     * This is a static list - no LLM call required.
+     *
+     * @returns List of appropriate never patterns with examples
+     *
+     * @example
+     * SemanticNever.appropriatePatterns()
+     * // [
+     * //   { pattern: "Exhaustive switch handler", description: "...", example: "..." },
+     * //   { pattern: "Functions that never return", description: "...", example: "..." },
+     * //   ...
+     * // ]
+     */
+    static appropriatePatterns(): NeverPattern[];
+}
+//# sourceMappingURL=never.d.ts.map

package/dist/types/never/never.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"never.d.ts","sourceRoot":"","sources":["../../../src/types/never/never.ts"],"names":[],"mappings":"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"}

package/dist/types/never/prompts.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Prompts for SemanticNever LLM operations
+ * These prompts are used to analyze unreachable code, exhaustiveness, and never type semantics
+ */
+/**
+ * System prompt for never type analysis tasks
+ */
+export declare const NEVER_SYSTEM_PROMPT = "You are a TypeScript type system expert specializing in the 'never' type and exhaustiveness checking. Your task is to analyze code patterns related to unreachable code, exhaustive switches, and impossible type states.\n\nYou must respond with valid JSON only, no additional text or explanation.\n\nKey concepts:\n- \"never\" is the bottom type in TypeScript - it represents values that never occur\n- A function returning \"never\" will never return normally (throws or infinite loop)\n- Exhaustive checks ensure all cases of a union type are handled\n- Dead code is code that can never be executed\n- Type narrowing can result in \"never\" when all possibilities are eliminated\n- Intersecting incompatible types (string & number) results in \"never\"\n\nUnreachability types:\n- \"control-flow\": Code after throw, return, or infinite loops\n- \"type-narrowing\": Code in branches where type is narrowed to never\n- \"exhaustive-check\": Default case in exhaustive switch that should never be reached\n- \"impossible-state\": Code that handles states that cannot exist\n\nGuidelines:\n- Be precise about why code is unreachable\n- Consider all edge cases in exhaustiveness analysis\n- Provide actionable suggestions for handling never types\n- Explain type intersections clearly";
+/**
+ * Prompt template for checking if a switch/conditional is exhaustive
+ */
+export declare function createIsExhaustivePrompt(typeName: string, handledCases: string[]): string;
+/**
+ * Prompt template for explaining why code is unreachable
+ */
+export declare function createExplainUnreachabilityPrompt(context: string): string;
+/**
+ * Prompt template for checking if code is dead code
+ */
+export declare function createIsDeadCodePrompt(code: string, context?: string): string;
+/**
+ * Prompt template for suggesting exhaustive handler code
+ */
+export declare function createSuggestExhaustiveHandlerPrompt(typeName: string): string;
+/**
+ * Prompt template for validating exhaustiveness in function code
+ */
+export declare function createValidateExhaustivenessCheckPrompt(fnCode: string): string;
+/**
+ * Prompt template for checking if a function should return never
+ */
+export declare function createShouldReturnNeverPrompt(fnName: string, behavior: string): string;
+/**
+ * Prompt template for explaining the never type
+ */
+export declare function createExplainPrompt(context?: string): string;
+/**
+ * Prompt template for analyzing type intersections
+ */
+export declare function createAnalyzeIntersectionPrompt(types: string[]): string;
+/**
+ * Get appropriate patterns where never is commonly used
+ * Note: This is a static list, not LLM-powered
+ */
+export declare function getAppropriatePatterns(): {
+    pattern: string;
+    description: string;
+    example: string;
+}[];
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/never/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/types/never/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB,qwCAsBK,CAAC;AAEtC;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,CAsBR;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAsBzE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAyB7E;AAED;;GAEG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiB7E;AAED;;GAEG;AACH,wBAAgB,uCAAuC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAqB9E;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAsBR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAuB5D;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAsBvE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,EAAE,CA4CF"}

package/dist/types/object/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SemanticObject module
+ * Exports the SemanticObject class and related types
+ */
+export { SemanticObject, type ObjectValidateResult, type SemanticMergeOptions, type KeyConvention, type SemanticEqualsResultWithMappings, type SemanticGetResult, type InferSchemaResult, type MissingSuggestion, type InferTypeResult, type SensitiveResult, } from './object.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/object/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/object/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,gCAAgC,EACrC,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,aAAa,CAAC"}

package/dist/types/object/object.d.ts

@@ -0,0 +1,162 @@
+/**
+ * SemanticObject
+ * An object type with LLM-powered semantic understanding
+ *
+ * Implements shared interfaces:
+ * - Semantic<T> - Base semantic wrapper
+ * - Comparable<SemanticObject<T>> - Semantic equality comparison
+ * - Validatable - Validation against semantic rules
+ * - Summarizable - Content summarization
+ * - TypeInferable - Type/purpose detection
+ * - SchemaInferable - Schema inference
+ * - SensitivityDetectable - Sensitive data detection
+ */
+import type { LLMClient } from '../../llm/client.ts';
+import type { SemanticEqualsResultWithMappings, SemanticGetResult, InferSchemaResult, MissingSuggestion, InferTypeResult, SensitiveResult } from '../../shared/types.ts';
+import type { Semantic, Comparable } from '../../shared/interfaces.ts';
+export type { SemanticEqualsResultWithMappings, SemanticGetResult, InferSchemaResult, MissingSuggestion, InferTypeResult, SensitiveResult, } from '../../shared/types.ts';
+/** Validation result with field-specific issues */
+export interface ObjectValidateResult {
+    valid: boolean;
+    issues: {
+        field: string;
+        problem: string;
+    }[];
+}
+/** Options for semantic merge */
+export interface SemanticMergeOptions {
+    conflictResolution?: 'prefer-this' | 'prefer-other' | 'combine';
+}
+/** Key naming conventions */
+export type KeyConvention = 'camelCase' | 'snake_case' | 'PascalCase' | 'kebab-case';
+/**
+ * SemanticObject - Object with LLM-powered semantic understanding
+ *
+ * Unlike traditional objects that require exact key matches,
+ * semantic objects can access properties using natural language
+ * queries and understand synonymous keys.
+ *
+ * @template T - The type of the underlying object
+ */
+export declare class SemanticObject<T extends object = object> implements Semantic<T>, Comparable<SemanticObject<T> | object, SemanticEqualsResultWithMappings> {
+    private readonly data;
+    private readonly client;
+    private constructor();
+    /**
+     * Create a SemanticObject from an existing object
+     */
+    static from<T extends object>(obj: T, client?: LLMClient): SemanticObject<T>;
+    /**
+     * Create an empty SemanticObject
+     */
+    static empty<T extends object = object>(client?: LLMClient): SemanticObject<T>;
+    /**
+     * Get the underlying object value
+     */
+    valueOf(): T;
+    /**
+     * Get a property using semantic key matching.
+     * Matches property names semantically, not just exactly.
+     *
+     * @param query - Property name or semantic query
+     * @returns Property value with match info
+     */
+    semanticGet(query: string): Promise<SemanticGetResult>;
+    /**
+     * Check if two objects are semantically equivalent.
+     * Considers property name synonyms and value meaning.
+     *
+     * @param other - Object to compare with
+     * @returns Equivalence result with mappings
+     */
+    semanticallyEquals(other: SemanticObject<T> | object): Promise<SemanticEqualsResultWithMappings>;
+    /**
+     * Validate the object against semantic rules.
+     *
+     * @param rules - Natural language validation rules
+     * @returns Validation result
+     */
+    validate(rules: string[]): Promise<ObjectValidateResult>;
+    /**
+     * Infer the semantic schema of this object.
+     *
+     * @returns Inferred schema with field descriptions
+     */
+    inferSchema(): Promise<InferSchemaResult>;
+    /**
+     * Transform property names to a different convention.
+     *
+     * @param convention - Target naming convention
+     * @returns Transformed object
+     */
+    transformKeys(convention: KeyConvention): Promise<SemanticObject<T>>;
+    /**
+     * Merge with another object, handling key synonyms.
+     *
+     * @param other - Object to merge
+     * @param options - Merge options
+     * @returns Merged object
+     */
+    semanticMerge(other: object, options?: SemanticMergeOptions): Promise<SemanticObject<T>>;
+    /**
+     * Extract specific fields using semantic matching.
+     *
+     * @param fields - Fields to extract (semantic descriptions)
+     * @returns Extracted object
+     */
+    pick(fields: string[]): Promise<SemanticObject<Partial<T>>>;
+    /**
+     * Suggest missing fields based on the object's purpose.
+     *
+     * @returns Suggested fields
+     */
+    suggestMissingFields(): Promise<MissingSuggestion[]>;
+    /**
+     * Summarize the object contents.
+     *
+     * @returns Human-readable summary
+     */
+    summarize(): Promise<string>;
+    /**
+     * Detect the semantic type/purpose of this object.
+     *
+     * @returns Inferred type
+     */
+    inferType(): Promise<InferTypeResult>;
+    /**
+     * Check if a field contains sensitive data.
+     *
+     * @param field - Field name to check
+     * @returns Sensitivity assessment
+     */
+    isSensitive(field: string): Promise<SensitiveResult>;
+    /**
+     * Get all keys of the object
+     */
+    keys(): string[];
+    /**
+     * Get all values of the object
+     */
+    values(): unknown[];
+    /**
+     * Get all entries of the object
+     */
+    entries(): [string, unknown][];
+    /**
+     * Check if object has a property (exact match)
+     */
+    has(key: string): boolean;
+    /**
+     * Get a property value (exact match)
+     */
+    get<K extends keyof T>(key: K): T[K];
+    /**
+     * Convert to string
+     */
+    toString(): string;
+    /**
+     * Convert to JSON
+     */
+    toJSON(): T;
+}
+//# sourceMappingURL=object.d.ts.map

package/dist/types/object/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../src/types/object/object.ts"],"names":[],"mappings":"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"}

package/dist/types/object/prompts.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Prompts for SemanticObject LLM operations
+ * These prompts enable semantic operations on object data structures
+ */
+/**
+ * System prompt for object semantic operations
+ */
+export declare const OBJECT_SYSTEM_PROMPT = "You are a semantic object analyzer. Your task is to analyze objects and their properties to provide semantic understanding.\n\nYou must respond with valid JSON only, no additional text or explanation.\n\nGuidelines:\n- Consider property names, values, and their semantic meanings\n- Understand common naming conventions (camelCase, snake_case, etc.)\n- Recognize synonymous property names (e.g., \"email\" and \"emailAddress\")\n- Provide confidence scores from 0.0 to 1.0\n- Be precise and consistent in your analysis";
+/**
+ * Prompt for semantic property access
+ */
+export declare function createSemanticGetPrompt(obj: object, query: string): string;
+/**
+ * Prompt for semantic equality comparison
+ */
+export declare function createSemanticallyEqualsPrompt(obj1: object, obj2: object): string;
+/**
+ * Prompt for validation against rules
+ */
+export declare function createValidatePrompt(obj: object, rules: string[]): string;
+/**
+ * Prompt for schema inference
+ */
+export declare function createInferSchemaPrompt(obj: object): string;
+/**
+ * Prompt for key transformation
+ */
+export declare function createTransformKeysPrompt(obj: object, convention: 'camelCase' | 'snake_case' | 'PascalCase' | 'kebab-case'): string;
+/**
+ * Prompt for semantic merge
+ */
+export declare function createSemanticMergePrompt(obj1: object, obj2: object, options?: {
+    conflictResolution?: 'prefer-this' | 'prefer-other' | 'combine';
+}): string;
+/**
+ * Prompt for semantic field extraction (pick)
+ */
+export declare function createPickPrompt(obj: object, fields: string[]): string;
+/**
+ * Prompt for suggesting missing fields
+ */
+export declare function createSuggestMissingFieldsPrompt(obj: object): string;
+/**
+ * Prompt for summarization
+ */
+export declare function createSummarizePrompt(obj: object): string;
+/**
+ * Prompt for type inference
+ */
+export declare function createInferTypePrompt(obj: object): string;
+/**
+ * Prompt for sensitive data detection
+ */
+export declare function createIsSensitivePrompt(obj: object, field: string): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/object/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/types/object/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB,2gBASY,CAAC;AAE9C;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,MAAM,CAmBR;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM,CAoBR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAsB3D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,WAAW,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,GACnE,MAAM,CAcR;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,kBAAkB,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,CAAA;CAAE,GAC5E,MAAM,CAwBR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EAAE,GACf,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAkBpE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAezD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAYzD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,MAAM,CAoBR"}

package/dist/types/object-literal/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SemanticObjectLiteral
+ * LLM-enhanced object literal type with semantic understanding
+ */
+export { SemanticObjectLiteral, type ObjectLiteralValidateResult, type DetectDomainResult, type PropertySearchResult, type MissingPropertySuggestion, type KeyConvention, type SemanticEqualsResultWithMappings, type InferSchemaResult, type SensitiveResult, } from './object-literal.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/object-literal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/object-literal/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,qBAAqB,EACrB,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,aAAa,EAClB,KAAK,gCAAgC,EACrC,KAAK,iBAAiB,EACtB,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC"}