@dataggo/node-akeneo-api 1.0.0

package/dist/cjs/error-handler.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const cleanHeaders = (headers) => headers && headers.Authorization
+    ? Object.assign(Object.assign({}, headers), { Authorization: `Bearer ${`...${headers.Authorization.substr(-5)}`}` }) : headers;
+function errorHandler({ config, response }) {
+    const data = response === null || response === void 0 ? void 0 : response.data;
+    const errorData = {
+        status: response === null || response === void 0 ? void 0 : response.status,
+        statusText: response === null || response === void 0 ? void 0 : response.statusText,
+        message: data && 'message' in data ? data.message : '',
+        details: data && 'details' in data ? data.details : {},
+        request: config
+            ? {
+                url: config.url,
+                headers: cleanHeaders(config.headers),
+                method: config.method,
+                payloadData: config.data,
+            }
+            : {},
+    };
+    const error = new Error();
+    error.name = `${response === null || response === void 0 ? void 0 : response.status} ${response === null || response === void 0 ? void 0 : response.statusText}`;
+    try {
+        error.message = JSON.stringify(errorData, null, '  ');
+    }
+    catch (_a) {
+        error.message = ramda_1.path(['message'], errorData) || '';
+    }
+    throw error;
+}
+exports.default = errorHandler;

package/dist/cjs/http-client.d.ts

@@ -0,0 +1,16 @@
+import { AxiosInstance } from 'axios';
+import { AppParams, ClientParams } from './types';
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+export declare const createConnectionHttpClient: (options: ClientParams) => AxiosInstance;
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+export declare const createAppHttpClient: (options: AppParams) => AxiosInstance;

package/dist/cjs/http-client.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppHttpClient = exports.createConnectionHttpClient = void 0;
+/* eslint-disable no-underscore-dangle */
+const qs_1 = __importDefault(require("qs"));
+const axios_1 = __importDefault(require("axios"));
+const TOKEN_PATH = '/api/oauth/v1/token';
+const defaultConfig = {
+    insecure: false,
+    retryOnError: true,
+    headers: {},
+    httpAgent: false,
+    httpsAgent: false,
+    timeout: 30000,
+    proxy: false,
+    basePath: '',
+    adapter: undefined,
+    maxContentLength: 1073741824,
+    paramsSerializer: qs_1.default.stringify,
+};
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+const createConnectionHttpClient = (options) => {
+    let accessToken = '';
+    const { url, clientId, secret, username, password } = options;
+    const baseURL = url.replace(/\/+$/, '');
+    const instance = axios_1.default.create(Object.assign(Object.assign(Object.assign({}, defaultConfig), (options.axiosOptions || {})), { baseURL }));
+    const base64Encoded = Buffer.from(`${clientId}:${secret}`).toString('base64');
+    const refreshAccessToken = () => __awaiter(void 0, void 0, void 0, function* () {
+        const tokenResult = yield axios_1.default.post(`${baseURL}${TOKEN_PATH}`, { grant_type: 'password', username, password }, {
+            headers: {
+                Authorization: `Basic ${base64Encoded}`,
+            },
+        });
+        accessToken = tokenResult.data.access_token;
+        return accessToken;
+    });
+    instance.interceptors.request.use((config) => __awaiter(void 0, void 0, void 0, function* () {
+        return (Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${accessToken || (yield refreshAccessToken())}` }) }));
+    }));
+    instance.interceptors.response.use((response) => response, (error) => __awaiter(void 0, void 0, void 0, function* () {
+        const originalRequest = error.config;
+        if (error.response &&
+            (error.response.status === 403 || error.response.status === 401) &&
+            !originalRequest._retry) {
+            originalRequest._retry = true;
+            accessToken = '';
+            originalRequest.headers.Authorization = `Bearer ${yield refreshAccessToken()}`;
+            return instance(originalRequest);
+        }
+        return Promise.reject(error);
+    }));
+    return instance;
+};
+exports.createConnectionHttpClient = createConnectionHttpClient;
+/**
+ * Create pre-configured axios instance
+ * @private
+ * @param {ClientParams} options - Initialization parameters for the HTTP client
+ * @return {AxiosInstance} Initialized axios instance
+ */
+const createAppHttpClient = (options) => {
+    const { url, accessToken } = options;
+    const baseURL = url.replace(/\/+$/, '');
+    const instance = axios_1.default.create(Object.assign(Object.assign(Object.assign({}, defaultConfig), (options.axiosOptions || {})), { baseURL }));
+    instance.interceptors.request.use((config) => __awaiter(void 0, void 0, void 0, function* () {
+        return (Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config.headers), { Authorization: `Bearer ${accessToken}` }) }));
+    }));
+    return instance;
+};
+exports.createAppHttpClient = createAppHttpClient;

package/dist/cjs/index.d.ts

@@ -0,0 +1,349 @@
+/**
+ * Akeneo Management API SDK. Allows you to create instances of a client
+ * with access to the Akeneo API.
+ */
+import { AxiosInstance } from 'axios';
+import { AppParams, ClientParams } from './types';
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   username: AKENEO_USERNAME,
+ *   password: AKENEO_PASSWORD,
+ *   clientId: AKENEO_CLIENT_ID,
+ *   secret: AKENEO_SECRET,
+ * });
+ * ```
+ */
+export declare const createClient: (params: ClientParams) => {
+    raw: {
+        http: AxiosInstance;
+    };
+    category: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Category<Record<string, any>>>;
+        get: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+        getAll: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+    };
+    productModel: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").ProductModel>;
+        get: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+        getAll: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+    };
+    product: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Product>;
+        get: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+        getAll: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+    };
+    assetFamily: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").AssetFamily>;
+        get: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAll: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAssets: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+        getAsset: (params: {
+            assetFamilyCode: string;
+            code: string;
+        }) => Promise<import("./types").Asset>;
+        getAssetsAll: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+    };
+    assetMediaFile: {
+        /**
+         *
+         * @see https://api.akeneo.com/api-reference.html#get_asset_media_files__code
+         */
+        get: (code: string) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntitiesMediaFile: {
+        /**
+         * @see https://api.akeneo.com/api-reference.html#get_reference_entity_media_files__code
+         */
+        get: (code: string) => Promise<any>;
+    };
+    attribute: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").Attribute>;
+        get: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getAll: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getOptions: (params: {
+            attributeCode: string;
+            query?: import("./types").AttributeOptionQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AttributeOption>>;
+        add: ({ code, attribute }: {
+            code: string;
+            attribute: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        addOption: ({ attributeCode, code, option, }: {
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntity: {
+        get: (params: {
+            query?: import("./types").ReferenceEntityQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Entity>>;
+        getRecords: (params: {
+            referenceEntityCode: string;
+            query?: import("./types").ReferenceEntityRecordQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").EntityRecord>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity__code_
+         */ add: ({ code, body }: {
+            code: string;
+            body: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__code_
+         */
+        addAttribute: ({ referenceEntityCode, code, attribute, }: {
+            referenceEntityCode: string;
+            code: string;
+            attribute: any;
+        }) => Promise<void>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__attribute_code__options__code_
+         */
+        addAttributeOption: ({ referenceEntityCode, attributeCode, code, option, }: {
+            referenceEntityCode: string;
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_records
+         */
+        addRecords: ({ referenceEntityCode, records, }: {
+            referenceEntityCode: string;
+            records: any[];
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    family: {
+        get: (params: {
+            query?: import("./types").FamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Family>>;
+        getVariants: (params: {
+            familyCode: string;
+            query?: import("./types").FamilyVariantQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Variant>>;
+    };
+};
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   accessToken: AKENEO_SECRET,
+ * });
+ * ```
+ */
+export declare const createAppClient: (params: AppParams) => {
+    raw: {
+        http: AxiosInstance;
+    };
+    category: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Category<Record<string, any>>>;
+        get: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+        getAll: (params: {
+            query?: import("./types").CategoryQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Category<Record<string, any>>>>;
+    };
+    productModel: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").ProductModel>;
+        get: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+        getAll: (params: {
+            query?: import("./types").ProductModelQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").ProductModel>>;
+    };
+    product: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").Product>;
+        get: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+        getAll: (params: {
+            query?: import("./types").ProductQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Product>>;
+    };
+    assetFamily: {
+        getOne: (params: {
+            code: string;
+            query?: {
+                with_attribute_options?: boolean | undefined;
+                with_quality_scores?: boolean | undefined;
+            } | undefined;
+        }) => Promise<import("./types").AssetFamily>;
+        get: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAll: (params: {
+            query?: import("./types").AssetFamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AssetFamily>>;
+        getAssets: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+        getAsset: (params: {
+            assetFamilyCode: string;
+            code: string;
+        }) => Promise<import("./types").Asset>;
+        getAssetsAll: (params: {
+            assetFamilyCode: string;
+            query?: import("./types").AssetQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Asset>>;
+    };
+    assetMediaFile: {
+        /**
+         *
+         * @see https://api.akeneo.com/api-reference.html#get_asset_media_files__code
+         */
+        get: (code: string) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntitiesMediaFile: {
+        /**
+         * @see https://api.akeneo.com/api-reference.html#get_reference_entity_media_files__code
+         */
+        get: (code: string) => Promise<any>;
+    };
+    attribute: {
+        getOne: (params: {
+            code: string;
+        }) => Promise<import("./types").Attribute>;
+        get: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getAll: (params: {
+            query?: import("./types").AttributeQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Attribute>>;
+        getOptions: (params: {
+            attributeCode: string;
+            query?: import("./types").AttributeOptionQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").AttributeOption>>;
+        add: ({ code, attribute }: {
+            code: string;
+            attribute: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        addOption: ({ attributeCode, code, option, }: {
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    referenceEntity: {
+        get: (params: {
+            query?: import("./types").ReferenceEntityQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Entity>>;
+        getRecords: (params: {
+            referenceEntityCode: string;
+            query?: import("./types").ReferenceEntityRecordQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").EntityRecord>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity__code_
+         */ add: ({ code, body }: {
+            code: string;
+            body: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__code_
+         */
+        addAttribute: ({ referenceEntityCode, code, attribute, }: {
+            referenceEntityCode: string;
+            code: string;
+            attribute: any;
+        }) => Promise<void>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__attribute_code__options__code_
+         */
+        addAttributeOption: ({ referenceEntityCode, attributeCode, code, option, }: {
+            referenceEntityCode: string;
+            attributeCode: string;
+            code: string;
+            option: any;
+        }) => Promise<import("axios").AxiosResponse<any>>;
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_records
+         */
+        addRecords: ({ referenceEntityCode, records, }: {
+            referenceEntityCode: string;
+            records: any[];
+        }) => Promise<import("axios").AxiosResponse<any>>;
+    };
+    family: {
+        get: (params: {
+            query?: import("./types").FamilyQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Family>>;
+        getVariants: (params: {
+            familyCode: string;
+            query?: import("./types").FamilyVariantQueryParameters | undefined;
+        }) => Promise<import("./types").ListResponse<import("./types").Variant>>;
+    };
+};
+export declare type AkeneoClientAPI = ReturnType<typeof createClient>;
+export * from './types';

package/dist/cjs/index.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Akeneo Management API SDK. Allows you to create instances of a client
+ * with access to the Akeneo API.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppClient = exports.createClient = void 0;
+const http_client_1 = require("./http-client");
+const endpoints = __importStar(require("./endpoints"));
+const ATTRIBUTES_PATH = '/api/rest/v1/attributes';
+const ASSET_MEDIA_FILES = '/api/rest/v1/asset-media-files';
+const REFERENCE_ENTITIES_MEDIA_FILES = '/api/rest/v1/reference-entities-media-files';
+const wrap = (http, fn) => (params) => fn(http, params);
+const getHttpClientWithEndpoint = (http) => ({
+    raw: {
+        http,
+    },
+    category: {
+        getOne: wrap(http, endpoints.category.getOne),
+        get: wrap(http, endpoints.category.get),
+        getAll: wrap(http, endpoints.category.getAll),
+    },
+    productModel: {
+        getOne: wrap(http, endpoints.productModel.getOne),
+        get: wrap(http, endpoints.productModel.get),
+        getAll: wrap(http, endpoints.productModel.getAll),
+    },
+    product: {
+        getOne: wrap(http, endpoints.product.getOne),
+        get: wrap(http, endpoints.product.get),
+        getAll: wrap(http, endpoints.product.getAll),
+    },
+    assetFamily: {
+        getOne: wrap(http, endpoints.assetFamily.getOne),
+        get: wrap(http, endpoints.assetFamily.get),
+        getAll: wrap(http, endpoints.assetFamily.getAll),
+        getAssets: wrap(http, endpoints.assetFamily.getAssets),
+        getAsset: wrap(http, endpoints.assetFamily.getAsset),
+        getAssetsAll: wrap(http, endpoints.assetFamily.getAssetsAll),
+    },
+    assetMediaFile: {
+        /**
+         *
+         * @see https://api.akeneo.com/api-reference.html#get_asset_media_files__code
+         */
+        get: (code) => __awaiter(void 0, void 0, void 0, function* () {
+            return http.get(`${ASSET_MEDIA_FILES}/${code}`, {
+                responseType: 'arraybuffer',
+                params: {},
+            });
+        }),
+    },
+    referenceEntitiesMediaFile: {
+        /**
+         * @see https://api.akeneo.com/api-reference.html#get_reference_entity_media_files__code
+         */
+        get: (code) => __awaiter(void 0, void 0, void 0, function* () {
+            return http.get(`${REFERENCE_ENTITIES_MEDIA_FILES}/${code}`, {
+                responseType: 'arraybuffer',
+                params: {},
+            });
+        }),
+    },
+    attribute: {
+        getOne: wrap(http, endpoints.attribute.getOne),
+        get: wrap(http, endpoints.attribute.get),
+        getAll: wrap(http, endpoints.attribute.getAll),
+        getOptions: wrap(http, endpoints.attribute.getOptions),
+        add: ({ code, attribute }) => __awaiter(void 0, void 0, void 0, function* () { return http.patch(`${ATTRIBUTES_PATH}/${code}`, attribute); }),
+        addOption: ({ attributeCode, code, option, }) => __awaiter(void 0, void 0, void 0, function* () {
+            return http.patch(`${ATTRIBUTES_PATH}/${attributeCode}/options/${code}`, option);
+        }),
+    },
+    referenceEntity: {
+        get: wrap(http, endpoints.referenceEntity.get),
+        getRecords: wrap(http, endpoints.referenceEntity.getRecords),
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity__code_
+         */ add: ({ code, body }) => __awaiter(void 0, void 0, void 0, function* () { return http.patch(`/api/rest/v1/reference-entities/${code}`, body); }),
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__code_
+         */
+        addAttribute: ({ referenceEntityCode, code, attribute, }) => __awaiter(void 0, void 0, void 0, function* () {
+            yield http.patch(`/api/rest/v1/reference-entities/${referenceEntityCode}/attributes/${code}`, attribute);
+        }),
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_attributes__attribute_code__options__code_
+         */
+        addAttributeOption: ({ referenceEntityCode, attributeCode, code, option, }) => http.patch(`/api/rest/v1/reference-entities/${referenceEntityCode}/attributes/${attributeCode}/options/${code}`, option),
+        /**
+         * @see https://api.akeneo.com/api-reference.html#patch_reference_entity_records
+         */
+        addRecords: ({ referenceEntityCode, records, }) => http.patch(`/api/rest/v1/reference-entities/${referenceEntityCode}/records`, records),
+    },
+    family: {
+        get: wrap(http, endpoints.family.get),
+        getVariants: wrap(http, endpoints.family.getVariants),
+    },
+});
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   username: AKENEO_USERNAME,
+ *   password: AKENEO_PASSWORD,
+ *   clientId: AKENEO_CLIENT_ID,
+ *   secret: AKENEO_SECRET,
+ * });
+ * ```
+ */
+const createClient = (params) => {
+    const http = http_client_1.createConnectionHttpClient(params);
+    return getHttpClientWithEndpoint(http);
+};
+exports.createClient = createClient;
+/**
+ * Create a client instance
+ * @param params - Client initialization parameters
+ *
+ * ```javascript
+ * const client = akeneo({
+ *   url: AKENEO_API_URL,
+ *   accessToken: AKENEO_SECRET,
+ * });
+ * ```
+ */
+const createAppClient = (params) => {
+    const http = http_client_1.createAppHttpClient(params);
+    return getHttpClientWithEndpoint(http);
+};
+exports.createAppClient = createAppClient;
+__exportStar(require("./types"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}