@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/types/ESPRMNeoService.d.ts

@@ -0,0 +1,24 @@
+import type { ESPRMNeoNode } from "./ESPRMNeoNode";
+import { ESPRMNeoServiceParam } from "./ESPRMNeoServiceParam";
+import type { ESPRMNeoServiceInterface } from "./types/node";
+/**
+ * Node-level service (not tied to a single device), e.g. time, local control.
+ * Holds a WeakRef to the parent node for delegating getParams/setParams.
+ */
+export declare class ESPRMNeoService implements ESPRMNeoServiceInterface {
+    readonly name: string;
+    readonly type: string;
+    readonly params: ESPRMNeoServiceParam[];
+    readonly _nodeRef: WeakRef<ESPRMNeoNode>;
+    constructor(data: Omit<ESPRMNeoServiceInterface, "params"> & {
+        params?: Array<{
+            id: string;
+            type?: string;
+            properties?: string[];
+            dataType: string;
+            serviceName?: string;
+            bounds?: Record<string, unknown>;
+            validStrings?: string[];
+        }>;
+    }, nodeRef: WeakRef<ESPRMNeoNode>);
+}

package/dist/types/ESPRMNeoServiceParam.d.ts

@@ -0,0 +1,23 @@
+import type { ESPRMNeoNode } from "./ESPRMNeoNode";
+import type { ESPAPIResponse } from "./types/output";
+import type { ESPRMNeoServiceParamInterface, ESPRMNeoParamInterface } from "./types/node";
+/**
+ * Service parameter – one parameter of a node service (e.g. timezone).
+ * Holds a WeakRef to the parent node so writes can be dispatched via the best
+ * available transport (see {@link delegatedTransportHandler}).
+ */
+export declare class ESPRMNeoServiceParam implements ESPRMNeoServiceParamInterface {
+    readonly id: string;
+    readonly type: string;
+    readonly properties: string[];
+    readonly dataType: string;
+    readonly serviceName: string;
+    readonly bounds?: Record<string, unknown>;
+    readonly validStrings?: string[];
+    value?: any;
+    readonly _nodeRef: WeakRef<ESPRMNeoNode>;
+    constructor(data: ESPRMNeoParamInterface & {
+        serviceName: string;
+    }, nodeRef: WeakRef<ESPRMNeoNode>);
+    setValue(value: any): Promise<ESPAPIResponse>;
+}

package/dist/types/ESPRMNeoSharingRequest.d.ts

@@ -0,0 +1,16 @@
+import { SharingRequestAccessType, SharingRequestInfo } from "./types/output";
+/**
+ * Represents a sharing request in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for sharing request operations.
+ */
+export declare class ESPRMNeoSharingRequest {
+    sharingRequestId: string;
+    groupId: string;
+    subgroupId: string;
+    accessType: SharingRequestAccessType;
+    /** Primary user information who sent the share invitation. */
+    primaryUserId: string;
+    primaryEmail: string;
+    primaryPhoneNumber: string;
+    constructor(data: SharingRequestInfo);
+}

package/dist/types/ESPRMNeoTrigger.d.ts

@@ -0,0 +1,26 @@
+import { TriggerItem, TriggerOperator } from "./types/trigger";
+import { ESPRMNeoNode } from "./ESPRMNeoNode";
+/**
+ * Represents a trigger in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for trigger operations.
+ * Holds a WeakRef to the parent node, matching the pattern used by
+ * ESPRMNeoDevice / ESPRMNeoService / ESPRMNeoDeviceParam.
+ */
+export declare class ESPRMNeoTrigger {
+    id: string;
+    nodeId: string;
+    groupId: string;
+    type: string;
+    enabled?: boolean;
+    path: string;
+    operator: TriggerOperator;
+    value: unknown;
+    readonly _nodeRef: WeakRef<ESPRMNeoNode>;
+    constructor(data: TriggerItem, node: ESPRMNeoNode);
+    /** Parent node, if the weak reference is still alive. */
+    getNode(): ESPRMNeoNode | undefined;
+    /**
+     * Converts this trigger to a plain TriggerItem (for building API payloads).
+     */
+    toTriggerItem(): TriggerItem;
+}

package/dist/types/ESPRMNeoUser.d.ts

@@ -0,0 +1,47 @@
+import { UserTokensData } from "./types/input";
+import type { EventCallbacks } from "./types/discovery";
+/**
+ * Represents an authenticated user in the ESP Rainmaker Neo system.
+ * Provides methods for user operations, device management, group management,
+ * and MQTT-based real-time communication.
+ *
+ */
+export declare class ESPRMNeoUser {
+    /** Registered event subscriber callbacks, keyed by event (see {@link subscribe}). */
+    eventCallbacks: EventCallbacks;
+    /**
+     * Per-event teardown handles for backing sources started by {@link subscribe}
+     * (LAN discovery, node-updates bus, custom discovery). Kept so
+     * {@link unsubscribe} / {@link removeAllCallbacks} can stop them.
+     */
+    eventTeardowns: Record<string, {
+        stop(): void;
+    }>;
+    /**
+     * Initializes the ESPRMNeoUser instance and persists the tokens to storage.
+     *
+     * @param tokens - Object containing the access token, id token, and refresh token.
+     */
+    constructor(tokens: UserTokensData);
+    /** Reads a token from storage, throwing when the user is not logged in. */
+    private static requireToken;
+    /**
+     * Returns the current Cognito access token from storage.
+     * @throws {ESPTokenError} When no access token is stored (not logged in).
+     */
+    getAccessToken(): Promise<string>;
+    /**
+     * Returns the current Cognito ID token from storage.
+     * @throws {ESPTokenError} When no ID token is stored (not logged in).
+     */
+    getIdToken(): Promise<string>;
+    /**
+     * Returns the current Cognito refresh token from storage.
+     * @throws {ESPTokenError} When no refresh token is stored (not logged in).
+     */
+    getRefreshToken(): Promise<string>;
+    /**
+     * Extends the current session using a refresh token.
+     */
+    static extendSession(refreshToken: string): Promise<void>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ESP Rainmaker Neo Base SDK
+ *
+ * Public entry point. Re-exports core classes (ESPRMNeoBase, ESPRMNeoAuth, ESPRMNeoUser,
+ * ESPRMNeoGroup, ESPRMNeoNode, ESPDevice, etc.), types, utils, and MQTT adapter interfaces.
+ */
+export { ESPRMNeoBase } from "./ESPRMNeoBase";
+export { ESPRMNeoAuth } from "./ESPRMNeoAuth";
+export { ESPRMNeoUser } from "./ESPRMNeoUser";
+export { ESPRMNeoGroup } from "./ESPRMNeoGroup";
+export { ESPRMNeoNode } from "./ESPRMNeoNode";
+export { ESPRMNeoDevice } from "./ESPRMNeoDevice";
+export { ESPRMNeoDeviceParam } from "./ESPRMNeoDeviceParam";
+export { ESPRMNeoService } from "./ESPRMNeoService";
+export { ESPRMNeoServiceParam } from "./ESPRMNeoServiceParam";
+export { ESPRMNeoSchedule } from "./ESPRMNeoSchedule";
+export { ESPRMNeoSharingRequest } from "./ESPRMNeoSharingRequest";
+export { ESPRMNeoTrigger } from "./ESPRMNeoTrigger";
+export { ESPRMNeoAutomation } from "./ESPRMNeoAutomation";
+export { ESPDevice } from "./ESPDevice";
+export * from "./types/export";
+export * from "./utils/export";
+export * from "./services/export";

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

@@ -0,0 +1,15 @@
+/**
+ * Augments the ESPDevice class with the `connect` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Connects to the ESP device using the configured provisioning adapter.
+         *
+         * @returns A promise that resolves to a connection status code (0 for success).
+         * @throws {Error} If the device cannot be connected or the adapter is not configured.
+         */
+        connect(): Promise<number>;
+    }
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { ESPAPIResponse } from "../../types/output";
+/**
+ * Augments the ESPDevice class with the `disconnect` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Disconnects from the ESP device.
+         *
+         * @returns A promise that resolves with the API response when disconnection is complete.
+         * @throws {Error} If disconnection fails or the adapter is not configured.
+         */
+        disconnect(): Promise<ESPAPIResponse>;
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Augments the ESPDevice class with the `getDeviceCapabilities` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Retrieves the capabilities of the device.
+         *
+         * @returns A promise that resolves to an array of capability strings.
+         * @throws {Error} If the capabilities cannot be retrieved or the adapter is not configured.
+         */
+        getDeviceCapabilities(): Promise<string[]>;
+    }
+}
+export {};

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

@@ -0,0 +1,17 @@
+/**
+ * Augments the ESPDevice class with the `getDeviceVersion` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Retrieves version information from the device.
+         *
+         * @returns A promise that resolves to an object containing device version information.
+         * @throws {Error} If the version cannot be retrieved or the adapter is not configured.
+         */
+        getDeviceVersion(): Promise<{
+            [key: string]: any;
+        }>;
+    }
+}
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * Augments the ESPDevice class with the `initializeSession` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Initializes a provisioning session with the device.
+         *
+         * @returns A promise that resolves to `true` if session initialization was successful.
+         * @throws {Error} If session initialization fails or the adapter is not configured.
+         */
+        initializeSession(): Promise<boolean>;
+    }
+}
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * Augments the ESPDevice class with the `initiateUserNodeMapping` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Initiates a user node mapping request.
+         * @param requestBody - The request body for the user node mapping.
+         * @returns A promise that resolves to the response from the API.
+         */
+        initiateUserNodeMapping(groupId: string, requestBody?: Record<string, unknown>): Promise<unknown>;
+    }
+}
+export {};

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

@@ -0,0 +1,28 @@
+import { ESPRMNeoUser } from "../../ESPRMNeoUser";
+import { ESPProvResponse } from "../../types/provision";
+/** Optional step-6 settings for {@link ESPDevice.provision}. */
+export interface ProvisionOptions {
+    user?: ESPRMNeoUser;
+    waitForOnline?: boolean;
+    onlineTimeoutMs?: number;
+}
+/**
+ * Augments the ESPDevice class with the `provision` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Provisions the device with WiFi credentials using challenge-response flow.
+         *
+         * @param ssid - The WiFi network SSID.
+         * @param passphrase - The WiFi network password.
+         * @param onProgress - A callback function to report progress.
+         * @param groupId - The group ID for node association.
+         * @param provisionType - The provisioning flow type. Default: ProvisionType.CHAL_RESP.
+         * @param options - Optional step 6 (online wait via MQTT).
+         * @returns A promise that resolves with the node ID when provisioning is complete.
+         * @throws {Error} If provisioning fails at any stage.
+         */
+        provision(ssid: string, passphrase: string, onProgress: (message: ESPProvResponse) => void, groupId: string, provisionType?: string, options?: ProvisionOptions): Promise<string>;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { ESPWifiList } from "../../types/provision";
+/**
+ * Augments the ESPDevice class with the `scanWifiList` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Scans for available WiFi networks using the device's provisioning adapter.
+         *
+         * @returns A promise that resolves to an array of available WiFi networks.
+         * @throws {Error} If the scan fails or the adapter is not configured.
+         */
+        scanWifiList(): Promise<ESPWifiList[]>;
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Augments the ESPDevice class with the `sendData` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Sends data to the device at a specific endpoint.
+         *
+         * @param endPoint - The endpoint to send data to.
+         * @param data - The data string to send.
+         * @returns A promise that resolves to the response string from the device.
+         * @throws {Error} If sending data fails or the adapter is not configured.
+         */
+        sendData(endPoint: string, data: string): Promise<string>;
+    }
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { ESPProvisionStatus } from "../../types/provision";
+/**
+ * Augments the ESPDevice class with the `setNetworkCredentials` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Sets the network credentials for the device.
+         * @param ssid - The SSID of the Wi-Fi network.
+         * @param passphrase - The passphrase of the Wi-Fi network.
+         * @returns A promise that resolves to the provisioning status.
+         */
+        setNetworkCredentials(ssid: string, passphrase: string): Promise<ESPProvisionStatus>;
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Augments the ESPDevice class with the `setProofOfPossession` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Sets the proof of possession (PoP) for the device during provisioning.
+         *
+         * @param proofOfPossession - The proof of possession string.
+         * @returns A promise that resolves to `true` if PoP was set successfully.
+         * @throws {Error} If setting PoP fails or the adapter is not configured.
+         */
+        setProofOfPossession(proofOfPossession: string): Promise<boolean>;
+    }
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { ESPClaimProgressCallback } from "../../types/provision";
+import { ClaimCapabilities } from "../../utils/constants";
+/**
+ * Augments the ESPDevice class with the `startAssistedClaiming` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Starts the assisted claiming process.
+         *
+         * Flow:
+         * 1. Send ClaimStart to device, which returns its device info
+         * 2. Reserve a node ID for the device MAC (`POST /v1/claim/initiate`)
+         * 3. Send ClaimInit with the cloud response to device
+         * 4. Read the chunked CSR from device
+         * 5. Exchange the CSR for a certificate (`POST /v1/claim/verify`)
+         * 6. Stream the certificate response back to device
+         *
+         * @param onProgress - Callback for progress updates
+         * @param claimCapability - Optional capability, e.g. `ClaimCapabilities.CAMERA_CLAIM`
+         * @returns Promise that resolves when claiming is complete
+         * @throws ESPClaimError if claiming fails at any step
+         */
+        startAssistedClaiming(onProgress?: ESPClaimProgressCallback, claimCapability?: ClaimCapabilities): Promise<void>;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { ESPAPIResponse } from "../../types/output";
+/**
+ * Augments the ESPDevice class with the `verifyUserNodeMapping` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Verifies the mapping between a user and a node.
+         * @param groupId - The ID of the group.
+         * @param requestId - The node association request ID.
+         * @param requestBody - The request body for the user node mapping verification.
+         * @returns A promise that resolves to the response from the API.
+         */
+        verifyUserNodeMapping(groupId: string, requestId: string, requestBody?: Record<string, unknown>): Promise<ESPAPIResponse>;
+    }
+}

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

@@ -0,0 +1,13 @@
+import "./Connect";
+import "./Disconnect";
+import "./GetDeviceCapabilities";
+import "./GetDeviceVersion";
+import "./ScanWifiList";
+import "./Provision";
+import "./SetProofOfPossession";
+import "./SendData";
+import "./InitializeSession";
+import "./SetNetworkCredentials";
+import "./InitiateUserNodeMapping";
+import "./VerifyUserNodeMapping";
+import "./StartAssistedClaiming";

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

@@ -0,0 +1,19 @@
+import { ChangePasswordResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAuth class with the `changePassword` method.
+ */
+declare module "../../ESPRMNeoAuth" {
+    interface ESPRMNeoAuth {
+        /**
+         * Changes the password for the currently authenticated user.
+         *
+         * Calls `POST /v1/user/auth/password` (CognitoAuthorizer Bearer token).
+         *
+         * @param oldPassword - The user's current password.
+         * @param newPassword - The new password to set.
+         * @returns A promise that resolves to a ChangePasswordResponse on success.
+         * @throws {ESPAuthError} If not logged in or the API request fails.
+         */
+        changePassword(oldPassword: string, newPassword: string): Promise<ChangePasswordResponse>;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ConfirmSignUpResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAuth class with the `confirmSignUp` method.
+ */
+declare module "../../ESPRMNeoAuth" {
+    interface ESPRMNeoAuth {
+        /**
+         * Confirms a user's sign-up using the verification code sent by Cognito.
+         *
+         * Calls `POST /v1/user/auth/signup/verify`.
+         *
+         * @param username - The username (typically the user's email or phone).
+         * @param verificationCode - The verification code received by the user.
+         * @returns The API response.
+         * @throws {ESPAuthError} If confirmation fails.
+         */
+        confirmSignUp(username: string, verificationCode: string): Promise<ConfirmSignUpResponse>;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ForgotPasswordResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAuth class with the `forgotPassword` method.
+ */
+declare module "../../ESPRMNeoAuth" {
+    interface ESPRMNeoAuth {
+        /**
+         * Initiates the password recovery process for a user.
+         *
+         * Calls `POST /v1/user/auth/password-recovery`.
+         *
+         * @param username - The username (email or phone number) for password recovery.
+         * @returns The server response with an optional `message` field — the only
+         *   field the backend returns (verified against the backend source).
+         * @throws {ESPAuthError} If recovery initiation fails.
+         */
+        forgotPassword(username: string): Promise<ForgotPasswordResponse>;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ESPRMNeoUser } from "../../ESPRMNeoUser";
+/**
+ * Augments the ESPRMNeoAuth class with the `getLoggedInUser` method.
+ */
+declare module "../../ESPRMNeoAuth" {
+    interface ESPRMNeoAuth {
+        /**
+         * Retrieves the currently logged-in user.
+         *
+         * Reads tokens from storage. If the access token is expired, refreshes
+         * the session using the refresh token, then reloads. Returns null when
+         * no tokens are stored.
+         *
+         * @returns {Promise<ESPRMNeoUser | null>} An ESPRMNeoUser if a session is active, or null when no tokens are stored.
+         * @throws {ESPAuthError} If the session refresh fails.
+         */
+        getLoggedInUser(): Promise<ESPRMNeoUser | null>;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ESPRMNeoUser } from "../../ESPRMNeoUser";
+/**
+ * Augments the ESPRMNeoAuth class with the `login` method.
+ */
+declare module "../../ESPRMNeoAuth" {
+    interface ESPRMNeoAuth {
+        /**
+         * Logs in a user with username and password.
+         *
+         * Calls `POST /v1/user/auth/token`.
+         *
+         * @param username - The username (email or phone number) for authentication.
+         * @param password - The user's password.
+         * @returns A promise that resolves to an ESPRMNeoUser instance on successful login.
+         * @throws {ESPAuthError} If authentication fails or credentials are invalid.
+         */
+        login(username: string, password: string): Promise<ESPRMNeoUser>;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { ESPAPIResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAuth class with the `sendSignUpCode` method.
+ */
+declare module "../../ESPRMNeoAuth" {
+    interface ESPRMNeoAuth {
+        /**
+         * Sends a verification code to the user's email during the sign-up process.
+         *
+         * Calls `POST /v1/user/auth/signup`.
+         *
+         * @param username - The email address of the user signing up
+         * @param password - The password for the new account
+         * @param userAttributes - Optional additional user attributes
+         * @returns A promise that resolves with the API response when the verification code is sent successfully
+         * @throws {ESPAuthError} If the sign-up code request fails.
+         */
+        sendSignUpCode(username: string, password: string, userAttributes?: Record<string, string>): Promise<ESPAPIResponse>;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { SetNewPasswordResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAuth class with the `setNewPassword` method.
+ */
+declare module "../../ESPRMNeoAuth" {
+    interface ESPRMNeoAuth {
+        /**
+         * Sets a new password for a user during password recovery flow.
+         *
+         * Calls `POST /v1/user/auth/password-recovery/confirmation`.
+         *
+         * @param username - The username (email or phone number) for password recovery.
+         * @param newPassword - The new password to set.
+         * @param verificationCode - The verification code received by the user.
+         * @returns A promise that resolves to a SetNewPasswordResponse on success.
+         * @throws {ESPAuthError} If the verification code is invalid or password setting fails.
+         */
+        setNewPassword(username: string, newPassword: string, verificationCode: string): Promise<SetNewPasswordResponse>;
+    }
+}

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

@@ -0,0 +1,7 @@
+import "./ChangePassword";
+import "./ConfirmSignUp";
+import "./ForgotPassword";
+import "./GetLoggedInUser";
+import "./Login";
+import "./SendSignUpCode";
+import "./SetNewPassword";

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

@@ -0,0 +1,18 @@
+import { ActionTarget } from "../../types/automation";
+import { ESPAPIResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAutomation class with the `addAction` method.
+ */
+declare module "../../ESPRMNeoAutomation" {
+    interface ESPRMNeoAutomation {
+        /**
+         * Adds an action target to this automation. The instance is updated only
+         * after the API call succeeds.
+         *
+         * @param target - The action target to add.
+         * @returns A promise that resolves with the API response.
+         * @throws {ESPAPICallValidationError} If target is missing or missing required fields.
+         */
+        addAction(target: ActionTarget): Promise<ESPAPIResponse>;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ESPAPIResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAutomation class with the `addCondition` method.
+ */
+declare module "../../ESPRMNeoAutomation" {
+    interface ESPRMNeoAutomation {
+        /**
+         * Adds a condition (trigger id) to this automation. The instance is
+         * updated only after the API call succeeds.
+         *
+         * @param triggerId - The trigger id to add to conditions.
+         * @returns A promise that resolves with the API response.
+         * @throws {ESPAPICallValidationError} If triggerId is missing or empty.
+         */
+        addCondition(triggerId: string): Promise<ESPAPIResponse>;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { ESPAPIResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAutomation class with the `delete` method.
+ */
+declare module "../../ESPRMNeoAutomation" {
+    interface ESPRMNeoAutomation {
+        /**
+         * Deletes this automation. After a successful delete, the instance is
+         * stale — callers should discard it.
+         *
+         * Calls `DELETE /v1/groups/{groupId}/service/automations/{automationId}`.
+         *
+         * @returns A promise that resolves with the API response when the automation is successfully deleted.
+         * @throws If the API request fails.
+         */
+        delete(): Promise<ESPAPIResponse>;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ESPAPIResponse } from "../../types/output";
+/**
+ * Augments the ESPRMNeoAutomation class with the `removeAction` method.
+ */
+declare module "../../ESPRMNeoAutomation" {
+    interface ESPRMNeoAutomation {
+        /**
+         * Removes an action from this automation by index. The instance is
+         * updated only after the API call succeeds.
+         *
+         * @param index - The index of the action to remove.
+         * @returns A promise that resolves with the API response.
+         * @throws {ESPAPICallValidationError} If the index is out of range.
+         */
+        removeAction(index: number): Promise<ESPAPIResponse>;
+    }
+}