@hello.nrfcloud.com/nrfcloud-api-helpers 1.0.0

package/dist/api/getDeviceShadow.js

@@ -0,0 +1,33 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+import { DeviceShadow } from './DeviceShadow.js';
+const DeviceShadows = Type.Array(DeviceShadow);
+/**
+ * @see https://api.nrfcloud.com/v1#tag/All-Devices/operation/ListDevices
+ */
+const ListDevices = Type.Object({
+    items: DeviceShadows,
+    total: Type.Optional(Type.Number({ minimum: 0 })),
+    pageNextToken: Type.Optional(Type.String({ minLength: 1 })),
+});
+export const getDeviceShadow = ({ endpoint, apiKey, }, fetchImplementation) => {
+    const vf = validatedFetch({ endpoint, apiKey }, fetchImplementation);
+    return async (devices) => {
+        const params = {
+            includeState: true,
+            includeStateMeta: true,
+            pageLimit: 100,
+            deviceIds: devices.join(','),
+        };
+        const queryString = Object.entries(params)
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .map((kv) => kv.map(encodeURIComponent).join('='))
+            .join('&');
+        const url = `devices?${queryString}`;
+        const maybeResult = await vf({ resource: url }, ListDevices);
+        if ('error' in maybeResult) {
+            return { error: maybeResult.error };
+        }
+        return { shadows: maybeResult.result.items };
+    };
+};

package/dist/api/getDeviceShadow.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/getDeviceShadow.spec.js

@@ -0,0 +1,28 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { getDeviceShadow } from './getDeviceShadow.js';
+void describe('getDeviceShadow()', () => {
+    void it('should accept a response without pagination and total devices', async () => {
+        const mockFetch = mock.fn(() => ({
+            ok: true,
+            json: async () => Promise.resolve({
+                items: [],
+            }),
+        }));
+        const fetcher = getDeviceShadow({
+            endpoint: new URL('https://example.com/'),
+            apiKey: 'some-key',
+        }, mockFetch);
+        const res = await fetcher(['device-id']);
+        assert.deepEqual(mockFetch.mock.calls[0]?.arguments, [
+            `https://example.com/v1/devices?deviceIds=device-id&includeState=true&includeStateMeta=true&pageLimit=100`,
+            {
+                headers: {
+                    Accept: 'application/json; charset=utf-8',
+                    Authorization: 'Bearer some-key',
+                },
+            },
+        ]);
+        assert.deepEqual(res, { shadows: [] });
+    });
+});

package/dist/api/index.d.ts

@@ -0,0 +1,9 @@
+export * from './validatedFetch.js';
+export * from './devices.js';
+export * from './getCurrentMonthlyCosts.js';
+export * from './createAccountDevice.js';
+export * from './slashless.js';
+export * from './getAccountInfo.js';
+export * from './deleteAccountDevice.js';
+export * from './getDeviceShadow.js';
+export * from './DeviceShadow.js';

package/dist/api/index.js

@@ -0,0 +1,9 @@
+export * from './validatedFetch.js';
+export * from './devices.js';
+export * from './getCurrentMonthlyCosts.js';
+export * from './createAccountDevice.js';
+export * from './slashless.js';
+export * from './getAccountInfo.js';
+export * from './deleteAccountDevice.js';
+export * from './getDeviceShadow.js';
+export * from './DeviceShadow.js';

package/dist/api/slashless.d.ts

@@ -0,0 +1 @@
+export declare const slashless: (url: URL) => string;

package/dist/api/slashless.js

@@ -0,0 +1 @@
+export const slashless = (url) => url.toString().replace(/\/$/, '');

package/dist/api/slashless.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/slashless.spec.js

@@ -0,0 +1,6 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { slashless } from './slashless.js';
+void describe('slashless()', () => {
+    void it('should remove the slash from an URL and convert it to a string', () => assert.equal(slashless(new URL('https://api.nrfcloud.com/')), 'https://api.nrfcloud.com'));
+});

package/dist/api/test-data/account.json

@@ -0,0 +1,63 @@
+{
+    "mqttEndpoint": "mqtt.nrfcloud.com",
+    "mqttTopicPrefix": "prod/b8b26bc5-2814-4063-b4fa-83ecddb2fec7/",
+    "team": {
+        "tenantId": "b8b26bc5-2814-4063-b4fa-83ecddb2fec7",
+        "name": "XXX"
+    },
+    "role": "owner",
+    "tags": [],
+    "plan": {
+        "name": "ENTERPRISE",
+        "proxyUsageDeclarations": {
+            "AGPS": 0,
+            "PGPS": 0,
+            "GROUND_FIX": 0
+        },
+        "serviceKeys": [
+            {
+                "service": "ALL",
+                "enabled": true,
+                "createdAt": "2023-09-14T10:24:31.663Z"
+            }
+        ],
+        "currentMonthCosts": [
+            {
+                "serviceId": "Devices",
+                "serviceDescription": "Devices in your account",
+                "quantity": 53,
+                "price": 0.1,
+                "total": 5.3
+            },
+            {
+                "serviceId": "Messages",
+                "serviceDescription": "Device messages stored",
+                "quantity": 70281,
+                "price": 0.0001,
+                "total": 7.03
+            },
+            {
+                "serviceId": "AGPS",
+                "serviceDescription": "Assisted GPS Service: total requests",
+                "quantity": 8,
+                "price": 0.001,
+                "total": 0.01
+            },
+            {
+                "serviceId": "SCELL",
+                "serviceDescription": "Single-Cell Location Service: total requests",
+                "quantity": 2684,
+                "price": 0.001,
+                "total": 2.68
+            },
+            {
+                "serviceId": "MCELL",
+                "serviceDescription": "Multi-Cell Location Service: total requests",
+                "quantity": 4505,
+                "price": 0.002,
+                "total": 9.01
+            }
+        ],
+        "currentMonthTotalCost": 24.03
+    }
+}

package/dist/api/validatedFetch.d.ts

@@ -0,0 +1,30 @@
+import { type Static, type TObject } from '@sinclair/typebox';
+import type { ValueError } from '@sinclair/typebox/compiler';
+export declare class ValidationError extends Error {
+    errors: ValueError[];
+    readonly isValidationError = true;
+    constructor(errors: ValueError[]);
+}
+export declare const validatedFetch: ({ endpoint, apiKey }: {
+    apiKey: string;
+    endpoint: URL;
+}, fetchImplementation?: typeof fetch) => <Schema extends TObject<import("@sinclair/typebox").TProperties>>(params: {
+    resource: string;
+} | {
+    resource: string;
+    payload: Payload;
+} | {
+    resource: string;
+    method: string;
+}, schema: Schema) => Promise<{
+    error: Error | ValidationError;
+} | {
+    result: Static<Schema>;
+}>;
+type Payload = {
+    /** The content-type of body */
+    type: string;
+    body: string;
+};
+export declare const JSONPayload: (payload: Record<string, unknown>) => Payload;
+export {};

package/dist/api/validatedFetch.js

@@ -0,0 +1,54 @@
+import {} from '@sinclair/typebox';
+import { slashless } from './slashless.js';
+import { validateWithTypeBox } from '@hello.nrfcloud.com/proto';
+export class ValidationError extends Error {
+    errors;
+    isValidationError = true;
+    constructor(errors) {
+        super(`Validation errors`);
+        this.name = 'ValidationError';
+        this.errors = errors;
+    }
+}
+const validate = (SchemaObject, data) => {
+    const maybeData = validateWithTypeBox(SchemaObject)(data);
+    if ('errors' in maybeData) {
+        console.error('Validation failed', { error: maybeData.errors });
+        throw new ValidationError(maybeData.errors);
+    }
+    return maybeData.value;
+};
+const fetchData = (fetchImplementation) => async (...args) => {
+    const response = await (fetchImplementation ?? fetch)(...args);
+    if (!response.ok)
+        throw new Error(`Error fetching status: ${response.status}`);
+    return response.json();
+};
+export const validatedFetch = ({ endpoint, apiKey }, fetchImplementation) => async (params, schema) => {
+    const { resource } = params;
+    const args = {
+        headers: headers(apiKey),
+    };
+    if ('payload' in params) {
+        const payload = params.payload;
+        args.method = 'POST';
+        args.body = payload.body;
+        args.headers = { ...(args.headers ?? {}), ['Content-Type']: payload.type };
+    }
+    else if ('method' in params) {
+        args.method = params.method;
+    }
+    return fetchData(fetchImplementation)(`${slashless(endpoint)}/v1/${resource}`, args)
+        .then((res) => ({ result: validate(schema, res) }))
+        .catch((error) => ({
+        error,
+    }));
+};
+const headers = (apiKey) => ({
+    Authorization: `Bearer ${apiKey}`,
+    Accept: 'application/json; charset=utf-8',
+});
+export const JSONPayload = (payload) => ({
+    type: 'application/json',
+    body: JSON.stringify(payload),
+});

package/dist/api/validatedFetch.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/validatedFetch.spec.js

@@ -0,0 +1,101 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { Type } from '@sinclair/typebox';
+import { JSONPayload, validatedFetch } from './validatedFetch.js';
+void describe('validatedFetch()', () => {
+    void it('should call an nRF Cloud API endpoint and validate the response', async () => {
+        const mockFetch = mock.fn(() => ({
+            ok: true,
+            json: async () => Promise.resolve({
+                foo: 'bar',
+            }),
+        }));
+        const vf = validatedFetch({
+            endpoint: new URL('https://example.com/'),
+            apiKey: 'some-key',
+        }, mockFetch);
+        const schema = Type.Object({ foo: Type.Literal('bar') });
+        const res = await vf({ resource: 'foo' }, schema);
+        assert.equal('error' in res, false);
+        assert.equal('result' in res, true);
+        assert.deepEqual('result' in res && res.result, { foo: 'bar' });
+        assert.deepEqual(mockFetch.mock.calls[0]?.arguments, [
+            `https://example.com/v1/foo`,
+            {
+                headers: {
+                    Accept: 'application/json; charset=utf-8',
+                    Authorization: 'Bearer some-key',
+                },
+            },
+        ]);
+    });
+    void it('should return the fetch exception', async () => {
+        const err = new Error(`Some error`);
+        const vf = validatedFetch({
+            endpoint: new URL('https://example.com/'),
+            apiKey: 'some-key',
+        }, () => Promise.reject(err));
+        assert.deepEqual(await vf({ resource: 'some-resource' }, Type.Object({})), {
+            error: err,
+        });
+    });
+    void it('should send POST request if body is given', async () => {
+        const mockFetch = mock.fn(() => ({
+            ok: true,
+            json: async () => Promise.resolve({}),
+        }));
+        const vf = validatedFetch({
+            endpoint: new URL('https://example.com/'),
+            apiKey: 'some-key',
+        }, mockFetch);
+        await vf({
+            resource: 'foo',
+            payload: {
+                type: 'application/octet-stream',
+                body: 'some data',
+            },
+        }, Type.Object({}));
+        assert.deepEqual(mockFetch.mock.calls[0]?.arguments, [
+            `https://example.com/v1/foo`,
+            {
+                method: 'POST',
+                body: 'some data',
+                headers: {
+                    Accept: 'application/json; charset=utf-8',
+                    Authorization: 'Bearer some-key',
+                    'Content-Type': 'application/octet-stream',
+                },
+            },
+        ]);
+    });
+    void it('should allow to specify the method', async () => {
+        const mockFetch = mock.fn(() => ({
+            ok: true,
+            json: async () => Promise.resolve({}),
+        }));
+        const vf = validatedFetch({
+            endpoint: new URL('https://example.com/'),
+            apiKey: 'some-key',
+        }, mockFetch);
+        await vf({
+            resource: 'foo',
+            method: 'POST',
+        }, Type.Object({}));
+        assert.deepEqual(mockFetch.mock.calls[0]?.arguments, [
+            `https://example.com/v1/foo`,
+            {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json; charset=utf-8',
+                    Authorization: 'Bearer some-key',
+                },
+            },
+        ]);
+    });
+});
+void describe('JSONPayload()', () => {
+    void it('should convert a an object to a payload definition to be used in validatedFetch', () => assert.deepEqual(JSONPayload({ foo: 'bar' }), {
+        type: 'application/json',
+        body: JSON.stringify({ foo: 'bar' }),
+    }));
+});

package/dist/settings/getAllAccounts.d.ts

@@ -0,0 +1,5 @@
+import { SSMClient } from '@aws-sdk/client-ssm';
+export declare const getAllAccounts: ({ ssm, stackName, }: {
+    ssm: SSMClient;
+    stackName: string;
+}) => Promise<string[]>;

package/dist/settings/getAllAccounts.js

@@ -0,0 +1,9 @@
+import { SSMClient } from '@aws-sdk/client-ssm';
+import { Scopes } from './scope.js';
+import { get } from '@bifravst/aws-ssm-settings-helpers';
+export const getAllAccounts = async ({ ssm, stackName, }) => [
+    ...new Set(Object.keys(await get(ssm)({
+        stackName,
+        scope: Scopes.NRFCLOUD_ACCOUNT_PREFIX,
+    })()).map((key) => key.split('/')[0])),
+];

package/dist/settings/index.d.ts

@@ -0,0 +1,4 @@
+export * from './settings.js';
+export * from './scope.js';
+export * from './initializeAccount.js';
+export * from './getAllAccounts.js';

package/dist/settings/index.js

@@ -0,0 +1,4 @@
+export * from './settings.js';
+export * from './scope.js';
+export * from './initializeAccount.js';
+export * from './getAllAccounts.js';

package/dist/settings/initializeAccount.d.ts

@@ -0,0 +1,10 @@
+import { SSMClient } from '@aws-sdk/client-ssm';
+/**
+ * Initializes the nRF Cloud Account
+ */
+export declare const initializeAccount: ({ ssm, stackName, account, iotEndpoint, }: {
+    ssm: SSMClient;
+    stackName: string;
+    account: string;
+    iotEndpoint: string;
+}) => (reset?: boolean) => Promise<void>;

package/dist/settings/initializeAccount.js

@@ -0,0 +1,72 @@
+import { SSMClient } from '@aws-sdk/client-ssm';
+import chalk from 'chalk';
+import { nrfCloudAccount } from './scope.js';
+import { get } from '@bifravst/aws-ssm-settings-helpers';
+import { createAccountDevice } from '../api/createAccountDevice.js';
+import { deleteAccountDevice } from '../api/deleteAccountDevice.js';
+import { getAccountInfo } from '../api/getAccountInfo.js';
+import { defaultApiEndpoint, getSettings as getNRFCloudSettings, putSettings as putNRFCloudSettings, } from './settings.js';
+/**
+ * Initializes the nRF Cloud Account
+ */
+export const initializeAccount = ({ ssm, stackName, account, iotEndpoint, }) => async (reset = false) => {
+    const settingsReader = get(ssm)({
+        stackName,
+        ...nrfCloudAccount(account),
+    });
+    const { apiKey, apiEndpoint } = await settingsReader();
+    if (apiKey === undefined)
+        throw new Error(`nRF Cloud API key not configured.`);
+    let settingsWithAccountDevice = undefined;
+    try {
+        settingsWithAccountDevice = await getNRFCloudSettings({
+            ssm,
+            stackName,
+            account,
+        })();
+        console.log(chalk.white('Stack settings'));
+        Object.entries(settingsWithAccountDevice).forEach(([k, v]) => console.log(chalk.yellow(`${k}:`), chalk.blue(v)));
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk.magenta(`Stack not configured.`));
+    }
+    const effectiveEndpoint = apiEndpoint === undefined ? defaultApiEndpoint : new URL(apiEndpoint);
+    const accountInfo = await getAccountInfo({
+        endpoint: effectiveEndpoint,
+        apiKey,
+    });
+    if ('error' in accountInfo) {
+        console.error(chalk.red('⚠️'), '', chalk.red(accountInfo.error.message));
+        process.exit(1);
+    }
+    console.log(chalk.yellow('AWS IoT endpoint:'), chalk.blue(iotEndpoint));
+    console.log();
+    console.log(chalk.white('nRF Cloud account info:'));
+    Object.entries(accountInfo).forEach(([k, v]) => console.log(chalk.yellow(`${k}:`), chalk.blue(v)));
+    console.log();
+    if (reset === true) {
+        console.debug(chalk.magenta(`Deleting account device ...`));
+        await deleteAccountDevice({ apiKey, endpoint: effectiveEndpoint });
+        console.log(chalk.green(`Account device deleted.`));
+    }
+    if (settingsWithAccountDevice === undefined || reset === true) {
+        console.debug(chalk.magenta(`Generating new account device credentials ...`));
+        const { clientCert, privateKey } = await createAccountDevice({
+            apiKey,
+            endpoint: effectiveEndpoint,
+        });
+        if (privateKey === undefined) {
+            console.error(chalk.red('⚠️'), chalk.red('Account device exists'));
+            throw new Error(`Account device exists in account ${accountInfo.team.tenantId}`);
+        }
+        console.log(chalk.green(`Account device created.`));
+        await putNRFCloudSettings({ ssm, stackName, account })({
+            accountDeviceClientCert: clientCert,
+            accountDevicePrivateKey: privateKey,
+            accountDeviceClientId: `account-${accountInfo.team.tenantId}`,
+            mqttEndpoint: accountInfo.mqttEndpoint,
+            mqttTopicPrefix: accountInfo.mqttTopicPrefix,
+        });
+    }
+};

package/dist/settings/scope.d.ts

@@ -0,0 +1,17 @@
+export declare enum Scopes {
+    STACK = "stack",
+    NRFCLOUD_BRIDGE_CERTIFICATE = "nRFCloudBridgeCertificate",
+    NRFCLOUD_ACCOUNT_PREFIX = "thirdParty"
+}
+export type ScopeContext = {
+    scope: string;
+    context: string;
+};
+export declare const ScopeContexts: {
+    readonly STACK_CONFIG: ScopeContext;
+    readonly STACK_MQTT_BRIDGE: ScopeContext;
+    readonly STACK_COAP_HEALTH_CHECK: ScopeContext;
+    readonly NRFCLOUD_BRIDGE_CERTIFICATE_MQTT: ScopeContext;
+    readonly NRFCLOUD_BRIDGE_CERTIFICATE_CA: ScopeContext;
+};
+export declare const nrfCloudAccount: (account: string) => ScopeContext;

package/dist/settings/scope.js

@@ -0,0 +1,34 @@
+export var Scopes;
+(function (Scopes) {
+    Scopes["STACK"] = "stack";
+    Scopes["NRFCLOUD_BRIDGE_CERTIFICATE"] = "nRFCloudBridgeCertificate";
+    Scopes["NRFCLOUD_ACCOUNT_PREFIX"] = "thirdParty";
+})(Scopes || (Scopes = {}));
+export const ScopeContexts = {
+    STACK_CONFIG: { scope: Scopes.STACK, context: 'context' },
+    STACK_MQTT_BRIDGE: {
+        scope: Scopes.STACK,
+        context: 'mqttBridge',
+    },
+    STACK_COAP_HEALTH_CHECK: {
+        scope: Scopes.STACK,
+        context: 'coap-health-check',
+    },
+    NRFCLOUD_BRIDGE_CERTIFICATE_MQTT: {
+        scope: Scopes.NRFCLOUD_BRIDGE_CERTIFICATE,
+        context: 'MQTT',
+    },
+    NRFCLOUD_BRIDGE_CERTIFICATE_CA: {
+        scope: Scopes.NRFCLOUD_BRIDGE_CERTIFICATE,
+        context: 'CA',
+    },
+};
+const nameRx = /^[a-zA-Z0-9_.-]+$/;
+export const nrfCloudAccount = (account) => {
+    if (!nameRx.test(account))
+        throw new Error(`Invalid account name: ${account}`);
+    return {
+        scope: Scopes.NRFCLOUD_ACCOUNT_PREFIX,
+        context: account,
+    };
+};

package/dist/settings/settings.d.ts

@@ -0,0 +1,43 @@
+import type { SSMClient } from '@aws-sdk/client-ssm';
+export declare const defaultApiEndpoint: URL;
+export declare const defaultCoAPEndpoint: URL;
+export type Settings = {
+    apiEndpoint: URL;
+    apiKey: string;
+    accountDeviceClientCert: string;
+    accountDevicePrivateKey: string;
+    accountDeviceClientId: string;
+    mqttEndpoint: string;
+    mqttTopicPrefix: string;
+    coapEndpoint: URL;
+    coapPort: number;
+};
+export declare const getSettings: ({ ssm, stackName, account, }: {
+    ssm: SSMClient;
+    stackName: string;
+    account: string;
+}) => (() => Promise<Settings>);
+export declare const getAPISettings: ({ ssm, stackName, account, }: {
+    ssm: SSMClient;
+    stackName: string;
+    account: string;
+}) => (() => Promise<Pick<Settings, 'apiKey' | 'apiEndpoint'>>);
+export declare const putSettings: ({ ssm, stackName, account, }: {
+    ssm: SSMClient;
+    stackName: string;
+    account: string;
+}) => (settings: Partial<Settings>) => Promise<void>;
+export declare const putSetting: ({ ssm, stackName, account, }: {
+    ssm: SSMClient;
+    stackName: string;
+    account: string;
+}) => (property: keyof Settings, value: string, deleteBeforeUpdate: boolean) => Promise<{
+    name: string;
+}>;
+export declare const deleteSettings: ({ ssm, stackName, account, }: {
+    ssm: SSMClient;
+    stackName: string;
+    account: string;
+}) => (property: string) => Promise<{
+    name: string;
+}>;

package/dist/settings/settings.js

@@ -0,0 +1,85 @@
+import { nrfCloudAccount } from './scope.js';
+import { get as getSSMSettings, put as putSSMSettings, remove as deleteSSMSettings, } from '@bifravst/aws-ssm-settings-helpers';
+export const defaultApiEndpoint = new URL('https://api.nrfcloud.com');
+export const defaultCoAPEndpoint = new URL('coaps://coap.nrfcloud.com');
+export const getSettings = ({ ssm, stackName, account, }) => {
+    const settingsReader = getSSMSettings(ssm)({
+        stackName,
+        ...nrfCloudAccount(account),
+    });
+    return async () => {
+        const p = await settingsReader();
+        const { apiEndpoint, apiKey, accountDeviceClientCert, accountDevicePrivateKey, mqttEndpoint, accountDeviceClientId, mqttTopicPrefix, coapEndpoint, coapPort, } = p;
+        if (apiKey === undefined)
+            throw new Error(`No nRF Cloud API key configured!`);
+        if (accountDeviceClientCert === undefined)
+            throw new Error(`No nRF Cloud account device clientCert configured!`);
+        if (accountDevicePrivateKey === undefined)
+            throw new Error(`No nRF Cloud account device privateKey configured!`);
+        if (accountDeviceClientId === undefined)
+            throw new Error(`No nRF Cloud Account Device client ID configured!`);
+        if (mqttTopicPrefix === undefined)
+            throw new Error(`No nRF Cloud MQTT topic prefix configured!`);
+        if (mqttEndpoint === undefined)
+            throw new Error(`No nRF Cloud MQTT endpoint configured!`);
+        return {
+            apiEndpoint: apiEndpoint === undefined ? defaultApiEndpoint : new URL(apiEndpoint),
+            apiKey,
+            mqttEndpoint,
+            accountDeviceClientCert,
+            accountDevicePrivateKey,
+            accountDeviceClientId,
+            mqttTopicPrefix,
+            coapEndpoint: coapEndpoint === undefined
+                ? defaultCoAPEndpoint
+                : new URL(coapEndpoint),
+            coapPort: parseInt(coapPort ?? `5684`, 10),
+        };
+    };
+};
+export const getAPISettings = ({ ssm, stackName, account, }) => {
+    const settingsReader = getSSMSettings(ssm)({
+        stackName,
+        ...nrfCloudAccount(account),
+    });
+    return async () => {
+        const p = await settingsReader();
+        const { apiEndpoint, apiKey } = p;
+        if (apiKey === undefined)
+            throw new Error(`No nRF Cloud API key configured!`);
+        return {
+            apiEndpoint: apiEndpoint === undefined ? defaultApiEndpoint : new URL(apiEndpoint),
+            apiKey,
+        };
+    };
+};
+export const putSettings = ({ ssm, stackName, account, }) => {
+    const settingsWriter = putSSMSettings(ssm)({
+        stackName,
+        ...nrfCloudAccount(account),
+    });
+    return async (settings) => {
+        await Promise.all(Object.entries(settings).map(async ([k, v]) => settingsWriter({
+            property: k,
+            value: v.toString(),
+        })));
+    };
+};
+export const putSetting = ({ ssm, stackName, account, }) => {
+    const settingsWriter = putSSMSettings(ssm)({
+        stackName,
+        ...nrfCloudAccount(account),
+    });
+    return async (property, value, deleteBeforeUpdate) => settingsWriter({
+        property,
+        value,
+        deleteBeforeUpdate,
+    });
+};
+export const deleteSettings = ({ ssm, stackName, account, }) => {
+    const settingsDeleter = deleteSSMSettings(ssm)({
+        stackName,
+        ...nrfCloudAccount(account),
+    });
+    return async (property) => settingsDeleter({ property });
+};