@metamask/snaps-sdk 1.3.2 → 2.0.0

package/dist/types/types/handlers/signature.d.ts

@@ -0,0 +1,111 @@
+import type { EnumToUnion } from '../../internals';
+import type { Component } from '../../ui';
+import type { SeverityLevel } from './transaction';
+/**
+ * An eth_sign signature object.
+ *
+ * @property from - The address the signature is being sent from.
+ * @property data - The data (hex string) that is being signed.
+ * @property signatureMethod - The signature method, which in this case is eth_sign
+ */
+export declare type EthSignature = {
+    from: string;
+    data: string;
+    signatureMethod: 'eth_sign';
+};
+/**
+ * A personal_sign signature object.
+ *
+ * @property from - The address the signature is being sent from.
+ * @property data - The data (hex string) that is being signed.
+ * @property signatureMethod - The signature method, which in this case is personal_sign
+ */
+export declare type PersonalSignature = {
+    from: string;
+    data: string;
+    signatureMethod: 'personal_sign';
+};
+/**
+ * An eth_signTypedData signature object.
+ *
+ * @property from - The address the signature is being sent from.
+ * @property data - The data that is being signed.
+ * @property signatureMethod - The signature method, which in this case is eth_signTypedData
+ */
+export declare type SignTypedDataSignature = {
+    from: string;
+    data: Record<string, any>[];
+    signatureMethod: 'eth_signTypedData';
+};
+/**
+ * An eth_signTypedData_v3 signature object.
+ *
+ * @property from - The address the signature is being sent from.
+ * @property data - The data that is being signed.
+ * @property signatureMethod - The signature method, which in this case is eth_signTypedData_v3
+ */
+export declare type SignTypedDataV3Signature = {
+    from: string;
+    data: Record<string, any>;
+    signatureMethod: 'eth_signTypedData_v3';
+};
+/**
+ * An eth_signTypedData_v4 signature object.
+ *
+ * @property from - The address the signature is being sent from.
+ * @property data - The data that is being signed.
+ * @property signatureMethod - The signature method, which in this case is eth_signTypedData_v4
+ */
+export declare type SignTypedDataV4Signature = {
+    from: string;
+    data: Record<string, any>;
+    signatureMethod: 'eth_signTypedData_v4';
+};
+/**
+ * A signature object. This can be one of the below signature methods.
+ *
+ * @see EthSignature
+ * @see PersonalSignature
+ * @see SignTypedDataSignature
+ * @see SignTypedDataV3Signature
+ * @see SignTypedDataV4Signature
+ */
+export declare type Signature = EthSignature | PersonalSignature | SignTypedDataSignature | SignTypedDataV3Signature | SignTypedDataV4Signature;
+/**
+ * The `onSignature` handler. This is called whenever a signature is
+ * submitted to the snap. It can return insights about the signature, which
+ * will be displayed to the user.
+ *
+ * Note that using this handler requires the `endowment:signature-insight`
+ * permission.
+ *
+ * @param args - The request arguments.
+ * @param args.signature - The signature object that contains the from address,
+ * data and signature method.
+ * @param args.signatureOrigin - The origin of the signature. This is the
+ * URL of the website that submitted the signature. This is only available if
+ * the Snap has enabled the `allowSignatureOrigin` option in the
+ * `endowment:signature-insight` permission.
+ * @returns An object containing insights about the signature. See
+ * {@link OnSignatureResponse}. Can also return `null` if no insights are
+ * available.
+ */
+export declare type OnSignatureHandler = (args: {
+    signature: Signature;
+    signatureOrigin?: string;
+}) => Promise<OnSignatureResponse | null>;
+/**
+ * The response from a Snap's `onSignature` handler.
+ *
+ * @property component - A custom UI component, that will be shown in MetaMask.
+ * @property id - A Snap interface ID.
+ * @property severity - The severity level of the content. Currently only one
+ * level is supported: `critical`.
+ */
+export declare type OnSignatureResponse = {
+    content: Component;
+    severity?: EnumToUnion<SeverityLevel>;
+} | {
+    id: string;
+    severity?: EnumToUnion<SeverityLevel>;
+};

package/dist/types/types/handlers/transaction.d.ts

@@ -101,10 +101,14 @@ export declare type OnTransactionHandler = (args: {
  * The response from a Snap's `onTransaction` handler.
  *
  * @property component - A custom UI component, that will be shown in MetaMask.
+ * @property id - A Snap interface ID.
  * @property severity - The severity level of the content. Currently only one
  * level is supported: `critical`.
  */
 export declare type OnTransactionResponse = {
     content: Component;
     severity?: EnumToUnion<SeverityLevel>;
+} | {
+    id: string;
+    severity?: EnumToUnion<SeverityLevel>;
 };

package/dist/types/types/handlers/user-input.d.ts

@@ -0,0 +1,64 @@
+import type { Infer } from 'superstruct';
+/**
+ * The type of user input event fired.
+ * Currently only two events are supported:
+ *
+ * - `ButtonClickEvent` - A button has been clicked in the UI.
+ * - `FormSubmitEvent` - A Form has been submitted in the UI.
+ */
+export declare enum UserInputEventType {
+    ButtonClickEvent = "ButtonClickEvent",
+    FormSubmitEvent = "FormSubmitEvent"
+}
+export declare const GenericEventStruct: import("superstruct").Struct<{
+    type: string;
+    name?: string | undefined;
+}, {
+    type: import("superstruct").Struct<string, null>;
+    name: import("superstruct").Struct<string | undefined, null>;
+}>;
+export declare const ButtonClickEventStruct: import("superstruct").Struct<{
+    type: UserInputEventType.ButtonClickEvent;
+    name?: string | undefined;
+}, {
+    type: import("superstruct").Struct<UserInputEventType.ButtonClickEvent, UserInputEventType.ButtonClickEvent>;
+    name: import("superstruct").Struct<string | undefined, null>;
+}>;
+export declare const FormSubmitEventStruct: import("superstruct").Struct<{
+    value: Record<string, string>;
+    type: UserInputEventType.FormSubmitEvent;
+    name: string;
+}, {
+    type: import("superstruct").Struct<UserInputEventType.FormSubmitEvent, UserInputEventType.FormSubmitEvent>;
+    value: import("superstruct").Struct<Record<string, string>, null>;
+    name: import("superstruct").Struct<string, null>;
+}>;
+export declare const UserInputEventStruct: import("superstruct").Struct<{
+    type: UserInputEventType.ButtonClickEvent;
+    name?: string | undefined;
+} | {
+    value: Record<string, string>;
+    type: UserInputEventType.FormSubmitEvent;
+    name: string;
+}, null>;
+/**
+ * A user input event fired in the UI. This is passed to the params of the `onUserInput` handler.
+ *
+ * @property type - The type of event fired. See {@link UserInputEventType} for the different types.
+ * @property name - The component name that fired the event. It is optional for an {@link UserInputEventType.ButtonClickEvent}.
+ * @property value - The value associated with the event. Only available when an {@link UserInputEventType.FormSubmitEvent} is fired.
+ * It contains the form values submitted.
+ */
+declare type UserInputEvent = Infer<typeof UserInputEventStruct>;
+/**
+ * The `onUserInput` handler. This is called when an user input event is fired in the UI.
+ *
+ * @param args - The user input event.
+ * @param args.id - The user interface id.
+ * @param args.event - The {@link UserInputEvent} object, containing the data about the fired event.
+ */
+export declare type OnUserInputHandler = (args: {
+    id: string;
+    event: UserInputEvent;
+}) => Promise<void>;
+export {};

package/dist/types/types/index.d.ts

@@ -5,3 +5,4 @@ export * from './methods';
 export * from './permissions';
 export * from './provider';
 export * from './snap';
+export * from './interface';

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

@@ -0,0 +1,10 @@
+import type { Infer } from 'superstruct';
+/**
+ * To avoid typing problems with the interface state when manipulating it we have to differentiate the state of
+ * a form (that will be contained inside the root state) and the root state since a key in the root stat can contain
+ * either the value of an input or a sub-state of a form.
+ */
+export declare const FormStateStruct: import("superstruct").Struct<Record<string, string | null>, null>;
+export declare const InterfaceStateStruct: import("superstruct").Struct<Record<string, string | Record<string, string | null> | null>, null>;
+export declare type FormState = Infer<typeof FormStateStruct>;
+export declare type InterfaceState = Infer<typeof InterfaceStateStruct>;

package/dist/types/types/methods/create-interface.d.ts

@@ -0,0 +1,13 @@
+import type { Component } from '../../ui';
+/**
+ * The request parameters for the `snap_createInterface` method.
+ *
+ * @property ui - The components to display in the interface.
+ */
+export declare type CreateInterfaceParams = {
+    ui: Component;
+};
+/**
+ * The result returned by the `snap_createInterface` method, which is the id of the created interface.
+ */
+export declare type CreateInterfaceResult = string;

package/dist/types/types/methods/dialog.d.ts

@@ -18,26 +18,35 @@ export declare enum DialogType {
  *
  * @property type - The type of dialog. Must be `alert`.
  * @property content - The content to display in the dialog.
+ * @property id - The Snap interface ID.
  */
 export declare type AlertDialog = {
     type: EnumToUnion<DialogType.Alert>;
     content: Component;
+} | {
+    type: EnumToUnion<DialogType.Alert>;
+    id: string;
 };
 /**
  * A confirmation dialog.
  *
  * @property type - The type of dialog. Must be `confirmation`.
  * @property content - The content to display in the dialog.
+ * @property id - The Snap interface ID.
  */
 export declare type ConfirmationDialog = {
     type: EnumToUnion<DialogType.Confirmation>;
     content: Component;
+} | {
+    type: EnumToUnion<DialogType.Confirmation>;
+    id: string;
 };
 /**
  * A prompt dialog.
  *
  * @property type - The type of dialog. Must be `prompt`.
  * @property content - The content to display in the dialog.
+ * @property id - The Snap interface ID.
  * @property placeholder - An optional placeholder text to display in the text
  * input.
  */
@@ -45,12 +54,17 @@ export declare type PromptDialog = {
     type: EnumToUnion<DialogType.Prompt>;
     content: Component;
     placeholder?: string;
+} | {
+    type: EnumToUnion<DialogType.Prompt>;
+    id: string;
+    placeholder?: string;
 };
 /**
  * The request parameters for the `snap_dialog` method.
  *
  * @property type - The type of dialog to display.
  * @property content - The content to display in the dialog.
+ * @property id - The Snap interface ID.
  * @property placeholder - The placeholder text to display in the dialog. Only
  * applicable for the `prompt` dialog.
  */

package/dist/types/types/methods/get-client-status.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The request parameters for the `snap_getClientStatus` method.
+ *
+ * This method does not accept any parameters.
+ */
+export declare type GetClientStatusParams = never;
+/**
+ * The result returned by the `snap_getClientStatus` method.
+ *
+ * It returns an object containing useful information about the client.
+ */
+export declare type GetClientStatusResult = {
+    locked: boolean;
+};

package/dist/types/types/methods/get-interface-state.d.ts

@@ -0,0 +1,13 @@
+import type { InterfaceState } from '../interface';
+/**
+ * The request parameters for the `snap_getInterfaceState` method.
+ *
+ * @property id - The interface id.
+ */
+export declare type GetInterfaceStateParams = {
+    id: string;
+};
+/**
+ * The result returned by the `snap_getInterfaceState` method, which is the state of the interface.
+ */
+export declare type GetInterfaceStateResult = InterfaceState;

package/dist/types/types/methods/index.d.ts

@@ -1,9 +1,12 @@
+export * from './create-interface';
 export * from './dialog';
 export * from './get-bip32-entropy';
 export * from './get-bip32-public-key';
 export * from './get-bip44-entropy';
+export * from './get-client-status';
 export * from './get-entropy';
 export * from './get-file';
+export * from './get-interface-state';
 export * from './get-locale';
 export * from './get-snaps';
 export * from './invoke-keyring';
@@ -13,3 +16,4 @@ export * from './manage-state';
 export * from './methods';
 export * from './notify';
 export * from './request-snaps';
+export * from './update-interface';

package/dist/types/types/methods/methods.d.ts

@@ -1,10 +1,13 @@
 import type { Method } from '../../internals';
+import type { CreateInterfaceParams, CreateInterfaceResult } from './create-interface';
 import type { DialogParams, DialogResult } from './dialog';
 import type { GetBip32EntropyParams, GetBip32EntropyResult } from './get-bip32-entropy';
 import type { GetBip32PublicKeyParams, GetBip32PublicKeyResult } from './get-bip32-public-key';
 import type { GetBip44EntropyParams, GetBip44EntropyResult } from './get-bip44-entropy';
+import type { GetClientStatusParams, GetClientStatusResult } from './get-client-status';
 import type { GetEntropyParams, GetEntropyResult } from './get-entropy';
 import type { GetFileParams, GetFileResult } from './get-file';
+import type { GetInterfaceStateParams, GetInterfaceStateResult } from './get-interface-state';
 import type { GetLocaleParams, GetLocaleResult } from './get-locale';
 import type { GetSnapsParams, GetSnapsResult } from './get-snaps';
 import type { InvokeKeyringParams, InvokeKeyringResult } from './invoke-keyring';
@@ -13,6 +16,7 @@ import type { ManageAccountsParams, ManageAccountsResult } from './manage-accoun
 import type { ManageStateParams, ManageStateResult } from './manage-state';
 import type { NotifyParams, NotifyResult } from './notify';
 import type { RequestSnapsParams, RequestSnapsResult } from './request-snaps';
+import type { UpdateInterfaceParams, UpdateInterfaceResult } from './update-interface';
 /**
  * The methods that are available to the Snap. Each method is a tuple of the
  * request parameters and the result returned by the method.
@@ -22,12 +26,16 @@ export declare type SnapMethods = {
     snap_getBip32Entropy: [GetBip32EntropyParams, GetBip32EntropyResult];
     snap_getBip32PublicKey: [GetBip32PublicKeyParams, GetBip32PublicKeyResult];
     snap_getBip44Entropy: [GetBip44EntropyParams, GetBip44EntropyResult];
+    snap_getClientStatus: [GetClientStatusParams, GetClientStatusResult];
     snap_getEntropy: [GetEntropyParams, GetEntropyResult];
     snap_getFile: [GetFileParams, GetFileResult];
     snap_getLocale: [GetLocaleParams, GetLocaleResult];
     snap_manageAccounts: [ManageAccountsParams, ManageAccountsResult];
     snap_manageState: [ManageStateParams, ManageStateResult];
     snap_notify: [NotifyParams, NotifyResult];
+    snap_createInterface: [CreateInterfaceParams, CreateInterfaceResult];
+    snap_updateInterface: [UpdateInterfaceParams, UpdateInterfaceResult];
+    snap_getInterfaceState: [GetInterfaceStateParams, GetInterfaceStateResult];
     wallet_getSnaps: [GetSnapsParams, GetSnapsResult];
     wallet_invokeKeyring: [InvokeKeyringParams, InvokeKeyringResult];
     wallet_invokeSnap: [InvokeSnapParams, InvokeSnapResult];

package/dist/types/types/methods/update-interface.d.ts

@@ -0,0 +1,15 @@
+import type { Component } from '../../ui';
+/**
+ * The request parameters for the `snap_createInterface` method.
+ *
+ * @property id - The interface id.
+ * @property ui - The components to display in the interface.
+ */
+export declare type UpdateInterfaceParams = {
+    id: string;
+    ui: Component;
+};
+/**
+ * The result returned by the `snap_updateInterface` method.
+ */
+export declare type UpdateInterfaceResult = null;

package/dist/types/types/permissions.d.ts

@@ -15,32 +15,54 @@ export declare type Bip44Entropy = {
 export declare type RequestedSnap = {
     version?: string;
 };
-export declare type InitialPermissions = {
-    'endowment:cronjob'?: {
+export declare type InitialPermissions = Partial<{
+    'endowment:cronjob': {
         jobs: Cronjob[];
+        maxRequestTime?: number;
     };
-    'endowment:keyring'?: {
+    'endowment:ethereum-provider': EmptyObject;
+    'endowment:keyring': {
         allowedOrigins?: string[];
+        maxRequestTime?: number;
     };
-    'endowment:name-lookup'?: ChainId[];
-    'endowment:network-access'?: EmptyObject;
-    'endowment:rpc'?: {
+    'endowment:lifecycle-hooks'?: {
+        maxRequestTime?: number;
+    };
+    'endowment:name-lookup': {
+        chains?: ChainId[];
+        matchers?: {
+            tlds?: string[];
+            schemes?: string[];
+        };
+        maxRequestTime?: number;
+    };
+    'endowment:network-access': EmptyObject;
+    'endowment:page-home'?: {
+        maxRequestTime?: number;
+    };
+    'endowment:rpc': {
         dapps?: boolean;
         snaps?: boolean;
         allowedOrigins?: string[];
+        maxRequestTime?: number;
     };
-    'endowment:transaction-insight'?: {
+    'endowment:signature-insight': {
+        allowSignatureOrigin?: boolean;
+        maxRequestTime?: number;
+    };
+    'endowment:transaction-insight': {
         allowTransactionOrigin?: boolean;
+        maxRequestTime?: number;
     };
-    'endowment:webassembly'?: EmptyObject;
-    snap_confirm?: EmptyObject;
-    snap_dialog?: EmptyObject;
-    snap_getBip32Entropy?: Bip32Entropy[];
-    snap_getBip32PublicKey?: Bip32Entropy[];
-    snap_getBip44Entropy?: Bip44Entropy[];
-    snap_getEntropy?: EmptyObject;
-    snap_manageAccounts?: EmptyObject;
-    snap_manageState?: EmptyObject;
-    snap_notify?: EmptyObject;
-    wallet_snap?: Record<string, RequestedSnap>;
-};
+    'endowment:webassembly': EmptyObject;
+    snap_dialog: EmptyObject;
+    snap_getBip32Entropy: Bip32Entropy[];
+    snap_getBip32PublicKey: Bip32Entropy[];
+    snap_getBip44Entropy: Bip44Entropy[];
+    snap_getEntropy: EmptyObject;
+    snap_getLocale: EmptyObject;
+    snap_manageAccounts: EmptyObject;
+    snap_manageState: EmptyObject;
+    snap_notify: EmptyObject;
+    wallet_snap: Record<string, RequestedSnap>;
+}>;

package/dist/types/ui/components/button.d.ts

@@ -0,0 +1,62 @@
+import type { Infer } from 'superstruct';
+import { NodeType } from '../nodes';
+export declare enum ButtonVariant {
+    Primary = "primary",
+    Secondary = "secondary"
+}
+export declare enum ButtonType {
+    Button = "button",
+    Submit = "submit"
+}
+export declare const ButtonStruct: import("superstruct").Struct<{
+    value: string;
+    type: NodeType.Button;
+    name?: string | undefined;
+    variant?: "primary" | "secondary" | undefined;
+    buttonType?: "button" | "submit" | undefined;
+}, {
+    type: import("superstruct").Struct<NodeType.Button, NodeType.Button>;
+    value: import("superstruct").Struct<string, null>;
+    variant: import("superstruct").Struct<"primary" | "secondary" | undefined, null>;
+    buttonType: import("superstruct").Struct<"button" | "submit" | undefined, null>;
+    name: import("superstruct").Struct<string | undefined, null>;
+}>;
+/**
+ * A button node, that renders either a primary or a secondary button.
+ *
+ * @property type - The type of the node, must be the string 'button'.
+ * @property variant - The style variant of the node, must be either 'primary' or 'secondary'.
+ * @property value - The text content of the node as plain text.
+ * @property buttonType - The type of the button, must be either 'button' or 'submit'.
+ * @property name - An optional name to identify the button.
+ */
+export declare type Button = Infer<typeof ButtonStruct>;
+/**
+ * Create a {@link Button} node.
+ *
+ * @param args - The node arguments. This can be either a string, or an object
+ * with a `value` property. A set of optional properties can be passed.
+ * @param args.variant - The optional variant of the button.
+ * @param args.value - The text content of the node.
+ * @param args.name - The optional name of the button.
+ * @returns The text node as object.
+ * @example
+ * ```typescript
+ * const node = button({  variant: 'primary', text: 'Hello, world!', name: 'myButton' });
+ * const node = button('Hello, world!', 'button', 'myButton', 'primary');
+ * const node = button('Hello, world!');
+ * ```
+ */
+export declare const button: (...args: [Omit<{
+    value: string;
+    type: NodeType.Button;
+    name?: string | undefined;
+    variant?: "primary" | "secondary" | undefined;
+    buttonType?: "button" | "submit" | undefined;
+}, "type">] | (string | undefined)[]) => {
+    value: string;
+    type: NodeType.Button;
+    name?: string | undefined;
+    variant?: "primary" | "secondary" | undefined;
+    buttonType?: "button" | "submit" | undefined;
+};

package/dist/types/ui/components/form.d.ts

@@ -0,0 +1,144 @@
+import type { Infer } from 'superstruct';
+import { NodeType } from '../nodes';
+export declare const FormComponentStruct: import("superstruct").Struct<{
+    type: NodeType.Input;
+    name: string;
+    value?: string | undefined;
+    label?: string | undefined;
+    inputType?: "number" | "text" | "password" | undefined;
+    placeholder?: string | undefined;
+} | {
+    value: string;
+    type: NodeType.Button;
+    name?: string | undefined;
+    variant?: "primary" | "secondary" | undefined;
+    buttonType?: "button" | "submit" | undefined;
+}, null>;
+/**
+ * The subset of nodes allowed as children in the {@link Form} node.
+ */
+export declare type FormComponent = Infer<typeof FormComponentStruct>;
+export declare const FormStruct: import("superstruct").Struct<{
+    type: NodeType.Form;
+    name: string;
+    children: ({
+        type: NodeType.Input;
+        name: string;
+        value?: string | undefined;
+        label?: string | undefined;
+        inputType?: "number" | "text" | "password" | undefined;
+        placeholder?: string | undefined;
+    } | {
+        value: string;
+        type: NodeType.Button;
+        name?: string | undefined;
+        variant?: "primary" | "secondary" | undefined;
+        buttonType?: "button" | "submit" | undefined;
+    })[];
+}, {
+    type: import("superstruct").Struct<NodeType.Form, NodeType.Form>;
+    children: import("superstruct").Struct<({
+        type: NodeType.Input;
+        name: string;
+        value?: string | undefined;
+        label?: string | undefined;
+        inputType?: "number" | "text" | "password" | undefined;
+        placeholder?: string | undefined;
+    } | {
+        value: string;
+        type: NodeType.Button;
+        name?: string | undefined;
+        variant?: "primary" | "secondary" | undefined;
+        buttonType?: "button" | "submit" | undefined;
+    })[], import("superstruct").Struct<{
+        type: NodeType.Input;
+        name: string;
+        value?: string | undefined;
+        label?: string | undefined;
+        inputType?: "number" | "text" | "password" | undefined;
+        placeholder?: string | undefined;
+    } | {
+        value: string;
+        type: NodeType.Button;
+        name?: string | undefined;
+        variant?: "primary" | "secondary" | undefined;
+        buttonType?: "button" | "submit" | undefined;
+    }, null>>;
+    name: import("superstruct").Struct<string, null>;
+}>;
+/**
+ * A form node that takes children {@link FormComponent} nodes and renders a form.
+ *
+ * @property type - The type of the node. Must be the string `form`.
+ * @property children - The children of the node. Only {@link FormComponent} nodes are allowed.
+ * @property name - The form name used to identify it.
+ */
+export declare type Form = Infer<typeof FormStruct>;
+/**
+ * Create a {@link Form} node.
+ *
+ * @param args - The node arguments. This can be either an array of children and a string, or
+ * an object with a `name` and `children` property.
+ * @param args.name - The form name used to identify it.
+ * @param args.children - The child nodes of the form. This can be any valid
+ * {@link FormComponent}.
+ * @returns The form node as object.
+ * @example
+ * const node = form({
+ *  name: 'myForm',
+ *  children: [
+ *    input({ name: 'myInput' }),
+ *    button({ value: 'Hello, world!' }),
+ *  ],
+ * });
+ *
+ * const node = form('myForm', [input('myInput'), button('Hello, world!')]);
+ */
+export declare const form: (...args: [Omit<{
+    type: NodeType.Form;
+    name: string;
+    children: ({
+        type: NodeType.Input;
+        name: string;
+        value?: string | undefined;
+        label?: string | undefined;
+        inputType?: "number" | "text" | "password" | undefined;
+        placeholder?: string | undefined;
+    } | {
+        value: string;
+        type: NodeType.Button;
+        name?: string | undefined;
+        variant?: "primary" | "secondary" | undefined;
+        buttonType?: "button" | "submit" | undefined;
+    })[];
+}, "type">] | (string | ({
+    type: NodeType.Input;
+    name: string;
+    value?: string | undefined;
+    label?: string | undefined;
+    inputType?: "number" | "text" | "password" | undefined;
+    placeholder?: string | undefined;
+} | {
+    value: string;
+    type: NodeType.Button;
+    name?: string | undefined;
+    variant?: "primary" | "secondary" | undefined;
+    buttonType?: "button" | "submit" | undefined;
+})[])[]) => {
+    type: NodeType.Form;
+    name: string;
+    children: ({
+        type: NodeType.Input;
+        name: string;
+        value?: string | undefined;
+        label?: string | undefined;
+        inputType?: "number" | "text" | "password" | undefined;
+        placeholder?: string | undefined;
+    } | {
+        value: string;
+        type: NodeType.Button;
+        name?: string | undefined;
+        variant?: "primary" | "secondary" | undefined;
+        buttonType?: "button" | "submit" | undefined;
+    })[];
+};

package/dist/types/ui/components/index.d.ts

@@ -9,3 +9,6 @@ export { ComponentStruct, panel, PanelStruct } from './panel';
 export * from './spinner';
 export * from './text';
 export * from './row';
+export * from './button';
+export * from './input';
+export * from './form';