@atlaskit/link-datasource 2.9.4 → 2.9.6

package/dist/es2019/ui/issue-like-table/column-picker/index.js

@@ -81,9 +81,9 @@ export const ColumnPicker = ({
   };
   useEffect(() => {
     if (allOptions.length) {
-      var _pickerRef$current, _pickerRef$current$se, _pickerRef$current$se2;
+      var _pickerRef$current, _pickerRef$current$se, _pickerRef$current$se2, _pickerRef$current$se3;
       // necessary to refocus the search input after the loading state
-      pickerRef === null || pickerRef === void 0 ? void 0 : (_pickerRef$current = pickerRef.current) === null || _pickerRef$current === void 0 ? void 0 : (_pickerRef$current$se = _pickerRef$current.selectRef) === null || _pickerRef$current$se === void 0 ? void 0 : (_pickerRef$current$se2 = _pickerRef$current$se.inputRef) === null || _pickerRef$current$se2 === void 0 ? void 0 : _pickerRef$current$se2.focus();
+      pickerRef === null || pickerRef === void 0 ? void 0 : (_pickerRef$current = pickerRef.current) === null || _pickerRef$current === void 0 ? void 0 : (_pickerRef$current$se = _pickerRef$current.selectRef) === null || _pickerRef$current$se === void 0 ? void 0 : (_pickerRef$current$se2 = _pickerRef$current$se.select) === null || _pickerRef$current$se2 === void 0 ? void 0 : (_pickerRef$current$se3 = _pickerRef$current$se2.inputRef) === null || _pickerRef$current$se3 === void 0 ? void 0 : _pickerRef$current$se3.focus();
     }
   }, [allOptions]);
   useEffect(() => {

package/dist/esm/hooks/useDatasourceTableState.js

@@ -8,6 +8,7 @@ import { DEFAULT_GET_DATASOURCE_DATA_PAGE_SIZE, useDatasourceClientExtension } f
 import { fg } from '@atlaskit/platform-feature-flags';
 import { useDatasourceAnalyticsEvents } from '../analytics';
 import { useDatasourceActions } from '../state';
+import { useDiscoverActions } from '../state/actions';
 import useErrorLogger from './useErrorLogger';
 export var useDatasourceTableState = function useDatasourceTableState(_ref) {
   var datasourceId = _ref.datasourceId,
@@ -22,6 +23,8 @@ export var useDatasourceTableState = function useDatasourceTableState(_ref) {
     captureError = _useErrorLogger.captureError;
   var _useDatasourceActions = useDatasourceActions(),
     onAddItems = _useDatasourceActions.onAddItems;
+  var _useDiscoverActions = useDiscoverActions(),
+    discoverActions = _useDiscoverActions.discoverActions;
   var idFieldCount = 1;
   var keyFieldCount = 1;
   var _useState = useState([]),
@@ -208,6 +211,7 @@ export var useDatasourceTableState = function useDatasourceTableState(_ref) {
       _yield$getDatasourceD4,
       access,
       _destinationObjectTypes,
+      product,
       _extensionKey,
       auth,
       _providerName,
@@ -216,7 +220,9 @@ export var useDatasourceTableState = function useDatasourceTableState(_ref) {
       nextPageCursor,
       _totalCount,
       schema,
+      integrationKey,
       newIds,
+      aris,
       isUserLoadingNextPage,
       currentLoadedItemCount,
       newlyLoadedItemCount,
@@ -258,6 +264,7 @@ export var useDatasourceTableState = function useDatasourceTableState(_ref) {
           _yield$getDatasourceD4 = _yield$getDatasourceD3.meta;
           access = _yield$getDatasourceD4.access;
           _destinationObjectTypes = _yield$getDatasourceD4.destinationObjectTypes;
+          product = _yield$getDatasourceD4.product;
           _extensionKey = _yield$getDatasourceD4.extensionKey;
           auth = _yield$getDatasourceD4.auth;
           _providerName = _yield$getDatasourceD4.providerName;
@@ -267,21 +274,21 @@ export var useDatasourceTableState = function useDatasourceTableState(_ref) {
           _totalCount = _yield$getDatasourceD5.totalCount;
           schema = _yield$getDatasourceD5.schema;
           if (!((_currentAbortControll = currentAbortController) !== null && _currentAbortControll !== void 0 && _currentAbortControll.signal.aborted)) {
-            _context2.next = 27;
+            _context2.next = 28;
             break;
           }
           throw new Error('Aborted');
-        case 27:
+        case 28:
           setExtensionKey(_extensionKey);
           setProviderName(_providerName);
           if (!(access === 'unauthorized' || access === 'forbidden')) {
-            _context2.next = 33;
+            _context2.next = 34;
             break;
           }
           setStatus(access);
           setAuthDetails(auth || initialEmptyArray);
           return _context2.abrupt("return");
-        case 33:
+        case 34:
           setDestinationObjectTypes(_destinationObjectTypes);
           setTotalCount(_totalCount);
           setNextCursor(nextPageCursor);
@@ -292,10 +299,29 @@ export var useDatasourceTableState = function useDatasourceTableState(_ref) {
             return [].concat(_toConsumableArray(currentResponseItems), _toConsumableArray(items));
           });
           if (fg('enable_datasource_react_sweet_state')) {
-            newIds = onAddItems(items);
+            /**
+             * Product is typed as any.
+             */
+            integrationKey = product;
+            newIds = onAddItems(items, typeof integrationKey === 'string' ? integrationKey : undefined);
             setResponseItemIds(function (currentIds) {
               return [].concat(_toConsumableArray(currentIds), _toConsumableArray(newIds));
             });
+            if (fg('platform-datasources-enable-two-way-sync')) {
+              if (typeof integrationKey === 'string') {
+                aris = items.reduce(function (acc, item) {
+                  var _item$ari;
+                  return typeof ((_item$ari = item.ari) === null || _item$ari === void 0 ? void 0 : _item$ari.data) === 'string' ? [].concat(_toConsumableArray(acc), [item.ari.data]) : acc;
+                }, []);
+                if (aris.length) {
+                  discoverActions({
+                    aris: aris,
+                    integrationKey: integrationKey,
+                    fieldKeys: fieldKeys
+                  });
+                }
+              }
+            }
           }
           setHasNextPage(Boolean(nextPageCursor));
           if (fieldKeys.length > 0) {
@@ -315,39 +341,39 @@ export var useDatasourceTableState = function useDatasourceTableState(_ref) {
             });
           }
           setStatus('resolved');
-          _context2.next = 58;
+          _context2.next = 59;
           break;
-        case 46:
-          _context2.prev = 46;
+        case 47:
+          _context2.prev = 47;
           _context2.t0 = _context2["catch"](10);
           if (!(_context2.t0.message === 'Aborted')) {
-            _context2.next = 50;
+            _context2.next = 51;
             break;
           }
           return _context2.abrupt("return");
-        case 50:
+        case 51:
           captureError('onNextPage', _context2.t0);
           if (!(_context2.t0 instanceof Response && _context2.t0.status === 401)) {
-            _context2.next = 54;
+            _context2.next = 55;
             break;
           }
           setStatus('unauthorized');
           return _context2.abrupt("return");
-        case 54:
+        case 55:
           if (!(_context2.t0 instanceof Response && _context2.t0.status === 403)) {
-            _context2.next = 57;
+            _context2.next = 58;
             break;
           }
           setStatus('forbidden');
           return _context2.abrupt("return");
-        case 57:
-          setStatus('rejected');
         case 58:
+          setStatus('rejected');
+        case 59:
         case "end":
           return _context2.stop();
       }
-    }, _callee2, null, [[10, 46]]);
-  })), [captureError, parameters, fieldKeys, nextCursor, responseItems, setResponseItemIds, onAddItems, getDatasourceData, datasourceId, applySchemaProperties, fireEvent, fullSchema, initialEmptyArray]);
+    }, _callee2, null, [[10, 47]]);
+  })), [captureError, parameters, fieldKeys, nextCursor, responseItems, setResponseItemIds, onAddItems, getDatasourceData, datasourceId, applySchemaProperties, fireEvent, fullSchema, initialEmptyArray, discoverActions]);
   var reset = useCallback(function (options) {
     setResponseItems(initialEmptyArray);
     setResponseItemIds(initialEmptyArray);

package/dist/esm/state/actions/index.js

@@ -0,0 +1,177 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { useCallback, useMemo } from 'react';
+import { createActionsHook, createHook, createStore } from 'react-sweet-state';
+import { useDatasourceClientExtension } from '@atlaskit/link-client-extension';
+
+/**
+ * Atomic actions available for an integration (by field)
+ * @example
+ * ```ts
+ *	{
+ *		jira: {
+ *			summary: {
+ *				actionKey: 'atlassian:issue:update:summary',
+ *				type: 'string',
+ *				description: 'Update issue summary',
+ *			}
+ *		}
+ *	}
+ * ```
+ */
+
+/**
+ * Permissions available for a target
+ */
+
+/**
+ * User permissions for actions on target (ARI) properties
+ * @example
+ * ```ts
+ *	{
+ *		'ari:cloud:jira:63cecfe3-16fa-4ee1-8e8d-047cc4b18980:issue/1': {
+ *			summary: {
+ *				isEditable: true
+ *			}
+ *		}
+ *	}
+ * ```
+ */
+
+var getInitialState = function getInitialState() {
+  return {
+    actionsByIntegration: {},
+    permissions: {}
+  };
+};
+export var actions = {
+  discoverActions: function discoverActions(api, request) {
+    return /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+        var setState, getState, response, _getState, currentActions, currentPermissions, actionsByIntegration, permissions;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              setState = _ref.setState, getState = _ref.getState;
+              _context.next = 3;
+              return api.getDatasourceActionsAndPermissions(request);
+            case 3:
+              response = _context.sent;
+              if ('permissions' in response) {
+                _getState = getState(), currentActions = _getState.actionsByIntegration, currentPermissions = _getState.permissions;
+                actionsByIntegration = response.actions.reduce(function (acc, action) {
+                  return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, action.integrationKey, _objectSpread(_objectSpread({}, acc[action.integrationKey]), {}, _defineProperty({}, action.fieldKey, {
+                    actionKey: action.actionKey,
+                    type: action.type
+                  }))));
+                }, currentActions);
+                permissions = response.permissions.data.reduce(function (acc, permission) {
+                  return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, permission.ari, _objectSpread(_objectSpread({}, acc[permission.ari]), {}, _defineProperty({}, permission.fieldKey, {
+                    isEditable: permission.isEditable
+                  }))));
+                }, currentPermissions);
+                setState({
+                  actionsByIntegration: actionsByIntegration,
+                  permissions: permissions
+                });
+              }
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+  }
+};
+export var ActionsStore = createStore({
+  name: 'actions-store',
+  initialState: getInitialState(),
+  actions: actions
+});
+var useActionStoreActions = createActionsHook(ActionsStore);
+export var useDiscoverActions = function useDiscoverActions() {
+  var _useDatasourceClientE = useDatasourceClientExtension(),
+    getDatasourceActionsAndPermissions = _useDatasourceClientE.getDatasourceActionsAndPermissions;
+  var _useActionStoreAction = useActionStoreActions(),
+    discoverActions = _useActionStoreAction.discoverActions;
+  return {
+    discoverActions: useMemo(function () {
+      return discoverActions.bind(null, {
+        getDatasourceActionsAndPermissions: getDatasourceActionsAndPermissions
+      });
+    }, [discoverActions, getDatasourceActionsAndPermissions])
+  };
+};
+var getFieldUpdateActionByAri = function getFieldUpdateActionByAri(state, _ref3) {
+  var _state$permissions$ar, _state$actionsByInteg;
+  var ari = _ref3.ari,
+    fieldKey = _ref3.fieldKey,
+    integrationKey = _ref3.integrationKey;
+  var isEditable = (_state$permissions$ar = state.permissions[ari]) === null || _state$permissions$ar === void 0 || (_state$permissions$ar = _state$permissions$ar[fieldKey]) === null || _state$permissions$ar === void 0 ? void 0 : _state$permissions$ar.isEditable;
+  if (isEditable === false) {
+    return;
+  }
+  return (_state$actionsByInteg = state.actionsByIntegration[integrationKey]) === null || _state$actionsByInteg === void 0 ? void 0 : _state$actionsByInteg[fieldKey];
+};
+
+/**
+ * Retrieves the action schema for a given ARI + fieldKey + integrationKey
+ */
+export var useAtomicUpdateActionSchema = createHook(ActionsStore, {
+  selector: getFieldUpdateActionByAri
+});
+
+/**
+ * Given an ARI + fieldKey + integrationKey
+ * Returns an executable action that updates a field on the entity if the user has permissions to do so
+ *
+ * @example
+ * ```tsx
+ * const { execute } = useExecuteAtomicAction({ ari, fieldKey: 'summary', integrationKey: 'jira' });
+ *
+ * return <button onClick={() => execute('New summary')}>Update summary</button>;
+ * ```
+ */
+export var useExecuteAtomicAction = function useExecuteAtomicAction(_ref4) {
+  var ari = _ref4.ari,
+    fieldKey = _ref4.fieldKey,
+    integrationKey = _ref4.integrationKey;
+  var _useAtomicUpdateActio = useAtomicUpdateActionSchema({
+      ari: ari,
+      fieldKey: fieldKey,
+      integrationKey: integrationKey
+    }),
+    _useAtomicUpdateActio2 = _slicedToArray(_useAtomicUpdateActio, 1),
+    schema = _useAtomicUpdateActio2[0];
+  var _useDatasourceClientE2 = useDatasourceClientExtension(),
+    executeAction = _useDatasourceClientE2.executeAtomicAction;
+  var execute = useCallback(function (value) {
+    if (!schema) {
+      throw new Error('No action schema found.');
+    }
+    executeAction({
+      integrationKey: integrationKey,
+      actionKey: schema.actionKey,
+      parameters: {
+        inputs: _defineProperty({}, fieldKey, value),
+        target: {
+          ari: ari
+        }
+      }
+    });
+  }, [executeAction, integrationKey, schema, fieldKey, ari]);
+  if (!schema) {
+    return null;
+  }
+  return {
+    execute: execute
+  };
+};

package/dist/esm/state/index.js

@@ -13,19 +13,22 @@ var getInitialState = function getInitialState() {
   };
 };
 export var actions = {
-  onAddItems: function onAddItems(items) {
+  onAddItems: function onAddItems(items, integrationKey) {
     return function (_ref) {
       var setState = _ref.setState,
         getState = _ref.getState;
       var oldItems = _objectSpread({}, getState().items);
       var _items$reduce = items.reduce(function (_ref2, item) {
-          var _item$ari;
+          var _item$ari, _oldItems$id;
           var _ref3 = _slicedToArray(_ref2, 2),
             ids = _ref3[0],
             itemMap = _ref3[1];
           var ari = typeof ((_item$ari = item['ari']) === null || _item$ari === void 0 ? void 0 : _item$ari.data) === 'string' ? item['ari'].data : undefined;
           var id = ari !== null && ari !== void 0 ? ari : uuidv4();
-          return [[].concat(_toConsumableArray(ids), [id]), _objectSpread(_objectSpread({}, itemMap), {}, _defineProperty({}, id, _objectSpread(_objectSpread({}, oldItems[id]), item)))];
+          return [[].concat(_toConsumableArray(ids), [id]), _objectSpread(_objectSpread({}, itemMap), {}, _defineProperty({}, id, {
+            integrationKey: integrationKey,
+            data: _objectSpread(_objectSpread({}, (_oldItems$id = oldItems[id]) === null || _oldItems$id === void 0 ? void 0 : _oldItems$id.data), item)
+          }))];
         }, [[], oldItems]),
         _items$reduce2 = _slicedToArray(_items$reduce, 2),
         newItemIds = _items$reduce2[0],
@@ -44,8 +47,9 @@ export var Store = createStore({
 });
 export var useDatasourceItem = createStateHook(Store, {
   selector: function selector(state, _ref4) {
+    var _state$items$id;
     var id = _ref4.id;
-    return state.items[id];
+    return (_state$items$id = state.items[id]) === null || _state$items$id === void 0 ? void 0 : _state$items$id.data;
   }
 });
 export var useDatasourceActions = createActionsHook(Store);

package/dist/esm/ui/issue-like-table/column-picker/index.js

@@ -101,7 +101,7 @@ export var ColumnPicker = function ColumnPicker(_ref) {
     if (allOptions.length) {
       var _pickerRef$current;
       // necessary to refocus the search input after the loading state
-      pickerRef === null || pickerRef === void 0 || (_pickerRef$current = pickerRef.current) === null || _pickerRef$current === void 0 || (_pickerRef$current = _pickerRef$current.selectRef) === null || _pickerRef$current === void 0 || (_pickerRef$current = _pickerRef$current.inputRef) === null || _pickerRef$current === void 0 || _pickerRef$current.focus();
+      pickerRef === null || pickerRef === void 0 || (_pickerRef$current = pickerRef.current) === null || _pickerRef$current === void 0 || (_pickerRef$current = _pickerRef$current.selectRef) === null || _pickerRef$current === void 0 || (_pickerRef$current = _pickerRef$current.select) === null || _pickerRef$current === void 0 || (_pickerRef$current = _pickerRef$current.inputRef) === null || _pickerRef$current === void 0 || _pickerRef$current.focus();
     }
   }, [allOptions]);
   useEffect(function () {

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

@@ -0,0 +1,87 @@
+import { type Action } from 'react-sweet-state';
+import { useDatasourceClientExtension } from '@atlaskit/link-client-extension';
+import type { ActionsDiscoveryRequest, AtomicActionInterface } from '@atlaskit/linking-types';
+type IntegrationKey = string;
+type FieldKey = string;
+/**
+ * Atomic actions available for an integration (by field)
+ * @example
+ * ```ts
+ *	{
+ *		jira: {
+ *			summary: {
+ *				actionKey: 'atlassian:issue:update:summary',
+ *				type: 'string',
+ *				description: 'Update issue summary',
+ *			}
+ *		}
+ *	}
+ * ```
+ */
+type IntegrationActions = Record<IntegrationKey, Record<FieldKey, Pick<AtomicActionInterface, 'actionKey' | 'type' | 'description'>>>;
+/**
+ * Permissions available for a target
+ */
+type TargetPermissions = Record<FieldKey, {
+    isEditable: boolean;
+}>;
+/**
+ * User permissions for actions on target (ARI) properties
+ * @example
+ * ```ts
+ *	{
+ *		'ari:cloud:jira:63cecfe3-16fa-4ee1-8e8d-047cc4b18980:issue/1': {
+ *			summary: {
+ *				isEditable: true
+ *			}
+ *		}
+ *	}
+ * ```
+ */
+type ARI = string;
+type Permissions = Record<ARI, TargetPermissions>;
+export interface ActionsStoreState {
+    actionsByIntegration: IntegrationActions;
+    permissions: Permissions;
+}
+interface Client {
+    getDatasourceActionsAndPermissions: ReturnType<typeof useDatasourceClientExtension>['getDatasourceActionsAndPermissions'];
+}
+export declare const actions: {
+    discoverActions: (api: Client, request: ActionsDiscoveryRequest) => Action<ActionsStoreState>;
+};
+export declare const ActionsStore: import("react-sweet-state").Store<ActionsStoreState, {
+    discoverActions: (api: Client, request: ActionsDiscoveryRequest) => Action<ActionsStoreState>;
+}>;
+export declare const useDiscoverActions: () => {
+    discoverActions: (request: ActionsDiscoveryRequest) => void | Promise<void>;
+};
+/**
+ * Retrieves the action schema for a given ARI + fieldKey + integrationKey
+ */
+export declare const useAtomicUpdateActionSchema: import("react-sweet-state").HookFunction<Pick<AtomicActionInterface, "actionKey" | "type" | "description"> | undefined, import("react-sweet-state").BoundActions<ActionsStoreState, {
+    discoverActions: (api: Client, request: ActionsDiscoveryRequest) => Action<ActionsStoreState>;
+}>, {
+    ari: string;
+    fieldKey: string;
+    integrationKey: string;
+}>;
+/**
+ * Given an ARI + fieldKey + integrationKey
+ * Returns an executable action that updates a field on the entity if the user has permissions to do so
+ *
+ * @example
+ * ```tsx
+ * const { execute } = useExecuteAtomicAction({ ari, fieldKey: 'summary', integrationKey: 'jira' });
+ *
+ * return <button onClick={() => execute('New summary')}>Update summary</button>;
+ * ```
+ */
+export declare const useExecuteAtomicAction: ({ ari, fieldKey, integrationKey, }: {
+    ari: string;
+    fieldKey: string;
+    integrationKey: string;
+}) => {
+    execute: (value: AtomicActionInterface['type']) => void;
+} | null;
+export {};

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

@@ -1,21 +1,26 @@
 /// <reference types="react" />
 import { type Action } from 'react-sweet-state';
-import { type DatasourceDataResponseItem } from '@atlaskit/linking-types';
+import type { DatasourceDataResponseItem } from '@atlaskit/linking-types';
+type UniqueIdentifier = string;
 export interface State {
-    items: Record<string, DatasourceDataResponseItem>;
+    items: Record<UniqueIdentifier, {
+        integrationKey: string | undefined;
+        data: DatasourceDataResponseItem;
+    }>;
 }
 export declare const actions: {
-    onAddItems: (items: DatasourceDataResponseItem[]) => Action<State, void, string[]>;
+    onAddItems: (items: DatasourceDataResponseItem[], integrationKey: string | undefined) => Action<State, void, string[]>;
 };
 export declare const Store: import("react-sweet-state").Store<State, {
-    onAddItems: (items: DatasourceDataResponseItem[]) => Action<State, void, string[]>;
+    onAddItems: (items: DatasourceDataResponseItem[], integrationKey: string | undefined) => Action<State, void, string[]>;
 }>;
 export declare const useDatasourceItem: import("react-sweet-state").HookStateFunction<DatasourceDataResponseItem | undefined, {
     id: string;
 }>;
 export declare const useDatasourceActions: import("react-sweet-state").HookActionsFunction<import("react-sweet-state").BoundActions<State, {
-    onAddItems: (items: DatasourceDataResponseItem[]) => Action<State, void, string[]>;
+    onAddItems: (items: DatasourceDataResponseItem[], integrationKey: string | undefined) => Action<State, void, string[]>;
 }>>;
 export declare const StoreContainer: ({ children }: {
     children: JSX.Element;
 }) => JSX.Element;
+export {};

package/dist/types-ts4.5/state/actions/index.d.ts

@@ -0,0 +1,87 @@
+import { type Action } from 'react-sweet-state';
+import { useDatasourceClientExtension } from '@atlaskit/link-client-extension';
+import type { ActionsDiscoveryRequest, AtomicActionInterface } from '@atlaskit/linking-types';
+type IntegrationKey = string;
+type FieldKey = string;
+/**
+ * Atomic actions available for an integration (by field)
+ * @example
+ * ```ts
+ *	{
+ *		jira: {
+ *			summary: {
+ *				actionKey: 'atlassian:issue:update:summary',
+ *				type: 'string',
+ *				description: 'Update issue summary',
+ *			}
+ *		}
+ *	}
+ * ```
+ */
+type IntegrationActions = Record<IntegrationKey, Record<FieldKey, Pick<AtomicActionInterface, 'actionKey' | 'type' | 'description'>>>;
+/**
+ * Permissions available for a target
+ */
+type TargetPermissions = Record<FieldKey, {
+    isEditable: boolean;
+}>;
+/**
+ * User permissions for actions on target (ARI) properties
+ * @example
+ * ```ts
+ *	{
+ *		'ari:cloud:jira:63cecfe3-16fa-4ee1-8e8d-047cc4b18980:issue/1': {
+ *			summary: {
+ *				isEditable: true
+ *			}
+ *		}
+ *	}
+ * ```
+ */
+type ARI = string;
+type Permissions = Record<ARI, TargetPermissions>;
+export interface ActionsStoreState {
+    actionsByIntegration: IntegrationActions;
+    permissions: Permissions;
+}
+interface Client {
+    getDatasourceActionsAndPermissions: ReturnType<typeof useDatasourceClientExtension>['getDatasourceActionsAndPermissions'];
+}
+export declare const actions: {
+    discoverActions: (api: Client, request: ActionsDiscoveryRequest) => Action<ActionsStoreState>;
+};
+export declare const ActionsStore: import("react-sweet-state").Store<ActionsStoreState, {
+    discoverActions: (api: Client, request: ActionsDiscoveryRequest) => Action<ActionsStoreState>;
+}>;
+export declare const useDiscoverActions: () => {
+    discoverActions: (request: ActionsDiscoveryRequest) => void | Promise<void>;
+};
+/**
+ * Retrieves the action schema for a given ARI + fieldKey + integrationKey
+ */
+export declare const useAtomicUpdateActionSchema: import("react-sweet-state").HookFunction<Pick<AtomicActionInterface, "actionKey" | "type" | "description"> | undefined, import("react-sweet-state").BoundActions<ActionsStoreState, {
+    discoverActions: (api: Client, request: ActionsDiscoveryRequest) => Action<ActionsStoreState>;
+}>, {
+    ari: string;
+    fieldKey: string;
+    integrationKey: string;
+}>;
+/**
+ * Given an ARI + fieldKey + integrationKey
+ * Returns an executable action that updates a field on the entity if the user has permissions to do so
+ *
+ * @example
+ * ```tsx
+ * const { execute } = useExecuteAtomicAction({ ari, fieldKey: 'summary', integrationKey: 'jira' });
+ *
+ * return <button onClick={() => execute('New summary')}>Update summary</button>;
+ * ```
+ */
+export declare const useExecuteAtomicAction: ({ ari, fieldKey, integrationKey, }: {
+    ari: string;
+    fieldKey: string;
+    integrationKey: string;
+}) => {
+    execute: (value: AtomicActionInterface['type']) => void;
+} | null;
+export {};

package/dist/types-ts4.5/state/index.d.ts

@@ -1,21 +1,26 @@
 /// <reference types="react" />
 import { type Action } from 'react-sweet-state';
-import { type DatasourceDataResponseItem } from '@atlaskit/linking-types';
+import type { DatasourceDataResponseItem } from '@atlaskit/linking-types';
+type UniqueIdentifier = string;
 export interface State {
-    items: Record<string, DatasourceDataResponseItem>;
+    items: Record<UniqueIdentifier, {
+        integrationKey: string | undefined;
+        data: DatasourceDataResponseItem;
+    }>;
 }
 export declare const actions: {
-    onAddItems: (items: DatasourceDataResponseItem[]) => Action<State, void, string[]>;
+    onAddItems: (items: DatasourceDataResponseItem[], integrationKey: string | undefined) => Action<State, void, string[]>;
 };
 export declare const Store: import("react-sweet-state").Store<State, {
-    onAddItems: (items: DatasourceDataResponseItem[]) => Action<State, void, string[]>;
+    onAddItems: (items: DatasourceDataResponseItem[], integrationKey: string | undefined) => Action<State, void, string[]>;
 }>;
 export declare const useDatasourceItem: import("react-sweet-state").HookStateFunction<DatasourceDataResponseItem | undefined, {
     id: string;
 }>;
 export declare const useDatasourceActions: import("react-sweet-state").HookActionsFunction<import("react-sweet-state").BoundActions<State, {
-    onAddItems: (items: DatasourceDataResponseItem[]) => Action<State, void, string[]>;
+    onAddItems: (items: DatasourceDataResponseItem[], integrationKey: string | undefined) => Action<State, void, string[]>;
 }>>;
 export declare const StoreContainer: ({ children }: {
     children: JSX.Element;
 }) => JSX.Element;
+export {};