cad-mcp-server 0.1.0

package/dist/tools/step-tools.d.ts

@@ -0,0 +1,758 @@
+import { z } from 'zod';
+import { CAD_RESPONSE_SCHEMA_VERSION } from '../schema-version.js';
+declare const internalFaceQuerySchema: {
+    filter: z.ZodOptional<z.ZodObject<{
+        entity_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        group_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        surface_type: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            bspline: "bspline";
+            plane: "plane";
+            cylinder: "cylinder";
+            cone: "cone";
+            sphere: "sphere";
+            torus: "torus";
+            other: "other";
+        }>>>;
+        area_min: z.ZodOptional<z.ZodNumber>;
+        area_max: z.ZodOptional<z.ZodNumber>;
+        normal_parallel_to: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        normal_tolerance_degrees: z.ZodOptional<z.ZodNumber>;
+        body_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        radius: "radius";
+        body_id: "body_id";
+        surface_type: "surface_type";
+        normal_direction: "normal_direction";
+        area_range: "area_range";
+    }>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        by: z.ZodEnum<{
+            center_x: "center_x";
+            center_y: "center_y";
+            center_z: "center_z";
+            surface_type: "surface_type";
+            area: "area";
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>>;
+    result_mode: z.ZodOptional<z.ZodEnum<{
+        summary: "summary";
+        entities: "entities";
+        groups: "groups";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+};
+declare const internalEdgeQuerySchema: {
+    filter: z.ZodOptional<z.ZodObject<{
+        entity_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        group_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        curve_type: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            line: "line";
+            circle: "circle";
+            ellipse: "ellipse";
+            bspline: "bspline";
+            other: "other";
+        }>>>;
+        length_min: z.ZodOptional<z.ZodNumber>;
+        length_max: z.ZodOptional<z.ZodNumber>;
+        radius_min: z.ZodOptional<z.ZodNumber>;
+        radius_max: z.ZodOptional<z.ZodNumber>;
+        body_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        curve_type: "curve_type";
+        body_id: "body_id";
+        length_range: "length_range";
+    }>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        by: z.ZodEnum<{
+            length: "length";
+            radius: "radius";
+            curve_type: "curve_type";
+            center_x: "center_x";
+            center_y: "center_y";
+            center_z: "center_z";
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>>;
+    result_mode: z.ZodOptional<z.ZodEnum<{
+        summary: "summary";
+        entities: "entities";
+        groups: "groups";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+};
+declare const internalPmiQuerySchema: {
+    filter: z.ZodOptional<z.ZodObject<{
+        pmi_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            geometric_tolerance: "geometric_tolerance";
+            dimension: "dimension";
+            datum: "datum";
+            annotation: "annotation";
+        }>>>;
+        tolerance_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            position: "position";
+            flatness: "flatness";
+            straightness: "straightness";
+            circularity: "circularity";
+            cylindricity: "cylindricity";
+            profile: "profile";
+            parallelism: "parallelism";
+            perpendicularity: "perpendicularity";
+            angularity: "angularity";
+            concentricity: "concentricity";
+            runout: "runout";
+            symmetry: "symmetry";
+            coaxiality: "coaxiality";
+            circular_runout: "circular_runout";
+            total_runout: "total_runout";
+            surface_profile: "surface_profile";
+            line_profile: "line_profile";
+        }>>>;
+        value_min: z.ZodOptional<z.ZodNumber>;
+        value_max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        type: "type";
+        tolerance_type: "tolerance_type";
+        dimension_type: "dimension_type";
+        material_condition: "material_condition";
+    }>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        by: z.ZodEnum<{
+            value: "value";
+            type: "type";
+            tolerance_type: "tolerance_type";
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>>;
+    result_mode: z.ZodOptional<z.ZodEnum<{
+        summary: "summary";
+        entities: "entities";
+        groups: "groups";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+};
+declare const findStepFacesSchema: {
+    surface_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        bspline: "bspline";
+        plane: "plane";
+        cylinder: "cylinder";
+        cone: "cone";
+        sphere: "sphere";
+        torus: "torus";
+        other: "other";
+    }>>>;
+    area_min: z.ZodOptional<z.ZodNumber>;
+    area_max: z.ZodOptional<z.ZodNumber>;
+    normal: z.ZodOptional<z.ZodObject<{
+        parallel_to: z.ZodArray<z.ZodNumber>;
+        tolerance_degrees: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    body_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        radius: "radius";
+        body_id: "body_id";
+        surface_type: "surface_type";
+        normal_direction: "normal_direction";
+        area_range: "area_range";
+    }>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        by: z.ZodEnum<{
+            center_x: "center_x";
+            center_y: "center_y";
+            center_z: "center_z";
+            surface_type: "surface_type";
+            area: "area";
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>>;
+    return_type: z.ZodOptional<z.ZodEnum<{
+        summary: "summary";
+        entities: "entities";
+        groups: "groups";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    file_path: z.ZodString;
+};
+declare const findStepEdgesSchema: {
+    curve_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        line: "line";
+        circle: "circle";
+        ellipse: "ellipse";
+        bspline: "bspline";
+        other: "other";
+    }>>>;
+    length_min: z.ZodOptional<z.ZodNumber>;
+    length_max: z.ZodOptional<z.ZodNumber>;
+    radius: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    body_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        curve_type: "curve_type";
+        body_id: "body_id";
+        length_range: "length_range";
+    }>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        by: z.ZodEnum<{
+            length: "length";
+            radius: "radius";
+            curve_type: "curve_type";
+            center_x: "center_x";
+            center_y: "center_y";
+            center_z: "center_z";
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>>;
+    return_type: z.ZodOptional<z.ZodEnum<{
+        summary: "summary";
+        entities: "entities";
+        groups: "groups";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    file_path: z.ZodString;
+};
+declare const getStepEntitiesSchema: {
+    entity_type: z.ZodEnum<{
+        edge: "edge";
+        face: "face";
+    }>;
+    entity_ids: z.ZodArray<z.ZodString>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    file_path: z.ZodString;
+};
+declare const pmiQuerySchema: {
+    pmi_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        geometric_tolerance: "geometric_tolerance";
+        dimension: "dimension";
+        datum: "datum";
+        annotation: "annotation";
+    }>>>;
+    tolerance_subtypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        position: "position";
+        flatness: "flatness";
+        straightness: "straightness";
+        circularity: "circularity";
+        cylindricity: "cylindricity";
+        profile: "profile";
+        parallelism: "parallelism";
+        perpendicularity: "perpendicularity";
+        angularity: "angularity";
+        concentricity: "concentricity";
+        runout: "runout";
+        symmetry: "symmetry";
+        coaxiality: "coaxiality";
+        circular_runout: "circular_runout";
+        total_runout: "total_runout";
+        surface_profile: "surface_profile";
+        line_profile: "line_profile";
+    }>>>;
+    value_min: z.ZodOptional<z.ZodNumber>;
+    value_max: z.ZodOptional<z.ZodNumber>;
+    group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        type: "type";
+        tolerance_type: "tolerance_type";
+        dimension_type: "dimension_type";
+        material_condition: "material_condition";
+    }>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        by: z.ZodEnum<{
+            value: "value";
+            type: "type";
+            tolerance_type: "tolerance_type";
+        }>;
+        direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>>;
+    return_type: z.ZodOptional<z.ZodEnum<{
+        summary: "summary";
+        entities: "entities";
+        groups: "groups";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    file_path: z.ZodString;
+};
+export declare const stepToolSchemas: {
+    readonly inspectStepFile: {
+        file_path: z.ZodString;
+    };
+    readonly findStepFaces: {
+        surface_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            bspline: "bspline";
+            plane: "plane";
+            cylinder: "cylinder";
+            cone: "cone";
+            sphere: "sphere";
+            torus: "torus";
+            other: "other";
+        }>>>;
+        area_min: z.ZodOptional<z.ZodNumber>;
+        area_max: z.ZodOptional<z.ZodNumber>;
+        normal: z.ZodOptional<z.ZodObject<{
+            parallel_to: z.ZodArray<z.ZodNumber>;
+            tolerance_degrees: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        body_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            [x: string]: string;
+        }>>>;
+        group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            radius: "radius";
+            body_id: "body_id";
+            surface_type: "surface_type";
+            normal_direction: "normal_direction";
+            area_range: "area_range";
+        }>>>;
+        sort: z.ZodOptional<z.ZodObject<{
+            by: z.ZodEnum<{
+                center_x: "center_x";
+                center_y: "center_y";
+                center_z: "center_z";
+                surface_type: "surface_type";
+                area: "area";
+            }>;
+            direction: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>;
+        return_type: z.ZodOptional<z.ZodEnum<{
+            summary: "summary";
+            entities: "entities";
+            groups: "groups";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        file_path: z.ZodString;
+    };
+    readonly findStepEdges: {
+        curve_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            line: "line";
+            circle: "circle";
+            ellipse: "ellipse";
+            bspline: "bspline";
+            other: "other";
+        }>>>;
+        length_min: z.ZodOptional<z.ZodNumber>;
+        length_max: z.ZodOptional<z.ZodNumber>;
+        radius: z.ZodOptional<z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        body_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            [x: string]: string;
+        }>>>;
+        group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            curve_type: "curve_type";
+            body_id: "body_id";
+            length_range: "length_range";
+        }>>>;
+        sort: z.ZodOptional<z.ZodObject<{
+            by: z.ZodEnum<{
+                length: "length";
+                radius: "radius";
+                curve_type: "curve_type";
+                center_x: "center_x";
+                center_y: "center_y";
+                center_z: "center_z";
+            }>;
+            direction: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>;
+        return_type: z.ZodOptional<z.ZodEnum<{
+            summary: "summary";
+            entities: "entities";
+            groups: "groups";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        file_path: z.ZodString;
+    };
+    readonly getStepEntities: {
+        entity_type: z.ZodEnum<{
+            edge: "edge";
+            face: "face";
+        }>;
+        entity_ids: z.ZodArray<z.ZodString>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            [x: string]: string;
+        }>>>;
+        file_path: z.ZodString;
+    };
+    readonly compareStepFiles: {
+        readonly baseline_file_path: z.ZodString;
+        readonly comparison_file_path: z.ZodString;
+    };
+    readonly queryStepPmi: {
+        pmi_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            geometric_tolerance: "geometric_tolerance";
+            dimension: "dimension";
+            datum: "datum";
+            annotation: "annotation";
+        }>>>;
+        tolerance_subtypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            position: "position";
+            flatness: "flatness";
+            straightness: "straightness";
+            circularity: "circularity";
+            cylindricity: "cylindricity";
+            profile: "profile";
+            parallelism: "parallelism";
+            perpendicularity: "perpendicularity";
+            angularity: "angularity";
+            concentricity: "concentricity";
+            runout: "runout";
+            symmetry: "symmetry";
+            coaxiality: "coaxiality";
+            circular_runout: "circular_runout";
+            total_runout: "total_runout";
+            surface_profile: "surface_profile";
+            line_profile: "line_profile";
+        }>>>;
+        value_min: z.ZodOptional<z.ZodNumber>;
+        value_max: z.ZodOptional<z.ZodNumber>;
+        group_by: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            type: "type";
+            tolerance_type: "tolerance_type";
+            dimension_type: "dimension_type";
+            material_condition: "material_condition";
+        }>>>;
+        sort: z.ZodOptional<z.ZodObject<{
+            by: z.ZodEnum<{
+                value: "value";
+                type: "type";
+                tolerance_type: "tolerance_type";
+            }>;
+            direction: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>;
+        return_type: z.ZodOptional<z.ZodEnum<{
+            summary: "summary";
+            entities: "entities";
+            groups: "groups";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        file_path: z.ZodString;
+    };
+};
+export declare const stepToolOutputSchemas: {
+    readonly inspectStepFile: {
+        readonly schema_version: z.ZodLiteral<"0.4">;
+        readonly file_path: z.ZodString;
+        readonly identity: z.ZodObject<{
+            product_names: z.ZodArray<z.ZodString>;
+            authoring_system: z.ZodOptional<z.ZodString>;
+            organization_name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly size: z.ZodObject<{
+            bounding_box: z.ZodObject<{}, z.core.$loose>;
+            dimensions: z.ZodObject<{}, z.core.$loose>;
+            volume: z.ZodNumber;
+            surface_area: z.ZodNumber;
+            units: z.ZodObject<{}, z.core.$loose>;
+        }, z.core.$strip>;
+        readonly structure: z.ZodObject<{
+            body_count: z.ZodNumber;
+            shape_type: z.ZodString;
+            is_assembly: z.ZodBoolean;
+            product_count: z.ZodNumber;
+            schema: z.ZodOptional<z.ZodString>;
+            application_protocol: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly health: z.ZodObject<{
+            is_valid: z.ZodOptional<z.ZodBoolean>;
+            warning_count: z.ZodNumber;
+            high_warning_count: z.ZodNumber;
+            complexity: z.ZodObject<{}, z.core.$loose>;
+        }, z.core.$strip>;
+        readonly pmi: z.ZodObject<{}, z.core.$loose>;
+        readonly topology_summary: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        readonly geometry_extremes: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        readonly warnings: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        readonly limitations: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+    };
+    readonly findStepFaces: z.ZodObject<{
+        schema_version: z.ZodLiteral<"0.4">;
+        file_path: z.ZodString;
+        units: z.ZodObject<{}, z.core.$loose>;
+        coordinate_system: z.ZodObject<{}, z.core.$loose>;
+        query: z.ZodObject<{}, z.core.$loose>;
+        statistics: z.ZodObject<{}, z.core.$loose>;
+        pagination: z.ZodObject<{
+            limit: z.ZodNumber;
+            offset: z.ZodNumber;
+            returned: z.ZodNumber;
+            total_matched: z.ZodNumber;
+            has_more: z.ZodBoolean;
+        }, z.core.$strip>;
+        entities: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        groups: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        warnings: z.ZodArray<z.ZodUnknown>;
+        limitations: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>;
+    readonly findStepEdges: z.ZodObject<{
+        schema_version: z.ZodLiteral<"0.4">;
+        file_path: z.ZodString;
+        units: z.ZodObject<{}, z.core.$loose>;
+        coordinate_system: z.ZodObject<{}, z.core.$loose>;
+        query: z.ZodObject<{}, z.core.$loose>;
+        statistics: z.ZodObject<{}, z.core.$loose>;
+        pagination: z.ZodObject<{
+            limit: z.ZodNumber;
+            offset: z.ZodNumber;
+            returned: z.ZodNumber;
+            total_matched: z.ZodNumber;
+            has_more: z.ZodBoolean;
+        }, z.core.$strip>;
+        entities: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        groups: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        warnings: z.ZodArray<z.ZodUnknown>;
+        limitations: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>;
+    readonly getStepEntities: z.ZodObject<{
+        schema_version: z.ZodLiteral<"0.4">;
+        file_path: z.ZodString;
+        units: z.ZodObject<{}, z.core.$loose>;
+        coordinate_system: z.ZodObject<{}, z.core.$loose>;
+        query: z.ZodObject<{}, z.core.$loose>;
+        statistics: z.ZodObject<{}, z.core.$loose>;
+        pagination: z.ZodObject<{
+            limit: z.ZodNumber;
+            offset: z.ZodNumber;
+            returned: z.ZodNumber;
+            total_matched: z.ZodNumber;
+            has_more: z.ZodBoolean;
+        }, z.core.$strip>;
+        entities: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        groups: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        warnings: z.ZodArray<z.ZodUnknown>;
+        limitations: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>;
+    readonly compareStepFiles: z.ZodObject<{
+        schema_version: z.ZodLiteral<"0.4">;
+        files: z.ZodObject<{
+            a: z.ZodString;
+            b: z.ZodString;
+        }, z.core.$strip>;
+        deltas: z.ZodObject<{}, z.core.$loose>;
+        exchange: z.ZodObject<{}, z.core.$loose>;
+        warnings: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        limitations: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        providers: z.ZodObject<{}, z.core.$loose>;
+    }, z.core.$loose>;
+    readonly queryStepPmi: z.ZodObject<{
+        schema_version: z.ZodLiteral<"0.4">;
+        file_path: z.ZodString;
+        units: z.ZodObject<{}, z.core.$loose>;
+        coordinate_system: z.ZodObject<{}, z.core.$loose>;
+        query: z.ZodObject<{}, z.core.$loose>;
+        statistics: z.ZodObject<{}, z.core.$loose>;
+        pagination: z.ZodObject<{
+            limit: z.ZodNumber;
+            offset: z.ZodNumber;
+            returned: z.ZodNumber;
+            total_matched: z.ZodNumber;
+            has_more: z.ZodBoolean;
+        }, z.core.$strip>;
+        entities: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        groups: z.ZodArray<z.ZodObject<{}, z.core.$loose>>;
+        warnings: z.ZodArray<z.ZodUnknown>;
+        limitations: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>;
+};
+export declare function handleInspectStepFile(filePath: string): Promise<import("./shared.js").ToolResponse<{
+    schema_version: "0.4";
+    file_path: string;
+    identity: {
+        product_names: string[];
+        authoring_system: string | undefined;
+        organization_name: string | undefined;
+    };
+    size: {
+        bounding_box: import("../types/schema.js").BoundingBox;
+        dimensions: import("../types/schema.js").Dimensions;
+        volume: number;
+        surface_area: number;
+        units: import("../types/schema.js").UnitSystem;
+    };
+    structure: {
+        body_count: number;
+        shape_type: "box" | "cylindrical" | "complex";
+        is_assembly: boolean;
+        product_count: number;
+        schema: string | undefined;
+        application_protocol: string | undefined;
+    };
+    health: {
+        is_valid: boolean | undefined;
+        warning_count: number;
+        high_warning_count: number;
+        complexity: {
+            body_count: number;
+            face_count: number | undefined;
+            edge_count: number | undefined;
+        };
+    };
+    pmi: {
+        has_pmi: boolean;
+        has_gdt: boolean;
+        has_dimensions: boolean;
+        semantic_status: "unknown" | "not_detected" | "keyword_detected";
+        tolerance_entity_count: number;
+    };
+    topology_summary: {
+        faces: {
+            total: number | undefined;
+        };
+        edges: {
+            total: number;
+            by_curve_type: Record<string, number>;
+            by_length_bucket: Record<"medium" | "tiny" | "small" | "large" | "xlarge", number>;
+            length_range: {
+                min: number;
+                max: number;
+            };
+        } | undefined;
+    };
+    geometry_extremes: {
+        edges_length_lt_1_mm: number;
+        min_edge_length: number;
+    };
+    warnings: import("../types/schema.js").Warning[];
+    limitations: import("../types/schema.js").Limitation[];
+}>>;
+export declare function handleFindStepFaces(filePath: string, query: Record<string, unknown> | undefined): Promise<import("./shared.js").ToolResponse<StepQueryResponse<Record<string, unknown>>>>;
+export declare function handleFindStepEdges(filePath: string, query: Record<string, unknown> | undefined): Promise<import("./shared.js").ToolResponse<StepQueryResponse<Record<string, unknown>>>>;
+export declare function handleGetStepEntities(filePath: string, query: Record<string, unknown> | undefined): Promise<import("./shared.js").ToolResponse<StepQueryResponse<Record<string, unknown>>>>;
+export declare function handleCompareStepFiles(fileA: string, fileB: string): Promise<import("./shared.js").ToolResponse<{
+    schema_version: "0.4";
+    files: {
+        a: string;
+        b: string;
+    };
+    deltas: {
+        dimensions: {
+            width: number;
+            height: number;
+            depth: number;
+        };
+        volume: number;
+        surfaceArea: number;
+        bodyCount: number;
+        faceCount: number | undefined;
+        edgeCount: number | undefined;
+    };
+    exchange: {
+        schemaChanged: boolean;
+        productNamesA: string[];
+        productNamesB: string[];
+    };
+    warnings: import("../types/schema.js").Warning[];
+    limitations: import("../types/schema.js").Limitation[];
+    providers: {
+        a: import("../types/schema.js").ProviderInfo[];
+        b: import("../types/schema.js").ProviderInfo[];
+    };
+}>>;
+export declare function handleQueryStepPmi(filePath: string, query: Record<string, unknown> | undefined): Promise<import("./shared.js").ToolResponse<StepQueryResponse<Record<string, unknown>>>>;
+export declare function adaptFindStepFaces(query: Partial<PublicFindStepFacesInput> | undefined): QueryStepFacesInput;
+export declare function adaptFindStepEdges(query: Partial<PublicFindStepEdgesInput> | undefined): QueryStepEdgesInput;
+export declare function adaptPmiQuery(query: Partial<PublicQueryStepPmiInput> | undefined): QueryStepPmiInput;
+type InputFromShape<T extends Record<string, z.ZodType>> = {
+    [K in keyof T]: z.infer<T[K]>;
+};
+export type QueryStepFacesInput = InputFromShape<typeof internalFaceQuerySchema>;
+export type QueryStepEdgesInput = InputFromShape<typeof internalEdgeQuerySchema>;
+export type QueryStepPmiInput = InputFromShape<typeof internalPmiQuerySchema>;
+type PublicFindStepFacesInput = InputFromShape<typeof findStepFacesSchema>;
+type PublicFindStepEdgesInput = InputFromShape<typeof findStepEdgesSchema>;
+export type PublicGetStepEntitiesInput = InputFromShape<typeof getStepEntitiesSchema>;
+type PublicQueryStepPmiInput = InputFromShape<typeof pmiQuerySchema>;
+export interface StepQueryUnits {
+    length: 'mm';
+    area: 'mm^2';
+    volume: 'mm^3';
+    angle: 'deg';
+}
+export interface StepQueryCoordinateSystem {
+    origin: 'STEP model origin';
+    axes: 'model coordinates';
+    handedness: 'right';
+}
+export interface StepQueryPagination {
+    limit: number;
+    offset: number;
+    returned: number;
+    total_matched: number;
+    has_more: boolean;
+}
+export interface StepQueryGroup {
+    id: string;
+    key: Record<string, unknown>;
+    entity_count: number;
+    sample_entity_ids: string[];
+    sample_entity_limit: number;
+    sample_is_complete: boolean;
+    summary: Record<string, unknown>;
+}
+export interface StepQueryResponse<TEntity extends Record<string, unknown>> {
+    schema_version: typeof CAD_RESPONSE_SCHEMA_VERSION;
+    file_path: string;
+    units: StepQueryUnits;
+    coordinate_system: StepQueryCoordinateSystem;
+    query: Record<string, unknown>;
+    statistics: Record<string, unknown>;
+    pagination: StepQueryPagination;
+    entities: TEntity[];
+    groups: StepQueryGroup[];
+    warnings: unknown[];
+    limitations: unknown[];
+}
+export {};
+//# sourceMappingURL=step-tools.d.ts.map