@getpara/shared 1.29.0 → 1.31.0

package/dist/esm/schemas/permissionsV2.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-export const policyAuthoringSigningWalletTypes = ['EVM'];
+import { permissionsV2UserParameterSaveSchema, permissionsV2UserParameterViewSchema, } from './permissionsV2UserParameters.js';
+export const policyAuthoringSigningWalletTypes = ['EVM', 'SOLANA', 'COSMOS', 'STELLAR', 'SUI'];
 export const policyAuthoringSigningRequestRoutes = [
     'evm.sign_transaction',
     'evm.sign_raw',
@@ -7,6 +8,10 @@ export const policyAuthoringSigningRequestRoutes = [
     'evm.sign_authorization',
     'evm.sign_message',
     'smart_account.user_operation',
+    'solana.sign_transaction',
+    'cosmos.sign_transaction',
+    'stellar.sign_transaction',
+    'sui.sign_transaction',
 ];
 export const permissionsV2SigningRequestTypes = [
     'evm_transaction',
@@ -15,8 +20,20 @@ export const permissionsV2SigningRequestTypes = [
     'evm_typed_data',
     'evm_authorization',
     'smart_account_user_operation',
+    'solana_transaction',
+    'cosmos_transaction',
+    'cosmos_message',
+    'stellar_transaction',
+    'sui_transaction',
+    'raw_message',
 ];
 const nonEmptyStringSchema = z.string().min(1);
+export const permissionsV2ParameterDeclarationSchema = z
+    .object({
+    id: nonEmptyStringSchema,
+    label: nonEmptyStringSchema,
+})
+    .strict();
 const uniqueNonEmptyStringsSchema = z
     .array(nonEmptyStringSchema)
     .min(1)
@@ -48,6 +65,7 @@ export const permissionsV2ConditionSchema = z.lazy(() => z.discriminatedUnion('k
         fact: nonEmptyStringSchema,
         op: permissionsV2CompareOperatorSchema,
         value: policyAuthoringJsonValueSchema,
+        parameter: permissionsV2ParameterDeclarationSchema.optional(),
     })
         .strict(),
     z
@@ -58,6 +76,7 @@ export const permissionsV2ConditionSchema = z.lazy(() => z.discriminatedUnion('k
         value: nonEmptyStringSchema,
         window: nonEmptyStringSchema,
         asset: nonEmptyStringSchema.optional(),
+        parameter: permissionsV2ParameterDeclarationSchema.optional(),
     })
         .strict(),
     z
@@ -79,7 +98,7 @@ export const permissionsV2ConditionSchema = z.lazy(() => z.discriminatedUnion('k
     })
         .strict(),
 ]));
-export const permissionsV2PartnerAuthoredPolicySelectorSchema = z
+const permissionsV2PartnerAuthoredPolicySelectorObjectSchema = z
     .object({
     walletId: nonEmptyStringSchema.optional(),
     chainId: z.union([nonEmptyStringSchema, uniqueNonEmptyStringsSchema]).optional(),
@@ -88,6 +107,7 @@ export const permissionsV2PartnerAuthoredPolicySelectorSchema = z
     requestType: permissionsV2SigningRequestTypeSchema.optional(),
 })
     .strict();
+export const permissionsV2PartnerAuthoredPolicySelectorSchema = permissionsV2PartnerAuthoredPolicySelectorObjectSchema;
 export const permissionsV2PolicyMetadataSchema = z
     .object({
     label: z.string().optional(),
@@ -99,19 +119,544 @@ export const permissionsV2PolicyMetadataSchema = z
 export const permissionsV2PartnerPolicyMetadataSchema = permissionsV2PolicyMetadataSchema.extend({
     productMode: permissionsV2PolicyModeSchema,
 });
+const conditionalApprovalNameSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(64)
+    .refine((value) => value === value.normalize('NFKC'), {
+    message: 'names must use normalized Unicode',
+});
+const conditionalApprovalIdentifierSchema = z.string().trim().min(1).max(64);
+const conditionalApprovalActorIdSchema = z.string().trim().min(1).max(128);
+const conditionalApprovalRequestIdSchema = z.string().trim().min(1).max(256);
+export const permissionsV2ConditionalApprovalEligibilitySchema = z.union([
+    z
+        .object({
+        kind: z.literal('role'),
+        name: conditionalApprovalNameSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal('attribute'),
+        name: conditionalApprovalNameSchema,
+        operator: z.literal('eq'),
+        value: conditionalApprovalNameSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal('attribute'),
+        name: conditionalApprovalNameSchema,
+        operator: z.literal('in'),
+        values: z
+            .array(conditionalApprovalNameSchema)
+            .min(1)
+            .refine((values) => new Set(values).size === values.length, {
+            message: 'attribute values must be unique',
+        }),
+    })
+        .strict(),
+]);
+const conditionalApprovalEligibilityListSchema = z
+    .array(permissionsV2ConditionalApprovalEligibilitySchema)
+    .min(1)
+    .max(10)
+    .refine((eligibility) => new Set(eligibility.map((clause) => JSON.stringify(clause))).size === eligibility.length, {
+    message: 'eligibility clauses must be unique',
+});
+export const permissionsV2ConditionalApprovalStageSchema = z
+    .object({
+    id: conditionalApprovalIdentifierSchema,
+    requiredApprovals: z.union([z.number().int().min(1).max(25), z.literal('all')]),
+    eligibility: conditionalApprovalEligibilityListSchema,
+    minimumAmount: z
+        .string()
+        .regex(/^(0|[1-9][0-9]*)$/)
+        .optional(),
+})
+    .strict();
+const conditionalApprovalRequiredCountKnobSchema = z
+    .object({
+    id: conditionalApprovalIdentifierSchema,
+    kind: z.literal('required_approvals'),
+    stageId: conditionalApprovalIdentifierSchema,
+    min: z.number().int().min(1).max(25),
+    max: z.number().int().min(1).max(25),
+})
+    .strict()
+    .refine((knob) => knob.min <= knob.max, { message: 'minimum required approvals must not exceed maximum' });
+const conditionalApprovalEligibleGroupOptionSchema = z
+    .object({
+    id: conditionalApprovalIdentifierSchema,
+    eligibility: conditionalApprovalEligibilityListSchema,
+})
+    .strict();
+const conditionalApprovalEligibleGroupKnobSchema = z
+    .object({
+    id: conditionalApprovalIdentifierSchema,
+    kind: z.literal('eligible_group'),
+    stageId: conditionalApprovalIdentifierSchema,
+    defaultOptionId: conditionalApprovalIdentifierSchema,
+    options: z
+        .array(conditionalApprovalEligibleGroupOptionSchema)
+        .min(1)
+        .max(25)
+        .refine((options) => new Set(options.map((option) => option.id)).size === options.length, {
+        message: 'eligible group option identifiers must be unique',
+    }),
+})
+    .strict();
+export const permissionsV2ConditionalApprovalSafeKnobSchema = z.union([
+    conditionalApprovalRequiredCountKnobSchema,
+    conditionalApprovalEligibleGroupKnobSchema,
+    z
+        .object({
+        id: conditionalApprovalIdentifierSchema,
+        kind: z.literal('minimum_amount'),
+        stageId: conditionalApprovalIdentifierSchema,
+    })
+        .strict(),
+]);
+export const permissionsV2ConditionalApprovalRequirementSchema = z
+    .object({
+    id: conditionalApprovalIdentifierSchema,
+    evidence: z.enum(['authenticated_approval', 'transaction_signature']).optional(),
+    amountFact: z.enum(['request.value.baseUnits', 'request.token.value.baseUnits']).optional(),
+    stages: z
+        .array(permissionsV2ConditionalApprovalStageSchema)
+        .min(1)
+        .max(5)
+        .refine((stages) => new Set(stages.map((stage) => stage.id)).size === stages.length, {
+        message: 'stage identifiers must be unique',
+    }),
+    configurationManagerEligibility: conditionalApprovalEligibilityListSchema.optional(),
+    safeKnobs: z
+        .array(permissionsV2ConditionalApprovalSafeKnobSchema)
+        .min(1)
+        .refine((knobs) => new Set(knobs.map((knob) => knob.id)).size === knobs.length, {
+        message: 'safe knob identifiers must be unique',
+    })
+        .optional(),
+})
+    .strict()
+    .superRefine((requirement, context) => {
+    const stagesById = new Map(requirement.stages.map((stage) => [stage.id, stage]));
+    const configuredStageIds = new Set();
+    const hasBands = requirement.stages.some((stage) => stage.minimumAmount !== undefined);
+    if (hasBands !== (requirement.amountFact !== undefined)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['amountFact'],
+            message: 'amount bands require an explicit amount fact',
+        });
+    }
+    let previousAmount = BigInt(0);
+    requirement.stages.forEach((stage, index) => {
+        if (index === 0) {
+            if (stage.minimumAmount !== undefined) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['stages', index, 'minimumAmount'],
+                    message: 'the first stage must apply to every amount',
+                });
+            }
+            return;
+        }
+        if (!hasBands)
+            return;
+        if (stage.minimumAmount === undefined ||
+            !/^(0|[1-9][0-9]*)$/.test(stage.minimumAmount) ||
+            BigInt(stage.minimumAmount) <= previousAmount) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['stages', index, 'minimumAmount'],
+                message: 'stage amount thresholds must be positive and strictly increasing',
+            });
+        }
+        else {
+            previousAmount = BigInt(stage.minimumAmount);
+        }
+    });
+    requirement.safeKnobs?.forEach((knob, index) => {
+        const stage = stagesById.get(knob.stageId);
+        if (stage === undefined) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['safeKnobs', index, 'stageId'],
+                message: 'safe knob must reference an existing stage',
+            });
+            return;
+        }
+        const settingKey = `${knob.stageId}:${knob.kind === 'minimum_amount' ? 'amount' : 'participation'}`;
+        if (configuredStageIds.has(settingKey)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['safeKnobs', index, 'stageId'],
+                message: 'a stage may expose one participation setting and one amount threshold',
+            });
+        }
+        configuredStageIds.add(settingKey);
+        if (knob.kind === 'minimum_amount') {
+            if (stage.minimumAmount === undefined) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['safeKnobs', index, 'stageId'],
+                    message: 'amount settings must reference a declared stage threshold',
+                });
+            }
+            return;
+        }
+        if (knob.kind === 'required_approvals') {
+            if (typeof stage.requiredApprovals !== 'number') {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['safeKnobs', index, 'stageId'],
+                    message: 'required count ranges apply only to numeric approval counts',
+                });
+            }
+            else if (stage.requiredApprovals < knob.min || stage.requiredApprovals > knob.max) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['safeKnobs', index],
+                    message: 'the published approval count must be within the configurable range',
+                });
+            }
+            return;
+        }
+        const defaultOption = knob.options.find((option) => option.id === knob.defaultOptionId);
+        if (defaultOption === undefined) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['safeKnobs', index, 'defaultOptionId'],
+                message: 'default group must reference a declared option',
+            });
+        }
+        else if (JSON.stringify(defaultOption.eligibility) !== JSON.stringify(stage.eligibility)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['safeKnobs', index, 'defaultOptionId'],
+                message: 'default group must match the published stage eligibility',
+            });
+        }
+    });
+});
+export const permissionsV2ConditionalApprovalCaseStatusSchema = z.enum([
+    'pending',
+    'completed',
+    'rejected',
+    'expired',
+    'invalidated',
+]);
+export const permissionsV2ConditionalApprovalDecisionUnavailableReasonSchema = z.enum([
+    'not_eligible',
+    'initiator',
+    'already_decided',
+    'case_terminal',
+    'authority_changed',
+]);
+export const permissionsV2ConditionalApprovalDecisionCapabilitySchema = z.discriminatedUnion('canDecide', [
+    z
+        .object({
+        canDecide: z.literal(true),
+        intents: z.tuple([z.literal('approve'), z.literal('reject')]),
+    })
+        .strict(),
+    z
+        .object({
+        canDecide: z.literal(false),
+        reason: permissionsV2ConditionalApprovalDecisionUnavailableReasonSchema,
+    })
+        .strict(),
+]);
+export const permissionsV2ConditionalApprovalRequirementIdentitySchema = z
+    .object({
+    requirementId: conditionalApprovalIdentifierSchema,
+    policyId: conditionalApprovalIdentifierSchema,
+    policyVersion: conditionalApprovalIdentifierSchema,
+    ruleId: conditionalApprovalIdentifierSchema,
+    stackHash: z.string().min(1),
+    authorizationScopeId: conditionalApprovalActorIdSchema,
+    configurationHash: z.string().min(1).optional(),
+})
+    .strict();
+const conditionalApprovalCaseStageViewSchema = z
+    .object({
+    id: conditionalApprovalIdentifierSchema,
+    requiredApprovals: z.number().int().min(1).max(25),
+    eligibleActorCount: z.number().int().min(1).max(100),
+    approvedActorIds: z
+        .array(conditionalApprovalActorIdSchema)
+        .refine((actorIds) => new Set(actorIds).size === actorIds.length, {
+        message: 'approved actor identifiers must be unique',
+    }),
+})
+    .strict();
+const conditionalApprovalRequestArgsSchema = z
+    .record(conditionalApprovalIdentifierSchema, z.string().min(1).max(512))
+    .refine((args) => Object.keys(args).length <= 25, {
+    message: 'request summaries may include at most twenty-five arguments',
+});
+export const permissionsV2ConditionalApprovalCaseViewSchema = z
+    .object({
+    kind: z.literal('conditional_approval'),
+    caseId: conditionalApprovalIdentifierSchema,
+    status: permissionsV2ConditionalApprovalCaseStatusSchema,
+    evidence: z.enum(['authenticated_approval', 'transaction_signature']).optional(),
+    request: z
+        .object({
+        id: conditionalApprovalRequestIdSchema,
+        requestHash: nonEmptyStringSchema,
+        walletId: nonEmptyStringSchema,
+        requestType: permissionsV2SigningRequestTypeSchema,
+        chainId: nonEmptyStringSchema.optional(),
+        classification: nonEmptyStringSchema,
+        // Signature collections expose only an encoded source; some native payloads have none.
+        from: nonEmptyStringSchema.optional(),
+        to: nonEmptyStringSchema.optional(),
+        value: z
+            .object({
+            baseUnits: z.string().regex(/^(0|[1-9][0-9]*)$/),
+            asset: nonEmptyStringSchema.optional(),
+            decimals: z.number().int().nonnegative().optional(),
+        })
+            .strict()
+            .optional(),
+        method: z.string().min(1).max(256).optional(),
+        payloadDigest: z.string().min(1).max(256).optional(),
+        args: conditionalApprovalRequestArgsSchema.optional(),
+    })
+        .strict(),
+    requirementIdentity: permissionsV2ConditionalApprovalRequirementIdentitySchema,
+    currentStageIndex: z.number().int().nonnegative(),
+    stages: z.array(conditionalApprovalCaseStageViewSchema).min(1).max(5),
+    decisions: z
+        .array(z
+        .object({
+        actorId: conditionalApprovalActorIdSchema,
+        stageId: conditionalApprovalIdentifierSchema,
+        intent: z.enum(['approve', 'reject']),
+        decidedAt: z.string().datetime(),
+    })
+        .strict())
+        .max(126),
+    expiresAt: z.string().datetime(),
+    terminalReason: z.string().min(1).optional(),
+    decision: permissionsV2ConditionalApprovalDecisionCapabilitySchema,
+})
+    .strict();
+export const permissionsV2AuthorityAssignmentSchema = z.union([
+    z
+        .object({
+        kind: z.literal('role'),
+        name: conditionalApprovalNameSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal('attribute'),
+        name: conditionalApprovalNameSchema,
+        value: conditionalApprovalNameSchema,
+    })
+        .strict(),
+]);
+const conditionalApprovalRevisionSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const conditionalApprovalChangeActorSchema = z
+    .object({
+    type: z.enum(['partner_secret', 'configuration_manager']),
+    id: conditionalApprovalActorIdSchema,
+})
+    .strict();
+export const permissionsV2AuthoritySetWriteSchema = z
+    .object({
+    expectedRevision: conditionalApprovalRevisionSchema,
+    assignments: z
+        .array(permissionsV2AuthorityAssignmentSchema)
+        .max(25)
+        .refine((assignments) => new Set(assignments.map((assignment) => JSON.stringify(assignment))).size === assignments.length, {
+        message: 'authority assignments must be unique',
+    }),
+})
+    .strict();
+export const permissionsV2AuthoritySetViewSchema = z
+    .object({
+    userId: conditionalApprovalActorIdSchema,
+    partnerId: nonEmptyStringSchema,
+    appId: nonEmptyStringSchema,
+    authorizationScopeId: conditionalApprovalActorIdSchema,
+    revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    assignments: z.array(permissionsV2AuthorityAssignmentSchema).max(25),
+    changedAt: z.string().datetime(),
+    changedBy: conditionalApprovalChangeActorSchema,
+})
+    .strict();
+export const permissionsV2AuthorizationScopeBindingWriteSchema = z
+    .object({
+    expectedRevision: conditionalApprovalRevisionSchema,
+    authorizationScopeId: conditionalApprovalActorIdSchema,
+})
+    .strict();
+export const permissionsV2AuthorizationScopeBindingViewSchema = z
+    .object({
+    walletId: nonEmptyStringSchema,
+    partnerId: nonEmptyStringSchema,
+    appId: nonEmptyStringSchema,
+    authorizationScopeId: conditionalApprovalActorIdSchema,
+    revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    changedAt: z.string().datetime(),
+    changedBy: conditionalApprovalChangeActorSchema,
+})
+    .strict();
+const conditionalApprovalConfigurationValuesSchema = z
+    .record(conditionalApprovalIdentifierSchema, z.union([z.string(), z.number().int()]))
+    .refine((values) => Object.keys(values).length <= 25, {
+    message: 'conditional approval configuration may contain at most 25 values',
+});
+export const permissionsV2AuthorizationConfigurationWriteSchema = z
+    .object({
+    expectedRevision: conditionalApprovalRevisionSchema,
+    values: conditionalApprovalConfigurationValuesSchema,
+})
+    .strict();
+export const permissionsV2AuthorizationConfigurationViewSchema = z
+    .object({
+    partnerId: nonEmptyStringSchema,
+    appId: nonEmptyStringSchema,
+    authorizationScopeId: conditionalApprovalActorIdSchema,
+    policyId: conditionalApprovalIdentifierSchema,
+    policyVersion: conditionalApprovalIdentifierSchema,
+    requirementId: conditionalApprovalIdentifierSchema,
+    revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    values: conditionalApprovalConfigurationValuesSchema,
+    configurationHash: nonEmptyStringSchema,
+    changedAt: z.string().datetime(),
+    changedBy: conditionalApprovalChangeActorSchema,
+})
+    .strict();
+export const permissionsV2ConditionalApprovalDecisionSchema = z
+    .object({
+    intent: z.enum(['approve', 'reject']),
+})
+    .strict();
+export const permissionsV2ConditionalApprovalSignatureSchema = z
+    .object({
+    walletId: z.string().min(1).max(128),
+    signature: z.string().min(1).max(512),
+})
+    .strict();
+/** Original transaction payloads for signature collection, not caller-provided policy facts. */
+export const permissionsV2TransactionSignatureCollectionSchema = z
+    .object({
+    requestId: z.string().min(1).max(128),
+    walletId: z.string().uuid(),
+    transaction: z.discriminatedUnion('format', [
+        z
+            .object({
+            format: z.literal('safe_eip712'),
+            typedDataJson: z.string().min(1).max(131072),
+            chainId: z
+                .string()
+                .regex(/^[1-9][0-9]*$/)
+                .max(78),
+        })
+            .strict(),
+        z
+            .object({
+            format: z.literal('evm_typed_data'),
+            typedDataJson: z.string().min(1).max(131072),
+            chainId: z
+                .string()
+                .regex(/^[1-9][0-9]*$/)
+                .max(78),
+        })
+            .strict(),
+        z
+            .object({
+            format: z.literal('evm_transaction'),
+            transactionBase64: z.string().min(1).max(131072),
+            chainId: z
+                .string()
+                .regex(/^[1-9][0-9]*$/)
+                .max(78),
+        })
+            .strict(),
+        z
+            .object({
+            format: z.literal('solana_transaction'),
+            transactionBase64: z.string().min(1).max(131072),
+        })
+            .strict(),
+        z
+            .object({
+            format: z.literal('cosmos_transaction'),
+            signMode: z.enum(['DIRECT', 'AMINO']),
+            signDocBase64: z.string().min(1).max(131072),
+        })
+            .strict(),
+        z
+            .object({
+            format: z.literal('stellar_xdr'),
+            transactionXdr: z.string().min(1).max(131072),
+            networkPassphrase: z.string().min(1).max(256),
+        })
+            .strict(),
+        z
+            .object({
+            format: z.literal('sui_transaction'),
+            transactionBase64: z.string().min(1).max(131072),
+        })
+            .strict(),
+    ]),
+})
+    .strict();
+export const permissionsV2ConditionalApprovalCaseListSchema = z
+    .object({
+    cases: z.array(permissionsV2ConditionalApprovalCaseViewSchema),
+})
+    .strict();
 export const permissionsV2PolicyRuleSchema = z
     .object({
     id: nonEmptyStringSchema,
     effect: permissionsV2PolicyEffectSchema,
     when: permissionsV2ConditionSchema,
+    approvalRequirement: permissionsV2ConditionalApprovalRequirementSchema.optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((rule, context) => {
+    if (rule.approvalRequirement !== undefined && rule.effect !== 'require_approval') {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['approvalRequirement'],
+            message: 'structured approval requirements are only valid for require_approval rules',
+        });
+    }
+});
+const permissionsV2PolicyRulesSchema = z
+    .array(permissionsV2PolicyRuleSchema)
+    .min(1)
+    .superRefine((rules, context) => {
+    const requirementIds = new Set();
+    rules.forEach((rule, index) => {
+        const requirementId = rule.approvalRequirement?.id;
+        if (requirementId === undefined)
+            return;
+        if (requirementIds.has(requirementId)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [index, 'approvalRequirement', 'id'],
+                message: 'approval requirement identifiers must be unique within a policy',
+            });
+        }
+        requirementIds.add(requirementId);
+    });
+});
 const partnerPolicyCandidateFields = {
     id: nonEmptyStringSchema,
     schemaVersion: z.literal('permissions.policy.v1'),
     version: nonEmptyStringSchema,
     selector: permissionsV2PartnerAuthoredPolicySelectorSchema,
-    rules: z.array(permissionsV2PolicyRuleSchema).min(1),
+    rules: permissionsV2PolicyRulesSchema,
     metadata: permissionsV2PolicyMetadataSchema.optional(),
 };
 export const permissionsV2PartnerPolicyCandidateSchema = z.object(partnerPolicyCandidateFields).strict();
@@ -120,7 +665,7 @@ export const permissionsV2PartnerAuthoredPolicyDefinitionSchema = permissionsV2P
 });
 export const permissionsV2DelegationPolicyDefinitionSchema = permissionsV2PartnerAuthoredPolicyDefinitionSchema.extend({
     layer: z.literal('partner'),
-    selector: permissionsV2PartnerAuthoredPolicySelectorSchema.extend({
+    selector: permissionsV2PartnerAuthoredPolicySelectorObjectSchema.extend({
         partnerId: nonEmptyStringSchema,
         appId: nonEmptyStringSchema,
     }),
@@ -142,6 +687,7 @@ export const permissionsV2DelegationConsentMutationSchema = z
     walletId: nonEmptyStringSchema,
     policyVersion: nonEmptyStringSchema,
     policyHash: nonEmptyStringSchema,
+    configurationHash: nonEmptyStringSchema.optional(),
     expiresAt: z.string().datetime().optional(),
 })
     .strict();
@@ -150,6 +696,23 @@ export const permissionsV2DelegationConsentStandingMutationSchema = permissionsV
     pendingTransactionId: nonEmptyStringSchema,
 })
     .strict();
+export const permissionsV2DelegationConsentNativeStandingMutationSchema = permissionsV2DelegationConsentMutationSchema
+    .extend({
+    requestId: permissionsV2TransactionSignatureCollectionSchema.shape.requestId,
+    walletId: permissionsV2TransactionSignatureCollectionSchema.shape.walletId,
+    transaction: permissionsV2TransactionSignatureCollectionSchema.shape.transaction,
+})
+    .strict();
+export const permissionsV2DelegationConsentStandingRouteMutationSchema = z.union([
+    permissionsV2DelegationConsentStandingMutationSchema,
+    permissionsV2DelegationConsentNativeStandingMutationSchema,
+]);
+/** Explicit owner consent, optionally committed together with personal settings. */
+export const permissionsV2DelegationConsentSubmissionSchema = permissionsV2DelegationConsentMutationSchema.extend({
+    posture: z.enum(['standing', 'manual_review']),
+    pendingTransactionId: nonEmptyStringSchema.optional(),
+    settings: permissionsV2UserParameterSaveSchema.pick({ expectedRevision: true, values: true }).optional(),
+});
 export const permissionsV2DelegationConsentViewSchema = z
     .object({
     status: permissionsV2DelegationConsentApiStatusSchema,
@@ -160,6 +723,7 @@ export const permissionsV2DelegationConsentViewSchema = z
     policyId: nonEmptyStringSchema,
     policyVersion: nonEmptyStringSchema,
     policyHash: nonEmptyStringSchema,
+    configurationHash: nonEmptyStringSchema.optional(),
     grantedAt: z.string().datetime().optional(),
     expiresAt: z.string().datetime().optional(),
     revokedAt: z.string().datetime().optional(),
@@ -171,6 +735,12 @@ export const permissionsV2DelegationConsentRequestSchema = z
     consent: permissionsV2DelegationConsentViewSchema,
 })
     .strict();
+export const permissionsV2DelegationConsentSubmissionResponseSchema = z
+    .object({
+    consent: permissionsV2DelegationConsentViewSchema,
+    settings: permissionsV2UserParameterViewSchema.nullable(),
+})
+    .strict();
 export const permissionsV2DelegationConsentDiscoveryResponseSchema = z
     .object({
     requests: z.array(permissionsV2DelegationConsentRequestSchema),