@silencelaboratories/walletprovider-sdk 4.2.1 → 4.4.0

package/dist/policy.d.ts

@@ -201,19 +201,42 @@ export interface ConditionGroup {
  * Either a single condition or a group of conditions
  */
 export type ConditionOrGroup = Condition | ConditionGroup;
-/** One external provider operation referenced by a policy rule. */
+/** One configured external-check operation referenced by a policy rule. */
 export interface ExternalCheck {
+    /** Policy-defined identifier for this external check. Must be unique across all rules in the policy. */
     check_id: string;
+    /** Integration identifier resolved by the party's integration registry. */
     integration_id: string;
+    /** Operation to execute for the referenced integration. */
     operation: string;
-    /** End-to-end provider timeout in milliseconds. */
+    /** Maximum duration allowed for this check, in milliseconds. */
     duration_ms: number;
 }
-/** Boolean group of external checks attached to one rule. */
+/** External checks combined with boolean logic for one policy rule. */
 export interface ExternalCheckGroup {
+    /** Logic applied only within this external-check group. */
     logic: Logic;
+    /** Checks in policy evaluation order. */
     checks: ExternalCheck[];
 }
+/**
+ * A half-open validity window `[from, to)` in **unix seconds**
+ *
+ * On a {@link Policy}, evaluation outside the window denies every
+ * transaction. On a {@link Rule}, the rule is skipped entirely outside its
+ * window — neither allow nor deny — so an expired `deny` rule stops denying.
+ * Absent means always in force.
+ */
+export declare class EffectiveTime {
+    /** Active from this unix second, inclusive. Absent = no lower bound. */
+    from?: number;
+    /** Active until this unix second, exclusive. Absent = no upper bound. */
+    to?: number;
+    constructor({ from, to }?: {
+        from?: number;
+        to?: number;
+    });
+}
 /**
  * A rule contains conditions that must be satisfied
  */
@@ -232,6 +255,8 @@ export declare class Rule {
     conditions: ConditionOrGroup[];
     /** Optional external predicates evaluated after the local conditions pass. */
     external_checks?: ExternalCheckGroup;
+    /** Optional validity window. Outside it this rule is skipped entirely. */
+    effective_time?: EffectiveTime;
     /**
      * Creates a new Rule instance.
      *
@@ -242,9 +267,10 @@ export declare class Rule {
      * @param action - (Optional) The action to take if the rule is matched (Allow/Deny). Defaults to Allow.
      * @param logic - (Optional) The logic operator (AND/OR) to apply to the conditions. Defaults to AND.
      * @param external_checks - (Optional) External checks evaluated when the local conditions pass.
+     * @param effective_time - (Optional) Validity window for this rule.
      * @throws Will throw an error if no conditions are provided or chain_type is missing.
      */
-    constructor({ description, chain_type, conditions, issuer, action, logic, external_checks, }: {
+    constructor({ description, chain_type, conditions, issuer, action, logic, external_checks, effective_time, }: {
         description: string;
         chain_type: ChainType;
         conditions: ConditionOrGroup[];
@@ -252,6 +278,7 @@ export declare class Rule {
         action?: Action;
         logic?: Logic;
         external_checks?: ExternalCheckGroup;
+        effective_time?: EffectiveTime;
     });
 }
 /**
@@ -264,18 +291,22 @@ export declare class Policy {
     description: string;
     /** Ordered list of rules to evaluate */
     rules: Rule[];
+    /** Optional validity window. Outside it every transaction is denied. */
+    effective_time?: EffectiveTime;
     /**
      * Creates a new Policy instance.
      *
      * @param version - The version of the policy schema. Defaults to '1.0'.
      * @param description - A human-readable description of the policy.
      * @param rules - An array of Rule objects that define the policy.
+     * @param effective_time - (Optional) Validity window for the policy.
      * @throws Will throw an error if no rules are provided.
      */
-    constructor({ version, description, rules }: {
+    constructor({ version, description, rules, effective_time, }: {
         version: string;
         description: string;
         rules: Rule[];
+        effective_time?: EffectiveTime;
     });
     toCanonicalJSON(): string;
 }
@@ -287,13 +318,16 @@ export declare namespace StateControllerAggregationMethod {
     /** Whether this aggregation can be applied to a stateful condition's transaction attribute. */
     function supportsAttribute(method: StateControllerAggregationMethod, attr: string): boolean;
 }
-export type StateControllerFixedInterval = 'day' | 'week' | 'month';
+export type StateControllerFixedInterval = 'minute' | 'hour' | 'day' | 'week' | 'month';
 export type StateControllerWindowConfig = {
     type: 'rolling';
-    seconds: number;
-} | {
-    type: 'fixed';
     interval: StateControllerFixedInterval;
+    /**
+     * Number of `interval` units in the rolling window, e.g.
+     * `{ interval: 'day', count: 3 }` is a rolling 3-day window.
+     * Must be a positive integer.
+     */
+    count: number;
 };
 export interface StateControllerPartitionField {
     transaction_type: TransactionType;

package/dist/policyIntegration.d.ts

@@ -1,20 +1,28 @@
-/** RFC 6901 JSON Pointer allowlists for a provider request. */
+/** Selects which fields may be disclosed to an external-check provider. */
 export interface PayloadProjection {
+    /** RFC 6901 JSON Pointers into the transaction; omission excludes this section. */
     transaction?: string[];
+    /** RFC 6901 JSON Pointers into the policy integration context; omission excludes this section. */
     context?: string[];
 }
-/** One operation exposed by a deployment-managed policy integration. */
+/** A policy-selectable external-check operation; an integration may expose several. */
 export interface OperationCatalogEntry {
+    /** Operation name referenced by policy rules. */
     operation: string;
+    /** Human-readable description for policy authors. */
     description: string;
+    /** Fields permitted in requests for this operation. */
     payload_projection: PayloadProjection;
 }
-/** One integration available to policy authors. */
+/** One provider integration and the operations it exposes to policy authors. */
 export interface IntegrationCatalogEntry {
+    /** Integration identifier referenced by policy rules. */
     integration_id: string;
+    /** Operations supported by this integration. */
     operations: OperationCatalogEntry[];
 }
-/** Public policy integration catalog returned by the wallet provider service. */
+/** Policy-facing integration catalog; provider endpoints are omitted. */
 export interface IntegrationCatalogResponse {
+    /** Integrations available for policy external checks. */
     integrations: IntegrationCatalogEntry[];
 }

package/dist/setupMessage.d.ts

@@ -60,7 +60,7 @@ export declare class SignSetupOpts implements EoaAuthPayload {
         key_id: string;
         message: string;
         signAlg: string;
-        policy_integration_context?: string;
+        policy_integration_context?: string | undefined;
     });
     get eoaRequestSchema(): {
         Request: {