@metamask/snaps-controllers 9.3.1 → 9.5.0

package/dist/types/cronjob/CronjobController.d.ts

@@ -1,30 +1,32 @@
-import type { RestrictedControllerMessenger } from '@metamask/base-controller';
+import type { RestrictedControllerMessenger, ControllerGetStateAction, ControllerStateChangeEvent } from '@metamask/base-controller';
 import { BaseController } from '@metamask/base-controller';
 import type { GetPermissions } from '@metamask/permission-controller';
 import type { SnapId } from '@metamask/snaps-sdk';
 import type { CronjobSpecification } from '@metamask/snaps-utils';
 import type { GetAllSnaps, HandleSnapRequest, SnapDisabled, SnapEnabled, SnapInstalled, SnapUninstalled, SnapUpdated } from '..';
 import { Timer } from '../snaps/Timer';
-export declare type CronjobControllerActions = GetAllSnaps | HandleSnapRequest | GetPermissions;
-export declare type CronjobControllerEvents = SnapInstalled | SnapUninstalled | SnapUpdated | SnapEnabled | SnapDisabled;
-export declare type CronjobControllerMessenger = RestrictedControllerMessenger<'CronjobController', CronjobControllerActions, CronjobControllerEvents, CronjobControllerActions['type'], CronjobControllerEvents['type']>;
+export type CronjobControllerGetStateAction = ControllerGetStateAction<typeof controllerName, CronjobControllerState>;
+export type CronjobControllerStateChangeEvent = ControllerStateChangeEvent<typeof controllerName, CronjobControllerState>;
+export type CronjobControllerActions = GetAllSnaps | HandleSnapRequest | GetPermissions | CronjobControllerGetStateAction;
+export type CronjobControllerEvents = SnapInstalled | SnapUninstalled | SnapUpdated | SnapEnabled | SnapDisabled | CronjobControllerStateChangeEvent;
+export type CronjobControllerMessenger = RestrictedControllerMessenger<typeof controllerName, CronjobControllerActions, CronjobControllerEvents, CronjobControllerActions['type'], CronjobControllerEvents['type']>;
 export declare const DAILY_TIMEOUT: number;
-export declare type CronjobControllerArgs = {
+export type CronjobControllerArgs = {
     messenger: CronjobControllerMessenger;
     /**
      * Persisted state that will be used for rehydration.
      */
     state?: CronjobControllerState;
 };
-export declare type Cronjob = {
+export type Cronjob = {
     timer?: Timer;
     id: string;
     snapId: SnapId;
 } & CronjobSpecification;
-export declare type StoredJobInformation = {
+export type StoredJobInformation = {
     lastRun: number;
 };
-export declare type CronjobControllerState = {
+export type CronjobControllerState = {
     jobs: Record<string, StoredJobInformation>;
 };
 declare const controllerName = "CronjobController";

package/dist/types/insights/SnapInsightsController.d.ts

@@ -1,4 +1,4 @@
-import type { RestrictedControllerMessenger } from '@metamask/base-controller';
+import type { RestrictedControllerMessenger, ControllerGetStateAction, ControllerStateChangeEvent } from '@metamask/base-controller';
 import { BaseController } from '@metamask/base-controller';
 import type { GetPermissions } from '@metamask/permission-controller';
 import type { SnapId } from '@metamask/snaps-sdk';
@@ -6,20 +6,24 @@ import type { DeleteInterface } from '../interface';
 import type { GetAllSnaps, HandleSnapRequest } from '../snaps';
 import type { TransactionControllerUnapprovedTransactionAddedEvent, SignatureStateChange, TransactionControllerTransactionStatusUpdatedEvent } from '../types';
 declare const controllerName = "SnapInsightsController";
-export declare type SnapInsightsControllerAllowedActions = HandleSnapRequest | GetAllSnaps | GetPermissions | DeleteInterface;
-export declare type SnapInsightsControllerActions = never;
-export declare type SnapInsightsControllerAllowedEvents = TransactionControllerUnapprovedTransactionAddedEvent | TransactionControllerTransactionStatusUpdatedEvent | SignatureStateChange;
-export declare type SnapInsightsControllerMessenger = RestrictedControllerMessenger<typeof controllerName, SnapInsightsControllerActions | SnapInsightsControllerAllowedActions, SnapInsightsControllerAllowedEvents, SnapInsightsControllerAllowedActions['type'], SnapInsightsControllerAllowedEvents['type']>;
-export declare type SnapInsight = {
+export type SnapInsightsControllerAllowedActions = HandleSnapRequest | GetAllSnaps | GetPermissions | DeleteInterface;
+export type SnapInsightsControllerGetStateAction = ControllerGetStateAction<typeof controllerName, SnapInsightsControllerState>;
+export type SnapInsightsControllerActions = SnapInsightsControllerGetStateAction;
+export type SnapInsightControllerStateChangeEvent = ControllerStateChangeEvent<typeof controllerName, SnapInsightsControllerState>;
+export type SnapInsightControllerEvents = SnapInsightControllerStateChangeEvent;
+export type SnapInsightsControllerAllowedEvents = TransactionControllerUnapprovedTransactionAddedEvent | TransactionControllerTransactionStatusUpdatedEvent | SignatureStateChange;
+export type SnapInsightsControllerMessenger = RestrictedControllerMessenger<typeof controllerName, SnapInsightsControllerActions | SnapInsightsControllerAllowedActions, SnapInsightControllerEvents | SnapInsightsControllerAllowedEvents, SnapInsightsControllerAllowedActions['type'], SnapInsightsControllerAllowedEvents['type']>;
+export type SnapInsight = {
     snapId: SnapId;
     interfaceId?: string | null;
     error?: string;
     loading: boolean;
+    severity?: string;
 };
-export declare type SnapInsightsControllerState = {
+export type SnapInsightsControllerState = {
     insights: Record<string, Record<SnapId, SnapInsight>>;
 };
-export declare type SnapInsightsControllerArgs = {
+export type SnapInsightsControllerArgs = {
     messenger: SnapInsightsControllerMessenger;
     state?: SnapInsightsControllerState;
 };

package/dist/types/interface/SnapInterfaceController.d.ts

@@ -1,48 +1,51 @@
 import type { AcceptRequest, HasApprovalRequest } from '@metamask/approval-controller';
-import type { RestrictedControllerMessenger } from '@metamask/base-controller';
+import type { RestrictedControllerMessenger, ControllerGetStateAction, ControllerStateChangeEvent } from '@metamask/base-controller';
 import { BaseController } from '@metamask/base-controller';
 import type { MaybeUpdateState, TestOrigin } from '@metamask/phishing-controller';
 import type { InterfaceState, SnapId, ComponentOrElement, InterfaceContext } from '@metamask/snaps-sdk';
 import type { JSXElement } from '@metamask/snaps-sdk/jsx';
 import type { Json } from '@metamask/utils';
 declare const controllerName = "SnapInterfaceController";
-export declare type CreateInterface = {
+export type CreateInterface = {
     type: `${typeof controllerName}:createInterface`;
     handler: SnapInterfaceController['createInterface'];
 };
-export declare type GetInterface = {
+export type GetInterface = {
     type: `${typeof controllerName}:getInterface`;
     handler: SnapInterfaceController['getInterface'];
 };
-export declare type UpdateInterface = {
+export type UpdateInterface = {
     type: `${typeof controllerName}:updateInterface`;
     handler: SnapInterfaceController['updateInterface'];
 };
-export declare type DeleteInterface = {
+export type DeleteInterface = {
     type: `${typeof controllerName}:deleteInterface`;
     handler: SnapInterfaceController['deleteInterface'];
 };
-export declare type UpdateInterfaceState = {
+export type UpdateInterfaceState = {
     type: `${typeof controllerName}:updateInterfaceState`;
     handler: SnapInterfaceController['updateInterfaceState'];
 };
-export declare type ResolveInterface = {
+export type ResolveInterface = {
     type: `${typeof controllerName}:resolveInterface`;
     handler: SnapInterfaceController['resolveInterface'];
 };
-export declare type SnapInterfaceControllerAllowedActions = TestOrigin | MaybeUpdateState | HasApprovalRequest | AcceptRequest;
-export declare type SnapInterfaceControllerActions = CreateInterface | GetInterface | UpdateInterface | DeleteInterface | UpdateInterfaceState | ResolveInterface;
-export declare type SnapInterfaceControllerMessenger = RestrictedControllerMessenger<typeof controllerName, SnapInterfaceControllerActions | SnapInterfaceControllerAllowedActions, never, SnapInterfaceControllerAllowedActions['type'], never>;
-export declare type StoredInterface = {
+export type SnapInterfaceControllerGetStateAction = ControllerGetStateAction<typeof controllerName, SnapInterfaceControllerState>;
+export type SnapInterfaceControllerAllowedActions = TestOrigin | MaybeUpdateState | HasApprovalRequest | AcceptRequest;
+export type SnapInterfaceControllerActions = CreateInterface | GetInterface | UpdateInterface | DeleteInterface | UpdateInterfaceState | ResolveInterface | SnapInterfaceControllerGetStateAction;
+export type SnapInterfaceControllerStateChangeEvent = ControllerStateChangeEvent<typeof controllerName, SnapInterfaceControllerState>;
+export type SnapInterfaceControllerEvents = SnapInterfaceControllerStateChangeEvent;
+export type SnapInterfaceControllerMessenger = RestrictedControllerMessenger<typeof controllerName, SnapInterfaceControllerActions | SnapInterfaceControllerAllowedActions, SnapInterfaceControllerEvents, SnapInterfaceControllerAllowedActions['type'], SnapInterfaceControllerEvents['type']>;
+export type StoredInterface = {
     snapId: SnapId;
     content: JSXElement;
     state: InterfaceState;
     context: InterfaceContext | null;
 };
-export declare type SnapInterfaceControllerState = {
+export type SnapInterfaceControllerState = {
     interfaces: Record<string, StoredInterface>;
 };
-export declare type SnapInterfaceControllerArgs = {
+export type SnapInterfaceControllerArgs = {
     messenger: SnapInterfaceControllerMessenger;
     state?: SnapInterfaceControllerState;
 };

package/dist/types/services/AbstractExecutionService.d.ts

@@ -6,8 +6,8 @@ import type { SnapRpcHookArgs } from '@metamask/snaps-utils';
 import type { Duplex } from 'readable-stream';
 import { Timer } from '../snaps/Timer';
 import type { ExecutionService, ExecutionServiceMessenger, SnapExecutionData } from './ExecutionService';
-export declare type SetupSnapProvider = (snapId: string, stream: Duplex) => void;
-export declare type ExecutionServiceArgs = {
+export type SetupSnapProvider = (snapId: string, stream: Duplex) => void;
+export type ExecutionServiceArgs = {
     setupSnapProvider: SetupSnapProvider;
     messenger: ExecutionServiceMessenger;
     initTimeout?: number;
@@ -15,18 +15,18 @@ export declare type ExecutionServiceArgs = {
     terminationTimeout?: number;
     usePing?: boolean;
 };
-export declare type JobStreams = {
+export type JobStreams = {
     command: Duplex;
     rpc: Duplex;
     _connection: BasePostMessageStream;
 };
-export declare type Job<WorkerType> = {
+export type Job<WorkerType> = {
     id: string;
     streams: JobStreams;
     rpcEngine: JsonRpcEngine;
     worker: WorkerType;
 };
-export declare type TerminateJobArgs<WorkerType> = Partial<Job<WorkerType>> & Pick<Job<WorkerType>, 'id'>;
+export type TerminateJobArgs<WorkerType> = Partial<Job<WorkerType>> & Pick<Job<WorkerType>, 'id'>;
 export declare abstract class AbstractExecutionService<WorkerType> implements ExecutionService {
     #private;
     protected jobs: Map<string, Job<WorkerType>>;

package/dist/types/services/ExecutionService.d.ts

@@ -1,68 +1,68 @@
 import type { RestrictedControllerMessenger } from '@metamask/base-controller';
 import type { SnapRpcHookArgs } from '@metamask/snaps-utils';
 import type { Json } from '@metamask/utils';
-declare type TerminateSnap = (snapId: string) => Promise<void>;
-declare type TerminateAll = () => Promise<void>;
-declare type ExecuteSnap = (snapData: SnapExecutionData) => Promise<unknown>;
-declare type HandleRpcRequest = (snapId: string, options: SnapRpcHookArgs) => Promise<unknown>;
+type TerminateSnap = (snapId: string) => Promise<void>;
+type TerminateAll = () => Promise<void>;
+type ExecuteSnap = (snapData: SnapExecutionData) => Promise<unknown>;
+type HandleRpcRequest = (snapId: string, options: SnapRpcHookArgs) => Promise<unknown>;
 export interface ExecutionService {
     terminateSnap: TerminateSnap;
     terminateAllSnaps: TerminateAll;
     executeSnap: ExecuteSnap;
     handleRpcRequest: HandleRpcRequest;
 }
-export declare type SnapExecutionData = {
+export type SnapExecutionData = {
     snapId: string;
     sourceCode: string;
     endowments: Json;
 };
-export declare type SnapErrorJson = {
+export type SnapErrorJson = {
     message: string;
     code: number;
     data?: Json;
 };
 declare const controllerName = "ExecutionService";
-export declare type ErrorMessageEvent = {
+export type ErrorMessageEvent = {
     type: 'ExecutionService:unhandledError';
     payload: [string, SnapErrorJson];
 };
-export declare type OutboundRequest = {
+export type OutboundRequest = {
     type: 'ExecutionService:outboundRequest';
     payload: [string];
 };
-export declare type OutboundResponse = {
+export type OutboundResponse = {
     type: 'ExecutionService:outboundResponse';
     payload: [string];
 };
-export declare type ExecutionServiceEvents = ErrorMessageEvent | OutboundRequest | OutboundResponse;
+export type ExecutionServiceEvents = ErrorMessageEvent | OutboundRequest | OutboundResponse;
 /**
  * Handles RPC request.
  */
-export declare type HandleRpcRequestAction = {
+export type HandleRpcRequestAction = {
     type: `${typeof controllerName}:handleRpcRequest`;
     handler: ExecutionService['handleRpcRequest'];
 };
 /**
  * Executes a given snap.
  */
-export declare type ExecuteSnapAction = {
+export type ExecuteSnapAction = {
     type: `${typeof controllerName}:executeSnap`;
     handler: ExecutionService['executeSnap'];
 };
 /**
  * Terminates a given snap.
  */
-export declare type TerminateSnapAction = {
+export type TerminateSnapAction = {
     type: `${typeof controllerName}:terminateSnap`;
     handler: ExecutionService['terminateSnap'];
 };
 /**
  * Terminates all snaps.
  */
-export declare type TerminateAllSnapsAction = {
+export type TerminateAllSnapsAction = {
     type: `${typeof controllerName}:terminateAllSnaps`;
     handler: ExecutionService['terminateAllSnaps'];
 };
-export declare type ExecutionServiceActions = HandleRpcRequestAction | ExecuteSnapAction | TerminateSnapAction | TerminateAllSnapsAction;
-export declare type ExecutionServiceMessenger = RestrictedControllerMessenger<'ExecutionService', ExecutionServiceActions, ExecutionServiceEvents, ExecutionServiceActions['type'], ExecutionServiceEvents['type']>;
+export type ExecutionServiceActions = HandleRpcRequestAction | ExecuteSnapAction | TerminateSnapAction | TerminateAllSnapsAction;
+export type ExecutionServiceMessenger = RestrictedControllerMessenger<'ExecutionService', ExecutionServiceActions, ExecutionServiceEvents, ExecutionServiceActions['type'], ExecutionServiceEvents['type']>;
 export {};

package/dist/types/services/ProxyPostMessageStream.d.ts

@@ -1,11 +1,11 @@
 import { BasePostMessageStream } from '@metamask/post-message-stream';
 import type { JsonRpcRequest } from '@metamask/utils';
-export declare type ProxyPostMessageStreamArgs = {
+export type ProxyPostMessageStreamArgs = {
     stream: BasePostMessageStream;
     jobId: string;
     extra?: Record<string, unknown>;
 };
-export declare type ProxyPostMessage = {
+export type ProxyPostMessage = {
     jobId: string;
     data: JsonRpcRequest;
     extra?: Record<string, unknown>;

package/dist/types/services/iframe/IframeExecutionService.d.ts

@@ -1,7 +1,7 @@
 import type { BasePostMessageStream } from '@metamask/post-message-stream';
 import type { ExecutionServiceArgs, TerminateJobArgs } from '../AbstractExecutionService';
 import { AbstractExecutionService } from '../AbstractExecutionService';
-declare type IframeExecutionEnvironmentServiceArgs = {
+type IframeExecutionEnvironmentServiceArgs = {
     iframeUrl: URL;
 } & ExecutionServiceArgs;
 export declare class IframeExecutionService extends AbstractExecutionService<Window> {

package/dist/types/services/offscreen/OffscreenExecutionService.d.ts

@@ -1,6 +1,6 @@
 import type { ExecutionServiceArgs } from '../AbstractExecutionService';
 import { ProxyExecutionService } from '../proxy/ProxyExecutionService';
-declare type OffscreenExecutionEnvironmentServiceArgs = {
+type OffscreenExecutionEnvironmentServiceArgs = {
     offscreenPromise: Promise<unknown>;
 } & ExecutionServiceArgs;
 export declare class OffscreenExecutionService extends ProxyExecutionService {

package/dist/types/services/proxy/ProxyExecutionService.d.ts

@@ -2,7 +2,7 @@ import type { BasePostMessageStream } from '@metamask/post-message-stream';
 import type { ExecutionServiceArgs, TerminateJobArgs } from '../AbstractExecutionService';
 import { AbstractExecutionService } from '../AbstractExecutionService';
 import { ProxyPostMessageStream } from '../ProxyPostMessageStream';
-declare type ProxyExecutionEnvironmentServiceArgs = {
+type ProxyExecutionEnvironmentServiceArgs = {
     stream: BasePostMessageStream;
 } & ExecutionServiceArgs;
 export declare class ProxyExecutionService extends AbstractExecutionService<string> {

package/dist/types/services/webview/WebViewExecutionService.d.ts

@@ -1,7 +1,7 @@
 import type { ExecutionServiceArgs } from '../AbstractExecutionService';
 import { ProxyExecutionService } from '../proxy/ProxyExecutionService';
 import type { WebViewInterface } from './WebViewMessageStream';
-export declare type WebViewExecutionServiceArgs = ExecutionServiceArgs & {
+export type WebViewExecutionServiceArgs = ExecutionServiceArgs & {
     getWebView: () => Promise<WebViewInterface>;
 };
 export declare class WebViewExecutionService extends ProxyExecutionService {

package/dist/types/services/webview/WebViewMessageStream.d.ts

@@ -1,11 +1,11 @@
 import type { PostMessageEvent } from '@metamask/post-message-stream';
 import { BasePostMessageStream } from '@metamask/post-message-stream';
-export declare type WebViewInterface = {
+export type WebViewInterface = {
     injectJavaScript(js: string): void;
     registerMessageListener(listener: (event: PostMessageEvent) => void): void;
     unregisterMessageListener(listener: (event: PostMessageEvent) => void): void;
 };
-declare type WebViewStreamArgs = {
+type WebViewStreamArgs = {
     name: string;
     target: string;
     getWebView: () => Promise<WebViewInterface>;

package/dist/types/services/webworker/WebWorkerExecutionService.d.ts

@@ -1,7 +1,7 @@
 import type { ExecutionServiceArgs, TerminateJobArgs } from '../AbstractExecutionService';
 import { AbstractExecutionService } from '../AbstractExecutionService';
 import { ProxyPostMessageStream } from '../ProxyPostMessageStream';
-declare type WebWorkerExecutionEnvironmentServiceArgs = {
+type WebWorkerExecutionEnvironmentServiceArgs = {
     documentUrl: URL;
 } & ExecutionServiceArgs;
 export declare const WORKER_POOL_ID = "snaps-worker-pool";

package/dist/types/snaps/SnapController.d.ts

@@ -1,5 +1,5 @@
 import type { AddApprovalRequest, UpdateRequestState } from '@metamask/approval-controller';
-import type { RestrictedControllerMessenger } from '@metamask/base-controller';
+import type { RestrictedControllerMessenger, ControllerGetStateAction, ControllerStateChangeEvent } from '@metamask/base-controller';
 import { BaseController } from '@metamask/base-controller';
 import type { GetEndowments, GetPermissions, GetSubjectMetadata, AddSubjectMetadata, GetSubjects, GrantPermissions, HasPermission, HasPermissions, RevokeAllPermissions, RevokePermissionForAllSubjects, RevokePermissions, UpdateCaveat } from '@metamask/permission-controller';
 import type { BlockReason } from '@metamask/snaps-registry';
@@ -21,7 +21,7 @@ export declare const controllerName = "SnapController";
 export declare const SNAP_APPROVAL_INSTALL = "wallet_installSnap";
 export declare const SNAP_APPROVAL_UPDATE = "wallet_updateSnap";
 export declare const SNAP_APPROVAL_RESULT = "wallet_installSnapResult";
-export declare type PendingRequest = {
+export type PendingRequest = {
     requestId: unknown;
     timer: Timer;
 };
@@ -36,7 +36,7 @@ export interface PreinstalledSnap {
     removable?: boolean;
     hidden?: boolean;
 }
-declare type SnapRpcHandler = (options: SnapRpcHookArgs & {
+type SnapRpcHandler = (options: SnapRpcHookArgs & {
     timeout: number;
 }) => Promise<unknown>;
 /**
@@ -90,142 +90,143 @@ export interface SnapRuntimeData {
      */
     stopping: boolean;
 }
-export declare type SnapError = {
+export type SnapError = {
     message: string;
     code: number;
     data?: Json;
 };
-declare type CloseAllConnectionsFunction = (origin: string) => void;
-declare type StoredSnaps = Record<SnapId, Snap>;
-export declare type SnapControllerState = {
+type CloseAllConnectionsFunction = (origin: string) => void;
+type StoredSnaps = Record<SnapId, Snap>;
+export type SnapControllerState = {
     snaps: StoredSnaps;
     snapStates: Record<SnapId, string | null>;
     unencryptedSnapStates: Record<SnapId, string | null>;
 };
-export declare type PersistedSnapControllerState = SnapControllerState & {
+export type PersistedSnapControllerState = SnapControllerState & {
     snaps: Record<SnapId, PersistedSnap>;
     snapStates: Record<SnapId, string>;
 };
 /**
  * Gets the specified Snap from state.
  */
-export declare type GetSnap = {
+export type GetSnap = {
     type: `${typeof controllerName}:get`;
     handler: SnapController['get'];
 };
 /**
  * Handles sending an inbound request to a snap and returns its result.
  */
-export declare type HandleSnapRequest = {
+export type HandleSnapRequest = {
     type: `${typeof controllerName}:handleRequest`;
     handler: SnapController['handleRequest'];
 };
 /**
  * Gets the specified Snap's persisted state.
  */
-export declare type GetSnapState = {
+export type GetSnapState = {
     type: `${typeof controllerName}:getSnapState`;
     handler: SnapController['getSnapState'];
 };
 /**
  * Checks if the specified snap exists in state.
  */
-export declare type HasSnap = {
+export type HasSnap = {
     type: `${typeof controllerName}:has`;
     handler: SnapController['has'];
 };
 /**
  * Updates the specified Snap's persisted state.
  */
-export declare type UpdateSnapState = {
+export type UpdateSnapState = {
     type: `${typeof controllerName}:updateSnapState`;
     handler: SnapController['updateSnapState'];
 };
 /**
  * Clears the specified Snap's persisted state.
  */
-export declare type ClearSnapState = {
+export type ClearSnapState = {
     type: `${typeof controllerName}:clearSnapState`;
     handler: SnapController['clearSnapState'];
 };
 /**
  * Checks all installed snaps against the blocklist.
  */
-export declare type UpdateBlockedSnaps = {
+export type UpdateBlockedSnaps = {
     type: `${typeof controllerName}:updateBlockedSnaps`;
     handler: SnapController['updateBlockedSnaps'];
 };
-export declare type EnableSnap = {
+export type EnableSnap = {
     type: `${typeof controllerName}:enable`;
     handler: SnapController['enableSnap'];
 };
-export declare type DisableSnap = {
+export type DisableSnap = {
     type: `${typeof controllerName}:disable`;
     handler: SnapController['disableSnap'];
 };
-export declare type RemoveSnap = {
+export type RemoveSnap = {
     type: `${typeof controllerName}:remove`;
     handler: SnapController['removeSnap'];
 };
-export declare type GetPermittedSnaps = {
+export type GetPermittedSnaps = {
     type: `${typeof controllerName}:getPermitted`;
     handler: SnapController['getPermittedSnaps'];
 };
-export declare type GetAllSnaps = {
+export type GetAllSnaps = {
     type: `${typeof controllerName}:getAll`;
     handler: SnapController['getAllSnaps'];
 };
-export declare type IncrementActiveReferences = {
+export type IncrementActiveReferences = {
     type: `${typeof controllerName}:incrementActiveReferences`;
     handler: SnapController['incrementActiveReferences'];
 };
-export declare type DecrementActiveReferences = {
+export type DecrementActiveReferences = {
     type: `${typeof controllerName}:decrementActiveReferences`;
     handler: SnapController['decrementActiveReferences'];
 };
-export declare type InstallSnaps = {
+export type InstallSnaps = {
     type: `${typeof controllerName}:install`;
     handler: SnapController['installSnaps'];
 };
-export declare type GetRegistryMetadata = {
+export type GetRegistryMetadata = {
     type: `${typeof controllerName}:getRegistryMetadata`;
     handler: SnapController['getRegistryMetadata'];
 };
-export declare type DisconnectOrigin = {
+export type DisconnectOrigin = {
     type: `${typeof controllerName}:disconnectOrigin`;
     handler: SnapController['removeSnapFromSubject'];
 };
-export declare type RevokeDynamicPermissions = {
+export type RevokeDynamicPermissions = {
     type: `${typeof controllerName}:revokeDynamicPermissions`;
     handler: SnapController['revokeDynamicSnapPermissions'];
 };
-export declare type GetSnapFile = {
+export type GetSnapFile = {
     type: `${typeof controllerName}:getFile`;
     handler: SnapController['getSnapFile'];
 };
-export declare type SnapControllerActions = ClearSnapState | GetSnap | GetSnapState | HandleSnapRequest | HasSnap | UpdateBlockedSnaps | UpdateSnapState | EnableSnap | DisableSnap | RemoveSnap | GetPermittedSnaps | InstallSnaps | GetAllSnaps | IncrementActiveReferences | DecrementActiveReferences | GetRegistryMetadata | DisconnectOrigin | RevokeDynamicPermissions | GetSnapFile;
-export declare type SnapStateChange = {
+export type SnapControllerGetStateAction = ControllerGetStateAction<typeof controllerName, SnapControllerState>;
+export type SnapControllerActions = ClearSnapState | GetSnap | GetSnapState | HandleSnapRequest | HasSnap | UpdateBlockedSnaps | UpdateSnapState | EnableSnap | DisableSnap | RemoveSnap | GetPermittedSnaps | InstallSnaps | GetAllSnaps | IncrementActiveReferences | DecrementActiveReferences | GetRegistryMetadata | DisconnectOrigin | RevokeDynamicPermissions | GetSnapFile | SnapControllerGetStateAction;
+export type SnapStateChange = {
     type: `${typeof controllerName}:stateChange`;
     payload: [SnapControllerState, Patch[]];
 };
 /**
  * Emitted when an installed snap has been blocked.
  */
-export declare type SnapBlocked = {
+export type SnapBlocked = {
     type: `${typeof controllerName}:snapBlocked`;
     payload: [snapId: string, blockedSnapInfo?: BlockReason];
 };
 /**
  * Emitted when a snap installation or update is started.
  */
-export declare type SnapInstallStarted = {
+export type SnapInstallStarted = {
     type: `${typeof controllerName}:snapInstallStarted`;
     payload: [snapId: SnapId, origin: string, isUpdate: boolean];
 };
 /**
  * Emitted when a snap installation or update failed.
  */
-export declare type SnapInstallFailed = {
+export type SnapInstallFailed = {
     type: `${typeof controllerName}:snapInstallFailed`;
     payload: [snapId: SnapId, origin: string, isUpdate: boolean, error: string];
 };
@@ -233,35 +234,35 @@ export declare type SnapInstallFailed = {
  * Emitted when a snap has been started after being added and authorized during
  * installation.
  */
-export declare type SnapInstalled = {
+export type SnapInstalled = {
     type: `${typeof controllerName}:snapInstalled`;
     payload: [snap: TruncatedSnap, origin: string];
 };
 /**
  * Emitted when a snap that has previously been fully installed, is uninstalled.
  */
-export declare type SnapUninstalled = {
+export type SnapUninstalled = {
     type: `${typeof controllerName}:snapUninstalled`;
     payload: [snap: TruncatedSnap];
 };
 /**
  * Emitted when an installed snap has been unblocked.
  */
-export declare type SnapUnblocked = {
+export type SnapUnblocked = {
     type: `${typeof controllerName}:snapUnblocked`;
     payload: [snapId: string];
 };
 /**
  * Emitted when a snap is updated.
  */
-export declare type SnapUpdated = {
+export type SnapUpdated = {
     type: `${typeof controllerName}:snapUpdated`;
     payload: [snap: TruncatedSnap, oldVersion: string, origin: string];
 };
 /**
  * Emitted when a snap is rolled back.
  */
-export declare type SnapRolledback = {
+export type SnapRolledback = {
     type: `${typeof controllerName}:snapRolledback`;
     payload: [snap: TruncatedSnap, failedVersion: string];
 };
@@ -269,7 +270,7 @@ export declare type SnapRolledback = {
  * Emitted when a Snap is terminated. This is different from the snap being
  * stopped as it can also be triggered when a snap fails initialization.
  */
-export declare type SnapTerminated = {
+export type SnapTerminated = {
     type: `${typeof controllerName}:snapTerminated`;
     payload: [snap: TruncatedSnap];
 };
@@ -277,30 +278,34 @@ export declare type SnapTerminated = {
  * Emitted when a Snap is enabled by a user.
  * This is not emitted by default when installing a snap.
  */
-export declare type SnapEnabled = {
+export type SnapEnabled = {
     type: `${typeof controllerName}:snapEnabled`;
     payload: [snap: TruncatedSnap];
 };
 /**
  * Emitted when a Snap is disabled by a user.
  */
-export declare type SnapDisabled = {
+export type SnapDisabled = {
     type: `${typeof controllerName}:snapDisabled`;
     payload: [snap: TruncatedSnap];
 };
-export declare type SnapControllerEvents = SnapBlocked | SnapInstalled | SnapUninstalled | SnapInstallStarted | SnapInstallFailed | SnapStateChange | SnapUnblocked | SnapUpdated | SnapRolledback | SnapTerminated | SnapEnabled | SnapDisabled;
-export declare type AllowedActions = GetEndowments | GetPermissions | GetSubjects | GetSubjectMetadata | AddSubjectMetadata | HasPermission | HasPermissions | RevokePermissions | RevokeAllPermissions | RevokePermissionForAllSubjects | GrantPermissions | AddApprovalRequest | HandleRpcRequestAction | ExecuteSnapAction | TerminateAllSnapsAction | TerminateSnapAction | UpdateCaveat | UpdateRequestState | GetResult | GetMetadata | Update | ResolveVersion | CreateInterface | GetInterface;
-export declare type AllowedEvents = ExecutionServiceEvents | SnapInstalled | SnapUpdated;
-declare type SnapControllerMessenger = RestrictedControllerMessenger<typeof controllerName, SnapControllerActions | AllowedActions, SnapControllerEvents | AllowedEvents, AllowedActions['type'], AllowedEvents['type']>;
-declare type FeatureFlags = {
+/**
+ * Emitted when there is a state change.
+ */
+export type SnapControllerStateChangeEvent = ControllerStateChangeEvent<typeof controllerName, SnapControllerState>;
+export type SnapControllerEvents = SnapBlocked | SnapInstalled | SnapUninstalled | SnapInstallStarted | SnapInstallFailed | SnapStateChange | SnapUnblocked | SnapUpdated | SnapRolledback | SnapTerminated | SnapEnabled | SnapDisabled | SnapControllerStateChangeEvent;
+export type AllowedActions = GetEndowments | GetPermissions | GetSubjects | GetSubjectMetadata | AddSubjectMetadata | HasPermission | HasPermissions | RevokePermissions | RevokeAllPermissions | RevokePermissionForAllSubjects | GrantPermissions | AddApprovalRequest | HandleRpcRequestAction | ExecuteSnapAction | TerminateAllSnapsAction | TerminateSnapAction | UpdateCaveat | UpdateRequestState | GetResult | GetMetadata | Update | ResolveVersion | CreateInterface | GetInterface;
+export type AllowedEvents = ExecutionServiceEvents | SnapInstalled | SnapUpdated;
+type SnapControllerMessenger = RestrictedControllerMessenger<typeof controllerName, SnapControllerActions | AllowedActions, SnapControllerEvents | AllowedEvents, AllowedActions['type'], AllowedEvents['type']>;
+type FeatureFlags = {
     requireAllowlist?: boolean;
     allowLocalSnaps?: boolean;
     disableSnapInstallation?: boolean;
 };
-declare type DynamicFeatureFlags = {
+type DynamicFeatureFlags = {
     disableSnaps?: boolean;
 };
-declare type SnapControllerArgs = {
+type SnapControllerArgs = {
     /**
      * A teardown function that allows the host to clean up its instrumentation
      * for a running snap.

package/dist/types/snaps/Timer.d.ts

@@ -1,4 +1,4 @@
-export declare type TimerStatus = 'stopped' | 'paused' | 'running' | 'finished';
+export type TimerStatus = 'stopped' | 'paused' | 'running' | 'finished';
 export declare class Timer {
     private state;
     /**