15-15: Verify mockery version upgrade compatibility

The upgrade from v2.46 to v2.50 should be verified for:

1. Breaking changes in the generated mocks
2. Compatibility with the current codebase
3. Latest stable version availability

Also applies to: 18-18

#!/bin/bash
# Check latest mockery version and changelog
gh api \
  -H "Accept: application/vnd.github+json" \
  repos/vektra/mockery/releases | jq -r '.[0:3] | .[] | "Version: \(.tag_name)\nPublished: \(.published_at)\n\(.body)\n"'

52-54: LGTM: Consistent mock implementation

The implementation change matches the pattern used in other mock files, maintaining consistency across the codebase.

21-21: LGTM: Type system updates align with mockery upgrade

The changes from any to interface{} are type-safe and backwards compatible. These modifications are consistent with the mockery upgrade and maintain the same runtime behavior.

Also applies to: 29-29, 44-44, 49-49, 51-51, 61-61

20-21: LGTM: Consistent type system updates for map returns

The changes from map[string]any to map[string]interface{} maintain type safety and are consistent with the mockery upgrade pattern.

Also applies to: 28-29, 33-33, 57-57, 62-62

53-53: Verify mock behavior after RunAndReturn implementation change

The implementation has changed from using _c.Call.Return(run) to _c.Run(run). While this aligns with the mockery upgrade, it represents a behavioral change in how mock functions are executed.

Let's verify the impact on existing tests:

Consider adding a comment in the PR description noting this behavioral change, as it might affect how mock expectations are verified in tests.

#!/bin/bash
# Search for test files that might be affected by this change
rg -l "RunAndReturn.*SetContext" --type go --glob "**/*_test.go"

#!/bin/bash
# Let's try a broader search to understand the usage of RunAndReturn
rg "RunAndReturn" --type go -A 3 -B 3

#!/bin/bash
# Let's also check for any test files using QueryWithSetContext
rg "QueryWithSetContext" --type go --glob "**/*_test.go" -A 3 -B 3

#!/bin/bash
# Let's examine the mock implementation more closely
cat mocks/database/orm/QueryWithSetContext.go

24-24: LGTM: Type system updates are consistent with mockery upgrade

The changes from any to interface{} and the corresponding method signature updates are correct and align with the mockery upgrade. The implementation maintains type safety while providing better compatibility.

Also applies to: 34-37, 40-42, 52-53

20-20: LGTM: Documentation improvements enhance clarity

The updated comments better describe the mock function signatures by explicitly stating they have "no fields". This improves code documentation accuracy.

Also applies to: 65-65

52-52: Verify the RunAndReturn behavior change

The implementation has changed from directly returning the run function to executing it through the Run method. While this change is part of the mockery upgrade, we should verify that existing tests aren't affected by this behavioral change.

Also applies to: 85-85

#!/bin/bash
# Search for test files that use RunAndReturn with these mocks
rg -l "RunAndReturn" --type go --glob "*_test.go"

#!/bin/bash
# Check the usage context of RunAndReturn in the test file
rg "RunAndReturn" -B 3 -A 3 database/migration/default_migrator_test.go

#!/bin/bash
# Find the mock definition of RunAndReturn to understand the change
ast-grep --pattern 'func $_($_, $_) RunAndReturn($_, $_) {
  $$$
}'

#!/bin/bash
# Look for any other potential usages of RunAndReturn pattern
rg "RunAndReturn" -g "!*_test.go" --type go

#!/bin/bash
# Check the implementation of RunAndReturn in ServiceProvider.go
rg -A 10 "func \(_c \*Context_Run_Call\) RunAndReturn" mocks/foundation/ServiceProvider.go

#!/bin/bash
# Look for the original implementation to compare
rg -A 10 "func \(_c \*Context_Call_Return\)" mocks/foundation/ServiceProvider.go

#!/bin/bash
# Look at the test context where RunAndReturn is used
rg -B 5 -A 5 "RunAndReturn" database/migration/default_migrator_test.go

#!/bin/bash
# Check the implementation of Run method in the mock
rg -A 5 "func \(_c \*Context\) Run" mocks/foundation/ServiceProvider.go

21-21: LGTM: Type changes are consistent and correct

The changes from any to interface{} are properly implemented across the Handle method and its related functions. The type assertions and error handling remain intact.

Also applies to: 31-31, 54-57, 70-70

21-21: LGTM: Type changes are properly implemented

The conversion from any to interface{} is correctly implemented across Marshal and Unmarshal methods, maintaining proper type assertions and error handling.

Also applies to: 30-30, 33-33, 41-41, 56-56, 61-61, 63-63, 73-73, 79-79, 87-87, 103-103, 108-108, 110-110, 120-120

24-24: LGTM: Type changes are consistent with other mock files

The changes from any to interface{} are properly implemented across First and Make methods, maintaining correct handling of variadic parameters and type assertions.

Let's verify the consistency of these changes across the codebase:

Also applies to: 35-35, 53-53, 59-59, 61-61, 64-64, 77-77, 83-83, 94-94, 112-112, 118-118, 120-120, 123-123, 136-136

#!/bin/bash
# Description: Verify that all mock files have been updated consistently
# Look for any remaining instances of "any" type in mock files

# Search for any remaining "any" type usage in mock files
echo "Checking for remaining 'any' type usage in mock files..."
rg "any" "mocks/"

# Search for interface{} usage in mock files to confirm the changes
echo "Verifying interface{} usage in mock files..."
rg "interface{}" "mocks/"

#!/bin/bash
# Let's try a different approach to search for type declarations
# First, let's look for function signatures in ResponseView.go
echo "Checking function signatures in ResponseView.go..."
rg "func.*\(" "mocks/http/ResponseView.go"

# Then, let's search for parameter types in mock files
echo "Checking parameter types in mock files..."
rg "\(.*interface\{.*\)" "mocks/http/"

# Let's also check for any type declarations
echo "Checking for any type declarations..."
rg "any" "mocks/http/"

24-24: LGTM! Type system changes look correct.

The changes from any to interface{} are consistent with the mockery upgrade. The type assertions and variable declarations are properly updated throughout the mock implementation.

Let's verify that all usages of this mock are compatible with the new signatures:

Also applies to: 34-34, 51-51, 57-62, 75-75

#!/bin/bash
# Description: Check for any potential incompatibilities with the updated mock
# Look for test files using this mock
rg -l "mocks/errors.Error" --type go --type-add "go:*.go"

#!/bin/bash
# Let's try a different approach to find usages of the Error mock
# First, let's check if the mock is imported using a different path
rg -l "\".*mocks.*Error\"" --type go

# Also search for any direct usage of Error type or its methods
rg "Error\s*\{|Error\s*\(" --type go -C 2

#!/bin/bash
# Let's search for actual usages of the Error mock's Args method
rg "Args\(" -B 2 -A 2 --type go

# Also search for any imports of the errors mock package to find test files using it
rg "\".*mocks/errors\"" --type go

148-148: Improved RunAndReturn behavior.

The change from _c.Call.Return(run) to _c.Run(run) is more correct as it executes the run function instead of just returning it. This ensures that mock expectations are properly handled during testing.

Let's verify the impact of this change on existing tests:

#!/bin/bash
# Description: Look for tests that might be affected by the RunAndReturn behavior change
rg -B 3 -A 3 "RunAndReturn.*map\[event\.Event\]" --type go

#!/bin/bash
# Find all usages of RunAndReturn in test files
rg -B 3 -A 3 "RunAndReturn" --type go --glob "*_test.go"

# Find all usages of GetEvents mock in test files
rg -B 3 -A 3 "GetEvents" --type go --glob "*_test.go"

#!/bin/bash
# Find the implementation of GetEvents in the actual code
ast-grep --pattern 'func $_GetEvents() map[event.Event][]event.Listener'

# Look for the actual Instance implementation
rg -B 3 -A 3 "type Instance struct" --type go

53-53: Consistent RunAndReturn behavior across mocks.

The RunAndReturn implementation changes in both For and ForWithLimits methods align with the pattern seen in other mocks, ensuring consistent behavior across the codebase.

Let's verify the consistency of RunAndReturn implementations across all mocks:

Also applies to: 87-87

#!/bin/bash
# Description: Check for any inconsistent RunAndReturn implementations
# Look for any remaining instances of Call.Return(run) in RunAndReturn methods
rg "RunAndReturn.*\{.*Call\.Return\(run\)" --type go

#!/bin/bash
# Let's search for all RunAndReturn implementations to verify consistency
ast-grep --pattern 'func $_($$$) RunAndReturn($$$) {
  $$$
}'

# Also search for Call.Return patterns to ensure no inconsistencies
rg "Call\.Return" --type go -A 2 -B 2

#!/bin/bash
# Let's search for RunAndReturn implementations in RateLimiter.go to verify the changes
rg "RunAndReturn.*\{" mocks/http/RateLimiter.go -A 3 -B 1

Line range hint 24-34: LGTM! Type system changes look correct.

The changes from any to interface{} are consistent with Go's type system and the mockery upgrade. The implementation maintains type safety while providing the same functionality.

Let's verify if this change is consistent across the codebase:

Also applies to: 55-64, 73-75, 79-89, 110-119, 128-130

#!/bin/bash
# Check if there are any remaining instances of the 'any' type
# that should have been converted to 'interface{}'
rg '\bany\b' --type go

98-99: LGTM! RunAndReturn implementation improved.

The change from _c.Call.Return(run) to _c.Run(run) is a cleaner implementation that maintains the same functionality while reducing indirection.

Also applies to: 131-132

Line range hint 66-84: LGTM! Comprehensive type system updates.

The changes successfully update all type signatures from any to interface{}, including:

• Method signatures
• Return types
• Variadic parameters
• Type assertions
• Map types

The implementation maintains type safety and proper handling of nil values.

Also applies to: 103-110, 114-115, 125-132, 142-144, 148-165, 177-190, 196-203

163-163: Documentation improvement

The comment clarification that GetSeeders provides a mock function with no fields enhances code readability.

239-239: Implementation aligned with Mockery's best practices

The change from _c.Call.Return(run) to _c.Run(run) in RunAndReturn aligns with Mockery's recommended implementation pattern for handling mock function execution.

150-150: Consistent mock implementation updates

The changes maintain consistency with Mockery's latest practices:

1. Updated RunAndReturn implementations to use _c.Run(run)
2. Added clear documentation about method signatures

Also applies to: 154-154, 182-182

71-71: Consistent mock implementation updates

The changes align with the Mockery upgrade patterns seen in other files:

1. Enhanced documentation clarity for GetJobs
2. Updated RunAndReturn implementation to use _c.Run(run)

Also applies to: 196-196

73-73: LGTM! Type system changes maintain compatibility

The changes from any to interface{} maintain backward compatibility while potentially supporting environments where any type alias might not be available. The implementation logic remains unchanged.

Also applies to: 81-81, 98-98, 103-103, 105-105, 115-115, 169-169, 180-180, 198-198, 204-204, 206-206, 209-209, 222-222

65-65: LGTM! Improved mock behavior consistency.

The changes to RunAndReturn methods now correctly use Run(run) instead of Call.Return(run), which fixes potential issues with mock behavior. This is a positive change from the mockery upgrade.

Also applies to: 143-143

Line range hint 1-324: LGTM! Consistent type system improvements.

The changes align with the other mock files, replacing any with interface{} and improving method documentation. These modifications enhance type safety while maintaining backward compatibility.

Line range hint 1-1: Verify mockery upgrade process.

The changes appear to be from upgrading the mockery tool. To ensure a smooth transition:

1. Verify that all mock files have been regenerated consistently
2. Check if there are any breaking changes in the new mockery version
3. Update any documentation or guidelines related to mock generation

#!/bin/bash
# Description: Verify consistent mock generation and potential manual modifications

# Check if all mock files have the generation header
echo "Checking for proper generation headers..."
rg -l "Code generated by mockery" mocks/

# Look for any uncommitted changes in mock files
echo "Checking for any uncommitted changes in mock files..."
git status --porcelain "mocks/"

# Check for potential manual modifications
echo "Checking for files missing generation header..."
fd . mocks/ -t f -e go | grep -v "_test.go" | xargs rg -L "Code generated by mockery"

Line range hint 21-327: LGTM! Type system update is consistent and backward-compatible.

The changes from any to interface{} are consistently applied across all method signatures and their implementations. This is a safe change as any is just an alias for interface{} in Go 1.18+.

Line range hint 73-373: LGTM! Type system update and documentation improvements are well implemented.

The changes maintain consistency with other mock files while improving method documentation. All type assertions and return value handling are properly updated.

Line range hint 21-338: LGTM! Verify the impact on existing tests.

The type system updates are consistent and well-implemented. Since this is a configuration mock that's likely widely used, we should verify the impact on existing tests.

#!/bin/bash
# Description: Find test files that might be affected by the Config mock changes

# Search for test files using the Config mock
rg -l "mock.*Config" --type go --type-add 'go:*.go' | grep "_test.go"

#!/bin/bash
# Let's check a sample of test files to verify if they're using the mock Config correctly
# We'll look at a few key test files from different packages

echo "=== Checking queue/config_test.go ==="
rg -A 5 "mock.*Config" queue/config_test.go

echo -e "\n=== Checking database/db/config_builder_test.go ==="
rg -A 5 "mock.*Config" database/db/config_builder_test.go

echo -e "\n=== Checking foundation/application_test.go ==="
rg -A 5 "mock.*Config" foundation/application_test.go

# Also check if there are any direct type assertions to string/bool/int
# which might be affected by the mock changes
echo -e "\n=== Checking for type assertions in test files ==="
rg "config\.(Get|GetString|GetBool|GetInt)\(.*\)\.(string|bool|int)" --type go | grep "_test.go"

Line range hint 127-139: LGTM: Type system changes look good

The change from any to interface{} in the Login method and its return handling is consistent with Go's type system. The implementation correctly handles type assertions and maintains the expected behavior.

Also applies to: 145-148

165-167: LGTM: Mock helper methods are properly updated

The helper methods Run and RunAndReturn have been correctly updated to use interface{} type, maintaining consistency with the main implementation.

Also applies to: 177-179

71-71: LGTM: Comment updates improve clarity

The updated comments for methods ID, Logout, and Refresh now correctly indicate "no fields" instead of "given fields", which better reflects their implementation.

Also applies to: 238-238, 341-341

316-328: LGTM: Value method implementation is consistent

The Value method's implementation correctly uses interface{} type and maintains proper type assertions in the return handling logic.

392-392: LGTM: RunAndReturn implementation improved

The change from using Return to Run in RunAndReturn methods is an improvement in the mock implementation, making it more consistent with the expected behavior.

Also applies to: 426-426

Line range hint 270-288: LGTM: Observe method properly handles database types

The Observe method's implementation correctly handles the conversion between interface{} and database-specific types while maintaining type safety.

298-299: LGTM: Consistent RunAndReturn implementation

The change to use Run instead of Return in RunAndReturn methods is consistently applied across all database operations, improving the mock's behavior.

Also applies to: 378-378, 411-411

Line range hint 27-562: LGTM: Type updates align with mockery upgrade requirements

The changes consistently replace any with interface{} across all method signatures and their corresponding helper methods. This update maintains backward compatibility while potentially improving type safety in the mock implementations.

Line range hint 24-474: LGTM: Consistent type updates for variadic methods

The changes appropriately update all variadic parameter types from any to interface{}, maintaining consistency across the printer mock implementation. The type assertions and return type handling are correctly updated to match.

Line range hint 66-562: LGTM: Consistent type updates across SQL-related methods

The changes appropriately update parameter types from any to interface{} across all SQL-related methods, maintaining consistency with the mockery upgrade requirements.

20-20: Documentation improvement noted

The comment for the Count method has been improved to explicitly state it provides a mock function with no fields, enhancing clarity.

Line range hint 1-1: Verify mockery upgrade consistency across codebase

The type changes from any to interface{} are consistently applied across all mock implementations, aligning with the mockery upgrade requirements. Let's verify there are no missed updates.

#!/bin/bash
# Description: Verify consistent type updates across all mock files
# Test: Search for any remaining instances of the 'any' type in mock files
# Expect: No occurrences of 'any' type in mock files

echo "Checking for any remaining 'any' type declarations in mock files..."
rg -t go "any" ./mocks/

echo "Checking for interface{} type declarations in mock files for verification..."
rg -t go "interface{}" ./mocks/

#!/bin/bash
# Let's modify the search pattern to properly escape curly braces
# and focus on finding both type patterns accurately

echo "Checking for 'any' type declarations..."
rg -t go '\bany\b' ./mocks/

echo "Checking for 'interface{}' type declarations..."
rg -t go 'interface\{\}' ./mocks/

27-27: LGTM: Comment updates accurately reflect method signatures

The changes to method comments from "with given fields" to "with no fields" are correct as these methods don't accept any parameters.

Also applies to: 72-72, 119-119, 166-166, 211-211, 256-256, 301-301, 346-346, 393-393, 440-440, 487-487, 534-534, 579-579, 626-626, 673-673

347-347: LGTM: Type updates align with Go best practices

The change from any to interface{} is appropriate and follows Go's type system conventions. The type assertions and conversions have been properly updated to match.

Also applies to: 354-359, 394-394, 401-406, 441-441, 448-453, 580-580, 587-592, 627-627, 634-639, 674-674, 681-686

57-57: LGTM: RunAndReturn implementation improved

The change from _c.Call.Return(run) to _c.Run(run) is a cleaner implementation that maintains the same behavior while reducing indirection.

Also applies to: 91-91, 125-125, 158-158, 253-253, 287-287, 321-321, 403-403, 437-437, 471-471, 505-505, 539-539

508-508: LGTM: Type system updates properly implemented

The changes from any to interface{} in method signatures and their corresponding helper methods are consistent and properly implemented, maintaining type safety while following Go conventions.

Also applies to: 516-516, 534-534, 539-539, 541-541, 551-551, 557-557, 565-565, 583-583, 588-588, 590-590, 600-600

Line range hint 1-1: Verify mock usage across the codebase

The Mockery upgrade changes look good. Let's verify that all mock usages in tests are compatible with these changes.

#!/bin/bash
# Description: Check for any remaining usage of 'any' type in test files
# and verify mock method calls

# Search for any remaining 'any' type usage in test files
echo "Checking for remaining 'any' type usage in tests..."
rg -t go "any" --glob "*_test.go"

# Search for mock method calls to verify compatibility
echo "Checking mock method calls..."
rg -t go "(RunAndReturn|interface{}).*testing\." --glob "*_test.go"

#!/bin/bash
# Let's check for mock method calls with a corrected regex pattern
echo "Checking mock method calls..."
rg -t go "(RunAndReturn|interface\{}).*testing\." --glob "*_test.go"

# Let's also check for mockery-generated files
echo "Checking mockery files..."
fd -t f "mock_.*\.go$"

#!/bin/bash
# Let's check for any test files that use mockery-style mocks
echo "Checking for mockery usage in tests..."
rg -t go "mock\.Mock|\.On\(|\.Return\(" --glob "*_test.go" -C 2

# Let's also check for any mock-related imports
echo "Checking mock-related imports..."
rg -t go "^import.*mock" --glob "*_test.go"

Line range hint 1-1054: Consistent type updates in logging mock implementation

The changes maintain consistency with the previous file, replacing any with interface{} across all logging-related method signatures. The modifications preserve the mock's behavior while aligning with the type system changes.

Line range hint 1-1054: Cache driver mock follows consistent type system updates

The changes align with the pattern seen in other mock files, maintaining consistency in the type system updates across the codebase.

Let's verify if there are any remaining any type usages that should be updated:

#!/bin/bash
# Search for any remaining 'any' type usages in mock files
rg -t go "any" ./mocks/

29-37: LGTM! The type system changes look correct.

The changes from any to interface{} are consistent and maintain backward compatibility. This is a good upgrade that aligns with Go's type system evolution.

Let's verify that all any type usages have been properly replaced:

Also applies to: 53-61, 71-71, 193-201, 217-224, 234-234, 286-301, 315-326, 334-339, 564-572, 589-596, 606-606, 769-784, 798-809, 817-822, 828-836, 852-860, 870-870, 876-892, 896-896, 913-920, 925-930, 936-952, 956-956, 972-979, 984-989, 1037-1045, 1062-1069, 1079-1079, 1132-1132

#!/bin/bash
# Description: Verify no remaining 'any' type usages in the codebase
# and confirm all interface{} replacements are properly implemented

# Check for any remaining 'any' type declarations
echo "Checking for remaining 'any' type usages..."
rg --type go "type.*any[^\\w]" || echo "No 'any' type declarations found"

# Verify interface{} implementations
echo "Verifying interface{} implementations..."
rg --type go "interface{}" -C 2

#!/bin/bash
# Let's fix the regex and search more precisely

# Check for any remaining 'any' type usages with better patterns
echo "Checking for remaining 'any' type usages..."
rg --type go "\bany\b"

# Verify interface{} usage with fixed pattern
echo "Verifying interface{} usage..."
rg --type go "\\binterface\\{\\}"

# Check specifically in the mocks/cache directory
echo "Checking mocks/cache directory..."
find mocks/cache -type f -name "*.go" -exec grep -l "interface{}" {} \;

#!/bin/bash
# Let's specifically check the Cache.go file and related changes
echo "Checking Cache.go file..."
rg --type go -l "interface{}" mocks/cache/Cache.go

# Check for any type declarations in Cache.go
echo "Checking type declarations in Cache.go..."
rg --type go "type.*interface{}" mocks/cache/Cache.go

# Look for method signatures in Cache.go
echo "Checking method signatures in Cache.go..."
rg --type go "func.*interface{}" mocks/cache/Cache.go

#!/bin/bash
# Let's fix the regex patterns and check Cache.go file
echo "Checking Cache.go file..."
grep -l "interface{" mocks/cache/Cache.go

# Check for method signatures with interface{} in Cache.go
echo "Checking method signatures in Cache.go..."
grep "func.*interface{" mocks/cache/Cache.go

# Get the full content of Cache.go for analysis
echo "Getting Cache.go content..."
cat mocks/cache/Cache.go

Line range hint 124-147: LGTM! Logging interface changes are consistent.

The type system updates in the logging mock implementation are thorough and maintain the expected behavior.

Also applies to: 160-161, 166-191, 204-205, 210-233, 246-247, 252-277, 290-291, 296-319, 332-333, 338-363, 376-377, 478-501, 514-515, 520-545, 558-559, 612-635, 648-649, 654-679, 692-693, 951-974, 987-988, 993-1018, 1031-1032

61-61: LGTM! RunAndReturn implementation improved.

The change from _c.Call.Return(run) to _c.Run(run) in RunAndReturn methods is a good improvement that makes the implementation more direct and efficient.

Also applies to: 95-95, 128-128, 162-162, 208-208, 241-241, 476-476, 510-510, 544-544, 626-626, 660-660, 860-860, 953-953, 987-987, 1021-1021

Line range hint 1-1290: LGTM: Standard mockery upgrade changes

The changes in this file follow the standard mockery upgrade pattern:

• Replacing any with interface{} for better type consistency
• Updating method comments for clarity
• No behavioral changes to the mock implementation

Line range hint 1-1290: LGTM: Consistent mockery upgrade changes

The changes align with the mockery upgrade pattern seen in other files:

• Standardizing type usage from any to interface{}
• Improving comment clarity
• No functional changes to the mock behavior

Line range hint 1-1236: LGTM: Standard mockery upgrade changes

The type changes align with the mockery upgrade pattern:

• Replacing any with interface{}
• Updating method comments for clarity

Line range hint 1237-1290: Verify the RunAndReturn implementation changes

Several methods have changed their RunAndReturn implementation from using Return(run) to Run(run). While this is likely intentional as part of the mockery upgrade, it's worth verifying that this change doesn't affect the mock behavior in tests.

Line range hint 165-1408: LGTM! Documentation improvements for mock methods

The changes consistently update method comments to clarify which mock functions have no fields, improving the clarity of the mock implementations.

Line range hint 65-94: LGTM! Type system improvements and implementation refinements

Changes improve type safety by:

1. Replacing any with interface{} consistently
2. Updating RunAndReturn implementations to use Run method
3. Improving method documentation

Also applies to: 98-111, 146-176, 192-222

Line range hint 131-160: LGTM! Comprehensive type system improvements

The changes successfully:

1. Replace any with interface{} across all method signatures
2. Update RunAndReturn implementations
3. Improve method documentation

Also applies to: 165-194, 674-726, 1862-1915

Line range hint 1195-1204: LGTM: Method signature updates look correct

The updates to CompileTypes and GetAttributeCommands methods properly reflect that they take no fields while maintaining the same functionality.

Also applies to: 1333-1342

Line range hint 224-264: LGTM: Type updates are consistent and maintain compatibility

The systematic replacement of any with interface{} across method signatures maintains type safety while ensuring backward compatibility. The changes are consistent across all query-related methods.

Also applies to: 384-445, 668-719, 782-822

Line range hint 1161-1204: LGTM: Blueprint mock updates maintain consistency

The updates to the Blueprint mock, particularly the Enum method signature change from []any to []interface{}, align with Go's type system while preserving the mock's behavior.