import { z } from 'zod';

declare const TestContextSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
declare const TestActionTypeSchema: z.ZodEnum<{
    create_record: "create_record";
    update_record: "update_record";
    delete_record: "delete_record";
    read_record: "read_record";
    query_records: "query_records";
    api_call: "api_call";
    run_script: "run_script";
    wait: "wait";
}>;
declare const TestActionSchema: z.ZodObject<{
    type: z.ZodEnum<{
        create_record: "create_record";
        update_record: "update_record";
        delete_record: "delete_record";
        read_record: "read_record";
        query_records: "query_records";
        api_call: "api_call";
        run_script: "run_script";
        wait: "wait";
    }>;
    target: z.ZodString;
    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    user: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const TestAssertionTypeSchema: z.ZodEnum<{
    error: "error";
    contains: "contains";
    not_contains: "not_contains";
    is_null: "is_null";
    equals: "equals";
    gt: "gt";
    gte: "gte";
    lt: "lt";
    lte: "lte";
    not_equals: "not_equals";
    not_null: "not_null";
}>;
declare const TestAssertionSchema: z.ZodObject<{
    field: z.ZodString;
    operator: z.ZodEnum<{
        error: "error";
        contains: "contains";
        not_contains: "not_contains";
        is_null: "is_null";
        equals: "equals";
        gt: "gt";
        gte: "gte";
        lt: "lt";
        lte: "lte";
        not_equals: "not_equals";
        not_null: "not_null";
    }>;
    expectedValue: z.ZodUnknown;
}, z.core.$strip>;
declare const TestStepSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    action: z.ZodObject<{
        type: z.ZodEnum<{
            create_record: "create_record";
            update_record: "update_record";
            delete_record: "delete_record";
            read_record: "read_record";
            query_records: "query_records";
            api_call: "api_call";
            run_script: "run_script";
            wait: "wait";
        }>;
        target: z.ZodString;
        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        user: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        operator: z.ZodEnum<{
            error: "error";
            contains: "contains";
            not_contains: "not_contains";
            is_null: "is_null";
            equals: "equals";
            gt: "gt";
            gte: "gte";
            lt: "lt";
            lte: "lte";
            not_equals: "not_equals";
            not_null: "not_null";
        }>;
        expectedValue: z.ZodUnknown;
    }, z.core.$strip>>>;
    capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, z.core.$strip>;
declare const TestScenarioSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    setup: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        action: z.ZodObject<{
            type: z.ZodEnum<{
                create_record: "create_record";
                update_record: "update_record";
                delete_record: "delete_record";
                read_record: "read_record";
                query_records: "query_records";
                api_call: "api_call";
                run_script: "run_script";
                wait: "wait";
            }>;
            target: z.ZodString;
            payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            user: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>;
        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            operator: z.ZodEnum<{
                error: "error";
                contains: "contains";
                not_contains: "not_contains";
                is_null: "is_null";
                equals: "equals";
                gt: "gt";
                gte: "gte";
                lt: "lt";
                lte: "lte";
                not_equals: "not_equals";
                not_null: "not_null";
            }>;
            expectedValue: z.ZodUnknown;
        }, z.core.$strip>>>;
        capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strip>>>;
    steps: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        action: z.ZodObject<{
            type: z.ZodEnum<{
                create_record: "create_record";
                update_record: "update_record";
                delete_record: "delete_record";
                read_record: "read_record";
                query_records: "query_records";
                api_call: "api_call";
                run_script: "run_script";
                wait: "wait";
            }>;
            target: z.ZodString;
            payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            user: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>;
        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            operator: z.ZodEnum<{
                error: "error";
                contains: "contains";
                not_contains: "not_contains";
                is_null: "is_null";
                equals: "equals";
                gt: "gt";
                gte: "gte";
                lt: "lt";
                lte: "lte";
                not_equals: "not_equals";
                not_null: "not_null";
            }>;
            expectedValue: z.ZodUnknown;
        }, z.core.$strip>>>;
        capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strip>>;
    teardown: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        action: z.ZodObject<{
            type: z.ZodEnum<{
                create_record: "create_record";
                update_record: "update_record";
                delete_record: "delete_record";
                read_record: "read_record";
                query_records: "query_records";
                api_call: "api_call";
                run_script: "run_script";
                wait: "wait";
            }>;
            target: z.ZodString;
            payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            user: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>;
        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            operator: z.ZodEnum<{
                error: "error";
                contains: "contains";
                not_contains: "not_contains";
                is_null: "is_null";
                equals: "equals";
                gt: "gt";
                gte: "gte";
                lt: "lt";
                lte: "lte";
                not_equals: "not_equals";
                not_null: "not_null";
            }>;
            expectedValue: z.ZodUnknown;
        }, z.core.$strip>>>;
        capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strip>>>;
    requires: z.ZodOptional<z.ZodObject<{
        params: z.ZodOptional<z.ZodArray<z.ZodString>>;
        plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
declare const TestSuiteSchema: z.ZodObject<{
    name: z.ZodString;
    scenarios: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        setup: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            action: z.ZodObject<{
                type: z.ZodEnum<{
                    create_record: "create_record";
                    update_record: "update_record";
                    delete_record: "delete_record";
                    read_record: "read_record";
                    query_records: "query_records";
                    api_call: "api_call";
                    run_script: "run_script";
                    wait: "wait";
                }>;
                target: z.ZodString;
                payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                user: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>;
            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                field: z.ZodString;
                operator: z.ZodEnum<{
                    error: "error";
                    contains: "contains";
                    not_contains: "not_contains";
                    is_null: "is_null";
                    equals: "equals";
                    gt: "gt";
                    gte: "gte";
                    lt: "lt";
                    lte: "lte";
                    not_equals: "not_equals";
                    not_null: "not_null";
                }>;
                expectedValue: z.ZodUnknown;
            }, z.core.$strip>>>;
            capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.core.$strip>>>;
        steps: z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            action: z.ZodObject<{
                type: z.ZodEnum<{
                    create_record: "create_record";
                    update_record: "update_record";
                    delete_record: "delete_record";
                    read_record: "read_record";
                    query_records: "query_records";
                    api_call: "api_call";
                    run_script: "run_script";
                    wait: "wait";
                }>;
                target: z.ZodString;
                payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                user: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>;
            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                field: z.ZodString;
                operator: z.ZodEnum<{
                    error: "error";
                    contains: "contains";
                    not_contains: "not_contains";
                    is_null: "is_null";
                    equals: "equals";
                    gt: "gt";
                    gte: "gte";
                    lt: "lt";
                    lte: "lte";
                    not_equals: "not_equals";
                    not_null: "not_null";
                }>;
                expectedValue: z.ZodUnknown;
            }, z.core.$strip>>>;
            capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.core.$strip>>;
        teardown: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            action: z.ZodObject<{
                type: z.ZodEnum<{
                    create_record: "create_record";
                    update_record: "update_record";
                    delete_record: "delete_record";
                    read_record: "read_record";
                    query_records: "query_records";
                    api_call: "api_call";
                    run_script: "run_script";
                    wait: "wait";
                }>;
                target: z.ZodString;
                payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                user: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>;
            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                field: z.ZodString;
                operator: z.ZodEnum<{
                    error: "error";
                    contains: "contains";
                    not_contains: "not_contains";
                    is_null: "is_null";
                    equals: "equals";
                    gt: "gt";
                    gte: "gte";
                    lt: "lt";
                    lte: "lte";
                    not_equals: "not_equals";
                    not_null: "not_null";
                }>;
                expectedValue: z.ZodUnknown;
            }, z.core.$strip>>>;
            capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.core.$strip>>>;
        requires: z.ZodOptional<z.ZodObject<{
            params: z.ZodOptional<z.ZodArray<z.ZodString>>;
            plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type TestSuite = z.infer<typeof TestSuiteSchema>;
type TestScenario = z.infer<typeof TestScenarioSchema>;
type TestStep = z.infer<typeof TestStepSchema>;
type TestAction = z.infer<typeof TestActionSchema>;
type TestAssertion = z.infer<typeof TestAssertionSchema>;

/**
 * Quality Assurance (QA) Protocol
 *
 * Defines how business logic and metadata are tested.
 * Includes:
 * - Test Scenarios
 * - Test Cases
 * - Expected Outcomes
 */

type index_TestAction = TestAction;
declare const index_TestActionSchema: typeof TestActionSchema;
declare const index_TestActionTypeSchema: typeof TestActionTypeSchema;
type index_TestAssertion = TestAssertion;
declare const index_TestAssertionSchema: typeof TestAssertionSchema;
declare const index_TestAssertionTypeSchema: typeof TestAssertionTypeSchema;
declare const index_TestContextSchema: typeof TestContextSchema;
type index_TestScenario = TestScenario;
declare const index_TestScenarioSchema: typeof TestScenarioSchema;
type index_TestStep = TestStep;
declare const index_TestStepSchema: typeof TestStepSchema;
type index_TestSuite = TestSuite;
declare const index_TestSuiteSchema: typeof TestSuiteSchema;
declare namespace index {
  export { type index_TestAction as TestAction, index_TestActionSchema as TestActionSchema, index_TestActionTypeSchema as TestActionTypeSchema, type index_TestAssertion as TestAssertion, index_TestAssertionSchema as TestAssertionSchema, index_TestAssertionTypeSchema as TestAssertionTypeSchema, index_TestContextSchema as TestContextSchema, type index_TestScenario as TestScenario, index_TestScenarioSchema as TestScenarioSchema, type index_TestStep as TestStep, index_TestStepSchema as TestStepSchema, type index_TestSuite as TestSuite, index_TestSuiteSchema as TestSuiteSchema };
}

export { TestContextSchema as T, TestActionTypeSchema as a, TestActionSchema as b, TestAssertionTypeSchema as c, TestAssertionSchema as d, TestStepSchema as e, TestScenarioSchema as f, TestSuiteSchema as g, type TestSuite as h, index as i, type TestScenario as j, type TestStep as k, type TestAction as l, type TestAssertion as m };
