// Cross-field: max must be >= min
Joi.object({
    min: Joi.number(),
    max: Joi.number().min(Joi.ref('min'))
});

// Self reference: use current value's own property
Joi.object({
    x: Joi.array().when('.length', {
        is: 2,
        then: Joi.array().items(2),
        otherwise: Joi.array().items(7)
    })
});

// Self reference in messages
Joi.number().min(10).message('{#label} is {[.]} and that is not good enough');

// Own property reference
Joi.object({ length: Joi.number().required() })
    .length(Joi.ref('.length'))
    .unknown();

// Parent reference (.. is equivalent to no prefix for sibling)
Joi.object({
    a: Joi.any(),
    a1: Joi.ref('a'),       // sibling (ancestor 1)
    a2: Joi.ref('..a')      // same thing explicitly
});

// Grandparent reference
Joi.object({
    a: Joi.any(),
    b: {
        c: Joi.ref('...a')  // ancestor 2 (grandparent)
    }
});

// Deep ancestor reference (4 dots = ancestor 3)
Joi.object({
    f: { g: Joi.any() },
    a: {
        b: {
            gx: Joi.ref('....f.g')  // ancestor 3
        }
    }
});

// Root reference
Joi.object({
    limit: Joi.number(),
    nested: Joi.object({
        deep: Joi.object({
            count: Joi.number().max(Joi.ref('/limit'))
        })
    })
});

// Context reference
Joi.number().max(Joi.ref('$serverLimit'));
// Pass context: schema.validate(value, { context: { serverLimit: 100 } });

// Nested context reference
Joi.boolean().when('$x.y', { is: Joi.exist(), otherwise: Joi.forbidden() });

// Ref as default value
Joi.object({
    a: Joi.any().default(Joi.ref('b')),
    b: Joi.any()
});

// Ref mixed with literal values in .valid()
Joi.object({
    a: Joi.number().valid(1, Joi.ref('b')),
    b: Joi.any()
});

// Ref in array context (references array item by index)
Joi.array().ordered(Joi.number(), Joi.number().min(Joi.ref('0')));

// Ref to array .length property
Joi.object({
    x: Joi.array().items(Joi.number().valid(Joi.ref('length')))
});

// Adjust: double the referenced value
Joi.number().max(Joi.ref('base', { adjust: (v) => v * 2 }));

// Map: convert enum to limits
Joi.number().max(Joi.ref('tier', {
    map: [['basic', 100], ['premium', 1000]]
}));

// Custom separator
Joi.ref('b/c', { separator: '/' });

// Literal key with no path parsing
Joi.ref('...a', { separator: false });  // looks for sibling key literally named "...a"

// Literal key with explicit ancestor
Joi.ref('...a', { separator: false, ancestor: 2 });  // grandparent's key "...a"

// Custom prefix
Joi.ref('@x', { prefix: { global: '@' } });  // same as Joi.ref('$x')
Joi.ref('@a', { prefix: { root: '@' } });     // same as Joi.ref('/a')

// Render option: show resolved value in error messages
const ref = Joi.ref('a', { render: true });
Joi.object({
    a: Joi.number(),
    b: Joi.number().min(ref)
});
// Error: "b" must be greater than or equal to 10
// Without render: "b" must be greater than or equal to ref:a

// Iterables: traverse into Set and Map
Joi.object({
    a: {
        b: Joi.array()
            .items({ x: Joi.number(), y: Joi.object().cast('map') })
            .cast('set')
    },
    d: Joi.ref('a.b.2.y.w', { iterables: true })
});

Joi.object({
    roles: Joi.array().items(Joi.string()),
    primary: Joi.string().valid(Joi.in('roles'))
});

const ref = Joi.in('a', { render: true });
// Error shows: "b" must be [1, 2, 3]

Joi.object({
    a: Joi.number(),
    b: Joi.number(),
    sum: Joi.number().valid(Joi.x('{a + b}'))
});

// Use time constants in expressions
Joi.date().max(Joi.x('{now + 7 * day}'));

// Conditional in expression
Joi.x('{if(a > 10, "big", "small")}')

// Length in rule argument
Joi.object({
    a: Joi.array().length(Joi.x('{length(b)}')),
    b: Joi.object()
});

// Number casting
Joi.valid(Joi.x('{number(1) + number(true) + number("1")}'))  // resolves to 3

// Cross-reference messages
Joi.string().messages({
    'string.min': '{msg("custom.hint")} - too short',
    'custom.hint': 'Please check requirements'
});

// Custom function
Joi.object().rename(/.*/, Joi.x('{ uppercase(#0) }', {
    functions: {
        uppercase(value) {
            return typeof value === 'string' ? value.toUpperCase() : value;
        }
    }
}));
// { a: 1, b: 2 } -> { A: 1, B: 2 }

// Override built-in function
Joi.object({
    a: Joi.array().length(Joi.x('{length(b)}', {
        functions: {
            length(value) {
                return value.length - 1;
            }
        }
    })),
    b: Joi.string()
});

Joi.string().min(3).messages({
    'string.min': '{{#label}} needs at least {{#limit}} chars (got {{#value}})'
});

// #label - the field label (automatically wrapped with label wrap chars)
// #limit - the rule argument
// #value - the actual value being validated

Joi.isRef(Joi.ref('a.b'));  // true
Joi.isRef('a.b');           // false
Joi.isRef(null);            // false

Joi.isExpression(Joi.x('{a + b}'));  // true
Joi.isExpression('test');            // false
Joi.isExpression(null);              // false