@nlabs/reaktor 0.4.0 → 0.4.1

package/lib/actions/groups.js

@@ -0,0 +1,282 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  addGroup: () => addGroup,
+  createGroupEdge: () => createGroupEdge,
+  deleteGroup: () => deleteGroup,
+  getGroup: () => getGroup,
+  getGroupDetails: () => getGroupDetails,
+  getGroupList: () => getGroupList,
+  getGroupListByTags: () => getGroupListByTags,
+  getGroupListByUser: () => getGroupListByUser,
+  getGroupsByReaction: () => getGroupsByReaction,
+  isGrouped: () => isGrouped,
+  updateGroup: () => updateGroup
+});
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_flatten = __toModule(require("lodash/flatten"));
+var import_uniqBy = __toModule(require("lodash/uniqBy"));
+var import_utils2 = __toModule(require("../utils"));
+var import_tags = __toModule(require("./tags"));
+const eventCategory = "groups";
+const getGroupList = (context, from, to) => {
+  const action = "getListByApp";
+  const { database } = context;
+  const limit = (0, import_utils2.getLimit)(from, to);
+  const aqlQry = `FOR g in groups
+      LET users = (
+        FOR u, l IN OUTBOUND g._id isGrouped
+        RETURN MERGE (u, {type:l.type})
+      )
+      ${limit.aql}
+      SORT g.added
+      RETURN DISTINCT MERGE(g, {users:users})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getGroupListByUser = (context, from, to) => {
+  const { database, session: { userId: sessionId } } = context;
+  const limit = (0, import_utils2.getLimit)(from, to);
+  const aqlQry = `FOR g, e IN INBOUND "${`users/${sessionId}`}" isGrouped
+      LET users = (
+        FOR u, l IN OUTBOUND g._id isGrouped
+        RETURN MERGE (u, {type:l.type})
+      )
+      ${limit.aql}
+      SORT g.added
+      RETURN DISTINCT MERGE(g, {users:users})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => {
+    throw error;
+  });
+};
+const getGroupListByTags = (context, tags, from, to) => {
+  const action = "getListByTags";
+  const { database } = context;
+  return Promise.all((tags || []).map((tagName) => {
+    const formatTagName = (0, import_utils.parseId)(tagName);
+    const limit = (0, import_utils2.getLimit)(from, to);
+    const aqlQry = `FOR p, e IN OUTBOUND "${`tags/${formatTagName}`}" isTagged
+          FOR u IN users
+          LET likes = (
+            FOR post, like IN INBOUND p._id likes
+            FILTER like.value == 'like'
+            RETURN like
+          )
+          LET dislikes = (
+            FOR post, like IN INBOUND p._id likes
+            FILTER like.value == 'dislike'
+            RETURN like
+          )
+          FILTER e.type == 'post' && p.userId == u._key
+          ${limit.aql}
+          SORT p.added
+          RETURN DISTINCT MERGE(p, {user:u, likes:LENGTH(likes), dislikes:LENGTH(dislikes)})`;
+    return database.query(aqlQry).then((cursor) => cursor.all());
+  })).then((results) => (0, import_uniqBy.default)((0, import_flatten.default)(results), "_key")).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getGroup = (context, itemId) => {
+  const action = "getItem";
+  const { database, session: { userId: sessionId } } = context;
+  const formatItemId = (0, import_utils.parseId)(itemId);
+  const aqlQry = import_arangojs.aql`FOR g, e IN INBOUND ${`users/${sessionId}`} isGrouped
+      FILTER g._key == ${formatItemId}
+      LET users = (
+        FOR u, l IN OUTBOUND g._id isGrouped
+        RETURN MERGE (u, {type:l.type})
+      )
+      LIMIT 1
+      RETURN DISTINCT MERGE(g, {users:users})`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((group = {}) => group).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getGroupDetails = (context, groupId) => {
+  const action = "getDetails";
+  const { database } = context;
+  const formatGroupId = (0, import_utils.parseId)(groupId);
+  const aqlQry = import_arangojs.aql`FOR g IN groups
+      FILTER g._key == ${formatGroupId}
+      LIMIT 1
+      RETURN g`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((group = {}) => group).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const createGroupEdge = (database, userId, groupId) => {
+  const action = "createGroupEdge";
+  const formatUserId = (0, import_utils.parseArangoId)(userId);
+  const formatGroupId = (0, import_utils.parseArangoId)(groupId);
+  const now = Date.now();
+  const edgeCollection = database.collection("isGrouped");
+  const edgeId = (0, import_utils.createHash)(`group-${formatUserId}-${formatGroupId}`);
+  const edge = {
+    _from: formatUserId,
+    _key: edgeId,
+    _to: formatGroupId,
+    added: now,
+    type: "groups"
+  };
+  return edgeCollection.save(edge, { returnNew: true }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, { id: formatUserId }).then(() => null));
+};
+const addGroup = (context, item = {}) => {
+  const action = "add";
+  const { database, session: { userId: sessionId } } = context;
+  const now = Date.now();
+  const {
+    description = "",
+    name = "Untitled",
+    type
+  } = item;
+  const id = (0, import_utils.createHash)(`group-${sessionId}`);
+  const formatDesc = description.substr(0, 640);
+  const formatType = (0, import_utils.parseChar)(type, 16) || "private";
+  const insert = {
+    _key: id,
+    added: now,
+    description: formatDesc,
+    modified: now,
+    name,
+    type: formatType
+  };
+  const db = database;
+  const aqlQry = import_arangojs.aql`INSERT ${insert} IN groups RETURN NEW`;
+  return db.query(aqlQry).then((cursor) => cursor.next()).then((group = {}) => {
+    const { _id: groupDocId } = group;
+    return (0, import_tags.extractTags)(db, groupDocId, formatDesc).then(() => createGroupEdge(database, sessionId, groupDocId).then(() => group));
+  }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const updateGroup = (context, item = {}) => {
+  const action = "update";
+  const { database } = context;
+  const {
+    description = "",
+    id,
+    name = "Untitled"
+  } = item;
+  const itemId = (0, import_utils.parseId)(id);
+  const now = Date.now();
+  const formatDesc = description.substr(0, 640);
+  const update = {
+    description: formatDesc,
+    modified: now,
+    name
+  };
+  const db = database;
+  const aqlQry = import_arangojs.aql`UPDATE ${itemId} WITH ${update} IN groups RETURN NEW`;
+  return db.query(aqlQry).then((cursor) => cursor.next()).then((group = {}) => {
+    const { _id: groupDocId } = group;
+    return (0, import_tags.extractTags)(db, groupDocId, description).then(() => group);
+  }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const deleteGroup = (context, itemId) => {
+  const action = "delete";
+  const { database } = context;
+  const formatItemId = (0, import_utils.parseId)(itemId);
+  const aqlQry = import_arangojs.aql`FOR g IN groups
+      FILTER g._key == ${formatItemId}
+      REMOVE g IN groups
+      RETURN OLD`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((group = {}) => group).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getGroupsByReaction = (context, reaction) => {
+  const action = "getGroupsByReaction";
+  const { database, session: { userId: sessionId } } = context;
+  const formatReaction = (0, import_utils.parseChar)(reaction, 32);
+  const userDocId = `users/${sessionId}`;
+  const aqlQry = import_arangojs.aql`FOR u, r IN OUTBOUND ${userDocId} hasReaction
+      FILTER r.value == ${formatReaction}
+      COLLECT reactionName = r.value INTO reactionItems
+      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const isGrouped = (database, userId, groupId) => {
+  const action = "isGrouped";
+  const formatUserId = (0, import_utils.parseId)(userId);
+  const formatGroupId = (0, import_utils.parseId)(groupId);
+  const aqlQry = import_arangojs.aql`FOR g IN groups
+    FILTER g._key == ${formatGroupId}
+    FOR u IN INBOUND g._id isGrouped
+    FILTER u._key == ${formatUserId}
+    LIMIT 1
+    RETURN u`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).then((results = []) => {
+    const isValid = !!results.length;
+    return {
+      groupId,
+      isValid,
+      userId
+    };
+  }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, { id: userId }).then(() => null));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addGroup,
+  createGroupEdge,
+  deleteGroup,
+  getGroup,
+  getGroupDetails,
+  getGroupList,
+  getGroupListByTags,
+  getGroupListByUser,
+  getGroupsByReaction,
+  isGrouped,
+  updateGroup
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/groups.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseArangoId, parseChar, parseId} from '@nlabs/utils';\nimport {aql, Database} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport flatten from 'lodash/flatten';\nimport uniqBy from 'lodash/uniqBy';\n\nimport {ArangoDBLimit} from '../types/arangodb';\nimport {ApiContext} from '../types/auth';\nimport {GroupEdgeType, GroupType, GroupUser} from '../types/groups';\nimport {getLimit, logError} from '../utils';\nimport {extractTags} from './tags';\n\nconst eventCategory: string = 'groups';\n\nexport const getGroupList = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {\n  const action: string = 'getListByApp';\n  const {database} = context;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const aqlQry: string = `FOR g in groups\n      LET users = (\n        FOR u, l IN OUTBOUND g._id isGrouped\n        RETURN MERGE (u, {type:l.type})\n      )\n      ${limit.aql}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getGroupListByUser = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {\n  // const action: string = 'getListByUser';\n  const {database, session: {userId: sessionId}} = context;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const aqlQry: string = `FOR g, e IN INBOUND \"${`users/${sessionId}`}\" isGrouped\n      LET users = (\n        FOR u, l IN OUTBOUND g._id isGrouped\n        RETURN MERGE (u, {type:l.type})\n      )\n      ${limit.aql}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getGroupListByTags = (\n  context: ApiContext,\n  tags: string[],\n  from: number,\n  to: number\n): Promise<GroupType[]> => {\n  const action: string = 'getListByTags';\n  const {database} = context;\n\n  return Promise.all(\n    (tags || []).map((tagName: string) => {\n      const formatTagName: string = parseId(tagName);\n      const limit: ArangoDBLimit = getLimit(from, to);\n      const aqlQry: string = `FOR p, e IN OUTBOUND \"${`tags/${formatTagName}`}\" isTagged\n          FOR u IN users\n          LET likes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'like'\n            RETURN like\n          )\n          LET dislikes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'dislike'\n            RETURN like\n          )\n          FILTER e.type == 'post' && p.userId == u._key\n          ${limit.aql}\n          SORT p.added\n          RETURN DISTINCT MERGE(p, {user:u, likes:LENGTH(likes), dislikes:LENGTH(dislikes)})`;\n\n      return database.query(aqlQry).then((cursor: ArrayCursor) => cursor.all());\n    })\n  )\n    .then((results) => uniqBy(flatten(results), '_key'))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action: string = 'getItem';\n  const {database, session: {userId: sessionId}} = context;\n  const formatItemId: string = parseId(itemId);\n\n  const aqlQry: AqlQuery = aql`FOR g, e IN INBOUND ${`users/${sessionId}`} isGrouped\n      FILTER g._key == ${formatItemId}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id isGrouped\n        RETURN MERGE (u, {type:l.type})\n      )\n      LIMIT 1\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((group: GroupType = {}) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getGroupDetails = (context: ApiContext, groupId: string): Promise<GroupType> => {\n  const action: string = 'getDetails';\n  const {database} = context;\n  const formatGroupId: string = parseId(groupId);\n  const aqlQry: AqlQuery = aql`FOR g IN groups\n      FILTER g._key == ${formatGroupId}\n      LIMIT 1\n      RETURN g`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((group: GroupType = {}) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const createGroupEdge = (\n  database: Database,\n  userId: string,\n  groupId: string,\n): Promise<GroupEdgeType> => {\n  const action: string = 'createGroupEdge';\n  const formatUserId: string = parseArangoId(userId);\n  const formatGroupId: string = parseArangoId(groupId);\n\n  const now: number = Date.now();\n  const edgeCollection: EdgeCollection = database.collection('isGrouped');\n  const edgeId: string = createHash(`group-${formatUserId}-${formatGroupId}`);\n\n  const edge: any = {\n    _from: formatUserId,\n    _key: edgeId,\n    _to: formatGroupId,\n    added: now,\n    type: 'groups'\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {id: formatUserId}).then(() => null));\n};\n\nexport const addGroup = (context: ApiContext, item: GroupType = {}): Promise<GroupType> => {\n  const action: string = 'add';\n  const {database, session: {userId: sessionId}} = context;\n  const now: number = Date.now();\n  const {\n    description = '',\n    name = 'Untitled',\n    type\n  }: GroupType = item;\n  const id: string = createHash(`group-${sessionId}`);\n  const formatDesc: string = description.substr(0, 640);\n  const formatType: string = parseChar(type, 16) || 'private';\n  const insert: GroupType = {\n    _key: id,\n    added: now,\n    description: formatDesc,\n    modified: now,\n    name,\n    type: formatType\n  };\n  const db: Database = database;\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN groups RETURN NEW`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((group: GroupType = {}) => {\n      // Update linked tags\n      const {_id: groupDocId}: GroupType = group;\n      return extractTags(db, groupDocId, formatDesc)\n        .then(() => createGroupEdge(database, sessionId, groupDocId).then(() => group));\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const updateGroup = (context: ApiContext, item: GroupType = {}): Promise<GroupType> => {\n  const action: string = 'update';\n  const {database} = context;\n  const {\n    description = '',\n    id,\n    name = 'Untitled'\n  }: GroupType = item;\n  const itemId: string = parseId(id);\n  const now: number = Date.now();\n  const formatDesc: string = description.substr(0, 640);\n  const update: any = {\n    description: formatDesc,\n    modified: now,\n    name\n  };\n  const db: Database = database;\n  const aqlQry: AqlQuery = aql`UPDATE ${itemId} WITH ${update} IN groups RETURN NEW`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((group: GroupType = {}) => {\n      const {_id: groupDocId} = group;\n\n      // Update linked tags\n      return extractTags(db, groupDocId, description).then(() => group);\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const deleteGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action: string = 'delete';\n  const {database} = context;\n  const formatItemId: string = parseId(itemId);\n  const aqlQry: AqlQuery = aql`FOR g IN groups\n      FILTER g._key == ${formatItemId}\n      REMOVE g IN groups\n      RETURN OLD`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((group: GroupType = {}) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getGroupsByReaction = (context: ApiContext, reaction: string): Promise<GroupType[]> => {\n  const action: string = 'getGroupsByReaction';\n  const {database, session: {userId: sessionId}} = context;\n  const formatReaction: string = parseChar(reaction, 32);\n  const userDocId: string = `users/${sessionId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR u, r IN OUTBOUND ${userDocId} hasReaction\n      FILTER r.value == ${formatReaction}\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const isGrouped = (database: Database, userId: string, groupId: string): Promise<GroupUser> => {\n  const action: string = 'isGrouped';\n  const formatUserId: string = parseId(userId);\n  const formatGroupId: string = parseId(groupId);\n  const aqlQry: AqlQuery = aql`FOR g IN groups\n    FILTER g._key == ${formatGroupId}\n    FOR u IN INBOUND g._id isGrouped\n    FILTER u._key == ${formatUserId}\n    LIMIT 1\n    RETURN u`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .then((results = []) => {\n      const isValid = !!results.length;\n\n      return {\n        groupId,\n        isValid,\n        userId\n      };\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {id: userId}).then(() => null));\n};\n"],
  "mappings": "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",
  "names": []
}


package/lib/actions/images.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { PutObjectRequest } from 'aws-sdk/clients/s3';
+import { ApiContext, ArangoDBLimit, ImageEdgeType, ImageOptions, ImageType, ImageUrlData } from '../types';
+export declare const parseImageOptions: (options?: ImageOptions) => {
+    limit: ArangoDBLimit;
+    type: string;
+};
+export declare const getImageOptional: (fields?: string[]) => any;
+export declare const getImagesByUser: (context: ApiContext, userId: string, from: number, to: number) => Promise<ImageType[]>;
+export declare const getImageCountByItem: (context: ApiContext, itemId: string) => Promise<number>;
+export declare const getImagesByItem: (context: ApiContext, itemId: string, options?: ImageOptions) => Promise<ImageType[]>;
+export declare const getImagesByGroup: (context: ApiContext, params: any) => Promise<ImageType[]>;
+export declare const getImagesByReactions: (context: ApiContext, reactions?: string[], options?: ImageOptions) => Promise<ImageType[]>;
+export declare const getImage: (context: ApiContext, id: string) => Promise<ImageType>;
+export declare const getPathUserImages: (userId: string, imageId: string, type: string, dir?: string) => string;
+export declare const getAppImageUrl: (data: ImageUrlData) => string;
+export declare const getUserImageUrl: (data: ImageUrlData) => string;
+export declare const resizeSaveImage: (context: ApiContext, imageId: string, buffer: Buffer, type?: string, s3Options?: PutObjectRequest) => Promise<ImageType>;
+export declare const addImage: (context: ApiContext, image: ImageType, s3Options?: PutObjectRequest) => Promise<ImageType>;
+export declare const addImageEdge: (context: ApiContext, imageEdge: ImageEdgeType) => Promise<object>;
+export declare const updateImage: (context: ApiContext, image: ImageType, s3Options?: PutObjectRequest) => Promise<ImageType>;
+export declare const deleteImage: (context: ApiContext, imageId: string) => Promise<ImageType>;