export interface V1VisionStepResultsItem {
    angleCheck?: V1VisionStepResultsItem.AngleCheck | undefined;
    barcode?: V1VisionStepResultsItem.Barcode.Item[] | undefined;
    booleanLogic?: V1VisionStepResultsItem.BooleanLogic | undefined;
    caliper?: V1VisionStepResultsItem.Caliper | undefined;
    contour?: V1VisionStepResultsItem.Contour | undefined;
    distance?: V1VisionStepResultsItem.Distance | undefined;
    expirationDate?: V1VisionStepResultsItem.ExpirationDate | undefined;
    findCopies?: V1VisionStepResultsItem.FindCopies | undefined;
    findEdge?: V1VisionStepResultsItem.FindEdge | undefined;
    findShapes?: V1VisionStepResultsItem.FindShapes | undefined;
    fixture?: V1VisionStepResultsItem.Fixture | undefined;
    labelMatch?: V1VisionStepResultsItem.LabelMatch | undefined;
    name?: string | undefined;
    presenceAbsence?: V1VisionStepResultsItem.PresenceAbsence | undefined;
    result?: string | undefined;
    textMatch?: V1VisionStepResultsItem.TextMatch | undefined;
}
export declare namespace V1VisionStepResultsItem {
    interface AngleCheck {
        /** The configured angle allowance range (in degrees) */
        angleConfigured?: AngleCheck.AngleConfigured | undefined;
        /** The counter-clockwise angle detected from the first edge to the second edge */
        angleFound?: number | undefined;
        /** The name of the second reference step used to check the angle */
        endStepName?: string | undefined;
        /** The name of the first reference step used to check the angle */
        startStepName?: string | undefined;
    }
    namespace AngleCheck {
        /**
         * The configured angle allowance range (in degrees)
         */
        interface AngleConfigured {
            high?: number | undefined;
            low?: number | undefined;
        }
    }
    type Barcode = Barcode.Item[];
    namespace Barcode {
        interface Item {
            contents?: string | undefined;
            matchString?: string | undefined;
            type?: string | undefined;
        }
    }
    interface BooleanLogic {
        operator?: string | undefined;
        steps?: BooleanLogic.Steps.Item[] | undefined;
    }
    namespace BooleanLogic {
        type Steps = Steps.Item[];
        namespace Steps {
            interface Item {
                name?: string | undefined;
                result?: string | undefined;
            }
        }
    }
    interface Caliper {
        /** The configured angle allowance range */
        angleRange?: Caliper.AngleRange | undefined;
        /** The configured contrast allowance range */
        contrastRange?: Caliper.ContrastRange | undefined;
        /** The distance found between the found edges */
        distanceFound?: number | undefined;
        /** The configured polarity for finding edges. Valid values: `LIGHT TO DARK`, `DARK TO LIGHT`. */
        filterPolarity?: Caliper.FilterPolarity | undefined;
        /** The maximum allowed distance threshold */
        maxDistance?: number | undefined;
        /** The minumum allowed distance threshold */
        minDistance?: number | undefined;
        /** The configured sharpness allowance range */
        sharpnessRange?: Caliper.SharpnessRange | undefined;
        /** The configured straightness allowance range */
        straightnessRange?: Caliper.StraightnessRange | undefined;
        /** The measurement unit of the distance found and the min and max distance threshold */
        unit?: string | undefined;
    }
    namespace Caliper {
        /**
         * The configured angle allowance range
         */
        interface AngleRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        /**
         * The configured contrast allowance range
         */
        interface ContrastRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        /** The configured polarity for finding edges. Valid values: `LIGHT TO DARK`, `DARK TO LIGHT`. */
        const FilterPolarity: {
            readonly LightToDark: "LIGHT TO DARK";
            readonly DarkToLight: "DARK TO LIGHT";
        };
        type FilterPolarity = (typeof FilterPolarity)[keyof typeof FilterPolarity];
        /**
         * The configured sharpness allowance range
         */
        interface SharpnessRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        /**
         * The configured straightness allowance range
         */
        interface StraightnessRange {
            high?: number | undefined;
            low?: number | undefined;
        }
    }
    interface Contour {
        /** The rotation angle found */
        angleDegrees?: number | undefined;
        /** The rotation angle allowance */
        angleTolerance?: number | undefined;
        /** The contour match percentage with the configured contour */
        matchPercentage?: number | undefined;
        /** The configured match threshold for contours */
        matchThreshold?: number | undefined;
    }
    interface Distance {
        /** The distance found between the start and end references */
        distanceFound?: number | undefined;
        /** The name of the second reference step that we're checking the distances between */
        endStepName?: string | undefined;
        /** Whether an offset angle range is enforced */
        enforceOffsetAngleRange?: boolean | undefined;
        /** The maximum allowed distance threshold */
        maxDistance?: number | undefined;
        /** The maximum angle allowance (in degrees) if enforceOffsetAngleRange is true */
        maxOffsetAngle?: number | undefined;
        /** The minumum allowed distance threshold */
        minDistance?: number | undefined;
        /** The minimum angle allowance (in degrees) if enforceOffsetAngleRange is true */
        minOffsetAngle?: number | undefined;
        /** The counter-clockwise angle (in degrees) found between the horizontal axis of the start reference step and the last */
        offsetAngleFound?: number | undefined;
        /** The name of the first reference step that we're checking the distances between */
        startStepName?: string | undefined;
        /** The measurement unit of the distance found and the min and max distance threshold */
        unit?: string | undefined;
    }
    interface ExpirationDate {
        dateOffset?: number | undefined;
        foundDate?: string | undefined;
        matchDate?: string | undefined;
    }
    interface FindCopies {
        /** The orientation angle tolerance (+/- °) */
        angleTolerance?: number | undefined;
        /** The number of copies found */
        foundCount?: number | undefined;
        /** The maximum number of copies allowed */
        maxCount?: number | undefined;
        /** The minimum number of copies allowed */
        minCount?: number | undefined;
        /** The minimum required similarity (in %) of a found copy compared to the configured match region */
        threshold?: number | undefined;
    }
    interface FindEdge {
        /** The detected angle in degrees */
        angleFound?: number | undefined;
        /** The configured angle allowance range */
        angleRange?: FindEdge.AngleRange | undefined;
        /** The detected contrast percentage */
        contrastPercent?: number | undefined;
        /** The configured contrast allowance range */
        contrastRange?: FindEdge.ContrastRange | undefined;
        /** The configured polarity for finding edges. Valid values: `LIGHT TO DARK`, `DARK TO LIGHT`. */
        filterPolarity?: string | undefined;
        /** The detected sharpness percentage */
        sharpnessPercent?: number | undefined;
        /** The configured sharpness allowance range */
        sharpnessRange?: FindEdge.SharpnessRange | undefined;
        /** The detected straightness percentage */
        straightnessFound?: number | undefined;
        /** The configured straightness allowance range */
        straightnessRange?: FindEdge.StraightnessRange | undefined;
    }
    namespace FindEdge {
        /**
         * The configured angle allowance range
         */
        interface AngleRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        /**
         * The configured contrast allowance range
         */
        interface ContrastRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        /**
         * The configured sharpness allowance range
         */
        interface SharpnessRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        /**
         * The configured straightness allowance range
         */
        interface StraightnessRange {
            high?: number | undefined;
            low?: number | undefined;
        }
    }
    interface FindShapes {
        foundCount?: number | undefined;
        maxCount?: number | undefined;
        minCount?: number | undefined;
    }
    interface Fixture {
        coordinates?: Fixture.Coordinates | undefined;
        found?: boolean | undefined;
        rotationDegrees?: number | undefined;
    }
    namespace Fixture {
        interface Coordinates {
            x?: number | undefined;
            y?: number | undefined;
        }
    }
    interface LabelMatch {
        score?: number | undefined;
        threshold?: number | undefined;
    }
    interface PresenceAbsence {
        blueRange?: PresenceAbsence.BlueRange | undefined;
        checkForAbsence?: boolean | undefined;
        grayscaleRange?: PresenceAbsence.GrayscaleRange | undefined;
        greenRange?: PresenceAbsence.GreenRange | undefined;
        hueRange?: PresenceAbsence.HueRange | undefined;
        redRange?: PresenceAbsence.RedRange | undefined;
        saturationRange?: PresenceAbsence.SaturationRange | undefined;
        score?: number | undefined;
        threshold?: number | undefined;
        valueRange?: PresenceAbsence.ValueRange | undefined;
    }
    namespace PresenceAbsence {
        interface BlueRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        interface GrayscaleRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        interface GreenRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        interface HueRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        interface RedRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        interface SaturationRange {
            high?: number | undefined;
            low?: number | undefined;
        }
        interface ValueRange {
            high?: number | undefined;
            low?: number | undefined;
        }
    }
    interface TextMatch {
        foundText?: string | undefined;
        matchString?: string | undefined;
    }
}