@lit-protocol/vincent-ability-sdk 0.0.1-ea

package/dist/src/type-inference-verification/allow-deny-test-cases-ability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allow-deny-test-cases-ability.d.ts","sourceRoot":"","sources":["../../../src/type-inference-verification/allow-deny-test-cases-ability.ts"],"names":[],"mappings":"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"}

package/dist/src/type-inference-verification/allow-deny-test-cases-ability.js

@@ -0,0 +1,644 @@
+"use strict";
+// src/type-inference-verification/allow-deny-test-cases-ability.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testExecuteTryCatchReturn = exports.testPrecheckAsyncWithoutAwait = exports.testExecuteConditionalReturns = exports.testPrecheckConditionalReturns = exports.testReturnWithInnerFunctions = exports.testExecuteFailWithSuccessSchema = exports.testPrecheckSuccessWithFailSchema = exports.testExecuteWrongSchema = exports.testPrecheckWrongSchema = exports.testExecuteWrongTypeReturn = exports.testExecuteRawReturn = exports.testPrecheckRawReturn = exports.testExecuteNoReturn = exports.testPrecheckNoReturn = exports.testReturnNoSchema = exports.missingSchema = exports.missingExecute = void 0;
+exports.testNoSchemas = testNoSchemas;
+exports.tesWithSchemas = tesWithSchemas;
+exports.testDifferentSchemas = testDifferentSchemas;
+exports.testPolicyResultTypes = testPolicyResultTypes;
+exports.assertAllow = assertAllow;
+exports.testExecutePolicyResultTyping = testExecutePolicyResultTyping;
+exports.testContextDestructuring = testContextDestructuring;
+/**
+ * Ability Definition Type Checking
+ *
+ * This file validates that TypeScript correctly enforces type constraints
+ * for ability definitions, focusing on success/failure responses.
+ */
+const zod_1 = require("zod");
+const helpers_1 = require("../lib/abilityCore/helpers");
+const vincentAbility_1 = require("../lib/abilityCore/vincentAbility");
+const bundledPolicy_1 = require("../lib/policyCore/bundledPolicy/bundledPolicy");
+const vincentPolicy_1 = require("../lib/policyCore/vincentPolicy");
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// Define a simple schema for our test cases
+const testSchema = zod_1.z.object({
+    action: zod_1.z.string(),
+    target: zod_1.z.string(),
+    amount: zod_1.z.number().optional(),
+});
+// Define result schemas for different test cases
+const successSchema = zod_1.z.object({
+    message: zod_1.z.string(),
+});
+const failSchema = zod_1.z.object({
+    error: zod_1.z.string(),
+    code: zod_1.z.number(),
+});
+// Create a test policy
+const baseTestPolicy = (0, vincentPolicy_1.createVincentPolicy)({
+    packageName: '@lit-protocol/test-policy@1.0.0',
+    abilityParamsSchema: zod_1.z.object({
+        actionType: zod_1.z.string(),
+    }),
+    evalAllowResultSchema: zod_1.z.object({
+        approved: zod_1.z.boolean(),
+    }),
+    evaluate: async (params, { allow }) => {
+        return allow({ approved: true });
+    },
+});
+const testPolicy = (0, vincentPolicy_1.createVincentAbilityPolicy)({
+    abilityParamsSchema: testSchema,
+    bundledVincentPolicy: (0, bundledPolicy_1.asBundledVincentPolicy)(baseTestPolicy, 'j298jhodf9024j4jfg'),
+    abilityParameterMappings: {
+        action: 'actionType',
+    },
+});
+/**
+ * Test Case 1: Basic ability with no schemas
+ * This validates the behavior when no explicit schemas are provided.
+ */
+function testNoSchemas() {
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (params, { succeed, fail }) => {
+            // Should allow succeed() with no arguments
+            succeed();
+            // @ts-expect-error Should not allow fail() with string error
+            fail('Error message');
+            // @ts-expect-error - Should not allow succeed() with arguments when no schema
+            succeed({ message: 'test' });
+            // @ts-expect-error - Should not allow fail() with object when no schema
+            fail({ error: 'test' });
+            return succeed();
+        },
+        execute: async (params, { succeed }) => {
+            // Should allow succeed() with no arguments
+            succeed();
+            // @ts-expect-error - Should not allow succeed() with arguments when no schema
+            return succeed({ data: 'test' });
+        },
+    });
+}
+/**
+ * Test Case 2: Ability with explicit success/fail schemas
+ * This validates that TypeScript enforces schema constraints.
+ */
+function tesWithSchemas() {
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability2@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeSuccessSchema: successSchema,
+        executeFailSchema: failSchema,
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        execute: async (params, { succeed, fail }) => {
+            // Should allow succeed() with valid schema
+            succeed({
+                message: 'Operation completed',
+            });
+            // Should allow fail() with valid schema
+            fail({
+                error: 'Something went wrong',
+                code: 400,
+            });
+            // @ts-expect-error - Missing required fields
+            succeed({});
+            succeed({
+                success: true,
+                // @ts-expect-error - Wrong type for message
+                message: 123,
+            });
+            succeed({
+                message: 'test',
+                // @ts-expect-error - Extra unexpected fields
+                extra: 'field',
+            });
+            fail({
+                error: 'Error message',
+                // @ts-expect-error - Wrong type for error code
+                code: '400',
+            });
+            return succeed({
+                message: 'Success',
+            });
+        },
+    });
+}
+/**
+ * Test Case 3: Ability with different precheck and execute schemas
+ * This validates that different schema types are correctly enforced.
+ */
+function testDifferentSchemas() {
+    const precheckSuccessSchema = zod_1.z.object({
+        valid: zod_1.z.boolean(),
+    });
+    const precheckFailSchema = zod_1.z.object({
+        reason: zod_1.z.string(),
+    });
+    const executeSuccessSchema = zod_1.z.object({
+        result: zod_1.z.string(),
+        timestamp: zod_1.z.number(),
+    });
+    const executeFailSchema = zod_1.z.object({
+        errorCode: zod_1.z.number(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability3@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheckSuccessSchema,
+        precheckFailSchema,
+        executeSuccessSchema,
+        executeFailSchema,
+        precheck: async (params, { succeed, fail }) => {
+            // Valid precheck schema
+            succeed({ valid: true });
+            // Valid precheck fail schema
+            fail({ reason: 'Invalid parameters' });
+            // @ts-expect-error - Using execute success schema in precheck
+            succeed({ result: 'test', timestamp: 123 });
+            // @ts-expect-error - Using execute fail schema in precheck
+            fail({ errorCode: 400 });
+            return succeed({ valid: true });
+        },
+        execute: async (params, { succeed, fail }) => {
+            // Valid execute schema
+            succeed({ result: 'success', timestamp: Date.now() });
+            // Valid execute fail schema
+            fail({ errorCode: 500 });
+            // @ts-expect-error - Using precheck success schema in execute
+            succeed({ valid: true });
+            // @ts-expect-error - Using precheck fail schema in execute
+            fail({ reason: 'Error' });
+            return succeed({ result: 'data', timestamp: Date.now() });
+        },
+    });
+}
+/**
+ * Test Case 4: Context type safety with policy results
+ * This validates that policiesContext is correctly typed.
+ */
+function testPolicyResultTypes() {
+    // First test: Precheck with properly typed policiesContext
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability4@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (params, { policiesContext, succeed }) => {
+            // Should be able to check if policy evaluation allowed
+            if (policiesContext.allow) {
+                // Should be able to access the policy result with the correct type
+                const result = policiesContext.allowedPolicies['@lit-protocol/test-policy@1.0.0'];
+                if (result) {
+                    const { approved } = result.result;
+                    console.log(approved);
+                }
+                const invalid = 
+                // @ts-expect-error - Property doesn't exist on the result type
+                policiesContext.allowedPolicies.testPolicy?.result.invalid;
+                console.log(invalid);
+            }
+            else {
+                // Should be able to access deny result when not allowed
+                const denyResult = policiesContext.deniedPolicy;
+                console.log(denyResult.packageName);
+            }
+            return succeed();
+        },
+        execute: async (params, { succeed }) => {
+            return succeed();
+        },
+    });
+}
+function assertAllow(obj) {
+    // This function just asserts that obj.allow is true
+    // It doesn't actually need to do anything at runtime
+    // TypeScript will use it for control flow analysis
+}
+// Separate test for execute-specific policy result typing
+function testExecutePolicyResultTyping() {
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability5@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        execute: async (params, { policiesContext, succeed }) => {
+            assertAllow(policiesContext);
+            // @ts-expect-error - Cannot negate a property known to be true
+            const allowIsAlwaysTrue = !policiesContext.allow;
+            // Should have access to test policy result
+            const result = policiesContext.allowedPolicies['@lit-protocol/test-policy@1.0.0'];
+            if (result) {
+                // Should be able to access properties of the result
+                const { approved } = result.result;
+                console.log(approved);
+            }
+            // @ts-expect-error - denyPolicyResult should not exist in execute
+            const denyResult = policiesContext.deniedPolicy[testPolicy];
+            console.log(denyResult);
+            return succeed();
+        },
+    });
+}
+// @ts-expect-error - Missing required execute function
+exports.missingExecute = (0, vincentAbility_1.createVincentAbility)({
+    abilityParamsSchema: testSchema,
+    supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+    precheck: async (params, { succeed }) => {
+        return succeed();
+    },
+});
+// @ts-expect-error - Missing required abilityParamsSchema
+exports.missingSchema = (0, vincentAbility_1.createVincentAbility)({
+    supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+    precheck: async (params, { succeed }) => {
+        return succeed();
+    },
+    execute: async (params, { succeed }) => {
+        return succeed();
+    },
+});
+/**
+ * Test Case 6: Testing return types are enforced
+ * Each sub-test has its own function to properly test at the function definition level.
+ */
+// Basic abilities for tests
+const testReturnNoSchema = () => {
+    // This is a good ability with proper returns
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability6@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        execute: async (params, { succeed }) => {
+            return succeed();
+        },
+    });
+};
+exports.testReturnNoSchema = testReturnNoSchema;
+// Test: Precheck with no return
+const testPrecheckNoReturn = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        // @ts-expect-error - Function doesn't return anything
+        precheck: async (params, { succeed }) => {
+            // No return statement
+        },
+        execute: async (params, { succeed }) => {
+            return succeed();
+        },
+    });
+};
+exports.testPrecheckNoReturn = testPrecheckNoReturn;
+// Test: Execute with no return
+const testExecuteNoReturn = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        // @ts-expect-error - Function doesn't return anything
+        execute: async (params, { succeed }) => {
+            // No return statement
+        },
+    });
+};
+exports.testExecuteNoReturn = testExecuteNoReturn;
+// Test: Precheck returning raw value
+const testPrecheckRawReturn = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        // @ts-expect-error - Returning raw value instead of AbilityPrecheckResponse
+        precheck: async (params, { succeed }) => {
+            return true;
+        },
+        execute: async (params, { succeed }) => {
+            return succeed();
+        },
+    });
+};
+exports.testPrecheckRawReturn = testPrecheckRawReturn;
+// Test: Execute returning raw value
+const testExecuteRawReturn = () => {
+    const executeSuccessSchema = zod_1.z.object({
+        success: zod_1.z.boolean(),
+        message: zod_1.z.string(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeSuccessSchema,
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        // @ts-expect-error - Returning raw object instead of AbilityExecutionResponse
+        execute: async (params, { succeed }) => {
+            return { success: true, message: 'test' };
+        },
+    });
+};
+exports.testExecuteRawReturn = testExecuteRawReturn;
+// Test: Execute returning wrong type object
+const testExecuteWrongTypeReturn = () => {
+    const executeSuccessSchema = zod_1.z.object({
+        success: zod_1.z.boolean(),
+        message: zod_1.z.string(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability7@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeSuccessSchema,
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        execute: async (params, { succeed }) => {
+            // This is correct
+            // return context.succeed({ success: true, message: "test" });
+            // @ts-expect-error - Wrong type of return object
+            return succeed({ wrongField: 'test' });
+        },
+    });
+};
+exports.testExecuteWrongTypeReturn = testExecuteWrongTypeReturn;
+// Test: Precheck returning wrong schema
+const testPrecheckWrongSchema = () => {
+    const precheckSuccessSchema = zod_1.z.object({
+        valid: zod_1.z.boolean(),
+    });
+    const executeSuccessSchema = zod_1.z.object({
+        result: zod_1.z.string(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability7@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheckSuccessSchema,
+        executeSuccessSchema,
+        precheck: async (params, { succeed }) => {
+            // This would be correct
+            // return context.succeed({ valid: true });
+            // @ts-expect-error - Using execute schema for precheck return
+            return succeed({ result: 'test' });
+        },
+        execute: async (params, { succeed }) => {
+            return succeed({ result: 'test' });
+        },
+    });
+};
+exports.testPrecheckWrongSchema = testPrecheckWrongSchema;
+// Test: Execute returning precheck schema
+const testExecuteWrongSchema = () => {
+    const precheckSuccessSchema = zod_1.z.object({
+        valid: zod_1.z.boolean(),
+    });
+    const executeSuccessSchema = zod_1.z.object({
+        result: zod_1.z.string(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability8@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheckSuccessSchema,
+        executeSuccessSchema,
+        precheck: async (params, { succeed }) => {
+            return succeed({ valid: true });
+        },
+        execute: async (params, { succeed }) => {
+            // This would be correct
+            // return context.succeed({ result: "test" });
+            // @ts-expect-error - Using precheck schema for execute return
+            return succeed({ valid: true });
+        },
+    });
+};
+exports.testExecuteWrongSchema = testExecuteWrongSchema;
+// Test: Precheck returning fail from success schema
+const testPrecheckSuccessWithFailSchema = () => {
+    const precheckSuccessSchema = zod_1.z.object({
+        valid: zod_1.z.boolean(),
+    });
+    const precheckFailSchema = zod_1.z.object({
+        reason: zod_1.z.string(),
+        code: zod_1.z.number(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability9@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheckSuccessSchema,
+        precheckFailSchema,
+        precheck: async (params, { succeed, fail }) => {
+            if (Math.random() > 0.5) {
+                return succeed({ valid: true });
+            }
+            else {
+                // This would be correct
+                // return context.fail({ reason: "test", code: 400 });
+                // @ts-expect-error - Using success schema for fail return
+                return fail({ valid: false });
+            }
+        },
+        execute: async (params, { succeed }) => {
+            return succeed();
+        },
+    });
+};
+exports.testPrecheckSuccessWithFailSchema = testPrecheckSuccessWithFailSchema;
+// Test: Execute returning fail with success schema
+const testExecuteFailWithSuccessSchema = () => {
+    const executeSuccessSchema = zod_1.z.object({
+        result: zod_1.z.string(),
+    });
+    const executeFailSchema = zod_1.z.object({
+        error: zod_1.z.string(),
+        code: zod_1.z.number(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability10@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeSuccessSchema,
+        executeFailSchema,
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        execute: async (params, { succeed, fail }) => {
+            if (Math.random() > 0.5) {
+                return succeed({ result: 'test' });
+            }
+            else {
+                // This would be correct
+                // return context.fail({ error: "test", code: 400 });
+                // @ts-expect-error - Using success schema for fail return
+                return fail({ result: 'error' });
+            }
+        },
+    });
+};
+exports.testExecuteFailWithSuccessSchema = testExecuteFailWithSuccessSchema;
+// Test: Ability with void-returning functions inside
+const testReturnWithInnerFunctions = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability11@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (params, { succeed }) => {
+            // Internal function that doesn't return anything shouldn't affect the overall return type
+            const logDetails = () => {
+                console.log('Details:', params);
+                // No return here is fine
+            };
+            logDetails();
+            return succeed();
+        },
+        execute: async (params, { succeed }) => {
+            // Internal async function with no return
+            const processData = async () => {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                // No return here is fine
+            };
+            await processData();
+            return succeed();
+        },
+    });
+};
+exports.testReturnWithInnerFunctions = testReturnWithInnerFunctions;
+// Test: Conditional returns in precheck
+const testPrecheckConditionalReturns = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        // @ts-expect-error - Missing return in one code path
+        precheck: async ({ abilityParams }, { succeed }) => {
+            if (abilityParams.action === 'test') {
+                return succeed();
+            }
+            // Missing return in this path
+        },
+        execute: async (params, { succeed }) => {
+            return succeed();
+        },
+    });
+};
+exports.testPrecheckConditionalReturns = testPrecheckConditionalReturns;
+// Test: Conditional returns in execute
+const testExecuteConditionalReturns = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (_, { succeed }) => {
+            return succeed();
+        },
+        // @ts-expect-error - Missing return in one code path
+        execute: async ({ abilityParams }, { succeed }) => {
+            if (abilityParams.action === 'test') {
+                return succeed();
+            }
+            // Missing return in this path
+        },
+    });
+};
+exports.testExecuteConditionalReturns = testExecuteConditionalReturns;
+// Test: Async precheck without await or return
+const testPrecheckAsyncWithoutAwait = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        // @ts-expect-error - Missing return from async function that calls other async functions
+        precheck: async (params, { succeed }) => {
+            // Call async function without await or using its result
+            await fetchData();
+            async function fetchData() {
+                return succeed();
+            }
+            // No return here
+        },
+        execute: async (params, { succeed }) => {
+            return succeed();
+        },
+    });
+};
+exports.testPrecheckAsyncWithoutAwait = testPrecheckAsyncWithoutAwait;
+// Test: Return from try-catch in execute
+const testExecuteTryCatchReturn = () => {
+    return (0, vincentAbility_1.createVincentAbility)({
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        // @ts-expect-error - Missing return in catch block
+        execute: async (params, { succeed, fail }) => {
+            try {
+                // This is fine
+                return succeed();
+            }
+            catch (error) {
+                // Missing return here
+                // @ts-expect-error Can't call fail w/ string when no schema
+                fail('Error occurred');
+            }
+        },
+    });
+};
+exports.testExecuteTryCatchReturn = testExecuteTryCatchReturn;
+/**
+ * Test Case 7: Context destructuring maintains type safety
+ */
+function testContextDestructuring() {
+    const executeSuccessSchema = zod_1.z.object({
+        data: zod_1.z.string(),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability12@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeSuccessSchema,
+        precheck: async (params, { succeed }) => {
+            // Destructuring should maintain type safety
+            // This should all work
+            succeed();
+            // @ts-expect-error - Wrong parameter type for succeed
+            succeed({ wrongField: true });
+            return succeed();
+        },
+        execute: async (params, { succeed }) => {
+            // Destructuring with type-specific functions
+            // Should be type safe
+            succeed({ data: 'result' });
+            // @ts-expect-error - Wrong field name
+            succeed({ wrongField: 'result' });
+            // @ts-expect-error - Missing required field
+            succeed({});
+            return succeed({ data: 'final result' });
+        },
+    });
+}
+//# sourceMappingURL=allow-deny-test-cases-ability.js.map