@maioradv/cms-basic-lib 1.0.0

package/dist/languages/graphql.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguagesResolvers = void 0;
+exports.LanguagesResolvers = {
+    query: {
+        languages: {
+            name: 'languages',
+            query: `query LanguageList($limit: Int, $after: Int, $before: Int){
+        languages(limit: $limit, after: $after, before: $before){
+          edges {
+            node {
+              id
+            }
+            cursor
+          }
+          nodes {
+            id
+            name
+            active
+            iso
+            locale
+            published
+            translations {
+              key
+              locale
+              value
+            }
+            createdAt
+            updatedAt
+          }
+          meta {
+            startCursor
+            endCursor
+            hasNextPage
+            hasPreviousPage
+          }
+        }
+      }`,
+        },
+    },
+    mutation: {
+        removeLanguages: {
+            name: 'removeLanguages',
+            query: `mutation LanguageDelete($id: [Int!]!){
+        removeLanguages(id: $id) {
+          count
+        }
+      }`,
+        },
+    }
+};

package/dist/languages/index.d.ts

@@ -0,0 +1,14 @@
+import { PaginatedDto, PaginatedGQL } from "../core/dto/pagination";
+import { RemoveGQL } from "../core/model/remove-gql.response";
+import { RestApiModuleI, ApiModule, GraphApiModuleI } from "../model";
+import { QueryLanguageGQLDto } from "./graphql";
+import { CreateLanguageDto, Language, QueryLanguageDto, UpdateLanguageDto } from "./types";
+export default class Languages extends ApiModule implements RestApiModuleI, GraphApiModuleI {
+    create(args: CreateLanguageDto): Promise<Language>;
+    findAll(args?: QueryLanguageDto): Promise<PaginatedDto<Language>>;
+    findOne(id: number): Promise<Language>;
+    update(id: number, data: UpdateLanguageDto): Promise<Language>;
+    remove(id: number): Promise<Language>;
+    list(args?: QueryLanguageGQLDto): Promise<PaginatedGQL<Language>>;
+    removeMany(id: number | number[]): Promise<RemoveGQL>;
+}

package/dist/languages/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const queryParams_1 = require("../core/utils/queryParams");
+const model_1 = require("../model");
+const graphql_1 = require("./graphql");
+class Languages extends model_1.ApiModule {
+    create(args) {
+        return this._call('post', '/languages', args);
+    }
+    findAll(args = {}) {
+        return this._call('get', '/languages', (0, queryParams_1.queryParams)(args));
+    }
+    findOne(id) {
+        return this._call('get', `/languages/${id}`);
+    }
+    update(id, data) {
+        return this._call('patch', `/languages/${id}`, data);
+    }
+    remove(id) {
+        return this._call('delete', `/languages/${id}`);
+    }
+    list(args = {}) {
+        return this._graphql(graphql_1.LanguagesResolvers.query.languages, args);
+    }
+    removeMany(id) {
+        return this._graphql(graphql_1.LanguagesResolvers.mutation.removeLanguages, {
+            id
+        });
+    }
+}
+exports.default = Languages;

package/dist/languages/types.d.ts

@@ -0,0 +1,29 @@
+import { BooleanClause, StringClause, WhereClausesDto } from "../core/dto/clauses";
+import { Sorting, SortingParamsDto } from "../core/dto/sorting";
+import { QueryParamsDto } from "../core/utils/queryParams";
+import { OmitRequire, Translation } from "../types";
+export type Language = {
+    id: number;
+    name: string;
+    active: boolean;
+    iso: string;
+    locale: string;
+    published: boolean;
+    translations: Translation[];
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type CreateLanguageDto = OmitRequire<Language, 'id' | 'createdAt' | 'updatedAt', 'name' | 'iso' | 'locale'>;
+export type UpdateLanguageDto = Partial<CreateLanguageDto>;
+export type SortingLanguageDto = SortingParamsDto<{
+    name?: Sorting;
+    active?: Sorting;
+    published?: Sorting;
+}>;
+export type ClausesLanguageDto = WhereClausesDto<{
+    name?: StringClause;
+    locale?: StringClause;
+    active?: BooleanClause;
+    published?: BooleanClause;
+}>;
+export type QueryLanguageDto = QueryParamsDto<SortingLanguageDto, ClausesLanguageDto>;

package/dist/languages/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/model.d.ts

@@ -0,0 +1,25 @@
+import { Axios, AxiosRequestConfig } from "axios";
+import { ResolverDef } from "./core/types/resolver";
+import { AccessTokenDto } from "./auth/types";
+export declare class ApiModule {
+    private client;
+    constructor(client: Axios);
+    protected _call<Res, Req = Record<string, any>>(method: CallMethod, path: string, data?: Req, opts?: AxiosRequestConfig): Promise<Res>;
+    protected _graphql<Res, Req = Record<string, any>>(resolver: ResolverDef<string>, variables?: Req): Promise<Res>;
+}
+export interface ClientApiI {
+    auth: () => Promise<AccessTokenDto>;
+}
+export interface RestApiModuleI {
+    create: (args: unknown) => Promise<unknown>;
+    findAll: (args?: unknown) => Promise<unknown>;
+    findOne: (id: number, args?: unknown) => Promise<unknown>;
+    update: (id: number, args: unknown) => Promise<unknown>;
+    remove: (id: number) => Promise<unknown>;
+}
+export interface GraphApiModuleI {
+    list: (args: unknown) => Promise<unknown>;
+    removeMany: (id: number | number[]) => Promise<unknown>;
+}
+type CallMethod = 'get' | 'post' | 'patch' | 'delete';
+export {};

package/dist/model.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiModule = void 0;
+const error_1 = require("./error");
+class ApiModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async _call(method, path, data, opts) {
+        try {
+            const response = await this.client.request({
+                method: method,
+                url: path,
+                data: method !== 'get' ? data !== null && data !== void 0 ? data : undefined : undefined,
+                params: method === 'get' ? data !== null && data !== void 0 ? data : undefined : undefined,
+                ...opts
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new error_1.RestApiError(error);
+        }
+    }
+    async _graphql(resolver, variables) {
+        try {
+            const response = await this.client.request({
+                method: 'post',
+                url: '/graphql',
+                data: {
+                    query: resolver.query,
+                    variables
+                },
+            });
+            if (response.data.errors)
+                throw new Error(response.data.errors.map(e => e.message).join(', '));
+            return response.data.data[resolver.name];
+        }
+        catch (error) {
+            throw new error_1.GraphApiError(error);
+        }
+    }
+}
+exports.ApiModule = ApiModule;

package/dist/popups/graphql.d.ts

@@ -0,0 +1,4 @@
+import { PaginatedGQLQueryDto } from "../core/dto/pagination";
+import { Resolvers } from "../core/types/resolver";
+export declare const PopupsResolvers: Resolvers<['popups'], ['removePopups']>;
+export type QueryPopupGQLDto = PaginatedGQLQueryDto;

package/dist/popups/graphql.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopupsResolvers = void 0;
+exports.PopupsResolvers = {
+    query: {
+        popups: {
+            name: 'popups',
+            query: `query PopupList($limit: Int, $after: Int, $before: Int){
+        popups(limit: $limit, after: $after, before: $before){
+          edges {
+            node {
+              id
+            }
+            cursor
+          }
+          nodes {
+            id
+            name
+            modal
+            target
+            published
+            translations {
+              key
+              locale
+              value
+            }
+            metafields {
+              key 
+              value
+            }
+            createdAt
+            updatedAt
+          }
+          meta {
+            startCursor
+            endCursor
+            hasNextPage
+            hasPreviousPage
+          }
+        }
+      }`,
+        },
+    },
+    mutation: {
+        removePopups: {
+            name: 'removePopups',
+            query: `mutation PopupDelete($id: [Int!]!){
+        removePopups(id: $id) {
+          count
+        }
+      }`,
+        },
+    }
+};

package/dist/popups/index.d.ts

@@ -0,0 +1,22 @@
+import { PaginatedDto, PaginatedGQL } from "../core/dto/pagination";
+import { RemoveGQL } from "../core/model/remove-gql.response";
+import { Image } from "../images/types";
+import { RestApiModuleI, ApiModule, GraphApiModuleI } from "../model";
+import { WithRelation } from "../types";
+import { QueryPopupGQLDto } from "./graphql";
+import { CreatePopupDto, CreatePopupImageDto, CreatePopupTriggerDto, FindOnePopupDto, Popup, PopupImage, PopupTrigger, QueryPopupDto, UpdatePopupDto, UpdatePopupImageDto } from "./types";
+export default class Popups extends ApiModule implements RestApiModuleI, GraphApiModuleI {
+    create(args: CreatePopupDto): Promise<Popup>;
+    findAll(args?: QueryPopupDto): Promise<PaginatedDto<Popup>>;
+    findOne(id: number): Promise<FindOnePopupDto>;
+    update(id: number, data: UpdatePopupDto): Promise<Popup>;
+    remove(id: number): Promise<Popup>;
+    list(args?: QueryPopupGQLDto): Promise<PaginatedGQL<Popup>>;
+    removeMany(id: number | number[]): Promise<RemoveGQL>;
+    createImage(popupId: number, args: CreatePopupImageDto): Promise<PopupImage>;
+    findAllImages(popupId: number): Promise<WithRelation<PopupImage, 'Image', Image>[]>;
+    updateImage(popupId: number, imageId: number, data: UpdatePopupImageDto): Promise<PopupImage>;
+    removeImage(popupId: number, imageId: number): Promise<PopupImage>;
+    createTrigger(popupId: number, args: CreatePopupTriggerDto): Promise<PopupTrigger>;
+    findAllTriggers(popupId: number): Promise<PopupTrigger[]>;
+}

package/dist/popups/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const queryParams_1 = require("../core/utils/queryParams");
+const model_1 = require("../model");
+const graphql_1 = require("./graphql");
+class Popups extends model_1.ApiModule {
+    create(args) {
+        return this._call('post', '/popups', args);
+    }
+    findAll(args = {}) {
+        return this._call('get', '/popups', (0, queryParams_1.queryParams)(args));
+    }
+    findOne(id) {
+        return this._call('get', `/popups/${id}`);
+    }
+    update(id, data) {
+        return this._call('patch', `/popups/${id}`, data);
+    }
+    remove(id) {
+        return this._call('delete', `/popups/${id}`);
+    }
+    list(args = {}) {
+        return this._graphql(graphql_1.PopupsResolvers.query.popups, args);
+    }
+    removeMany(id) {
+        return this._graphql(graphql_1.PopupsResolvers.mutation.removePopups, {
+            id
+        });
+    }
+    createImage(popupId, args) {
+        return this._call('post', `/popups/${popupId}/images`, args, {
+            headers: {
+                'Content-Type': 'multipart/form-data'
+            }
+        });
+    }
+    findAllImages(popupId) {
+        return this._call('get', `/popups/${popupId}/images`);
+    }
+    updateImage(popupId, imageId, data) {
+        return this._call('patch', `/popups/${popupId}/images/${imageId}`, data);
+    }
+    removeImage(popupId, imageId) {
+        return this._call('delete', `/popups/${popupId}/images/${imageId}`);
+    }
+    createTrigger(popupId, args) {
+        return this._call('post', `/popups/${popupId}/triggers`, args);
+    }
+    findAllTriggers(popupId) {
+        return this._call('get', `/popups/${popupId}/triggers`);
+    }
+}
+exports.default = Popups;

package/dist/popups/triggers.d.ts

@@ -0,0 +1,6 @@
+import { ApiModule } from "../model";
+import { PopupTrigger, UpdatePopupTriggerDto } from "./types";
+export default class PopupTriggers extends ApiModule {
+    update(id: number, data: UpdatePopupTriggerDto): Promise<PopupTrigger>;
+    remove(id: number): Promise<PopupTrigger>;
+}

package/dist/popups/triggers.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = require("../model");
+class PopupTriggers extends model_1.ApiModule {
+    update(id, data) {
+        return this._call('patch', `/popup-triggers/${id}`, data);
+    }
+    remove(id) {
+        return this._call('delete', `/popup-triggers/${id}`);
+    }
+}
+exports.default = PopupTriggers;

package/dist/popups/types.d.ts

@@ -0,0 +1,67 @@
+import { BooleanClause, StringClause, WhereClausesDto } from "../core/dto/clauses";
+import { Sorting, SortingParamsDto } from "../core/dto/sorting";
+import { QueryParamsDto } from "../core/utils/queryParams";
+import { CreateImageDto, Image } from "../images/types";
+import { Metafield, OmitRequire, Translation, WithRelation } from "../types";
+export declare enum PopupTarget {
+    menu = "menu",
+    menuDetail = "menuDetail",
+    collectionDetail = "collectionDetail"
+}
+export declare enum PopupModal {
+    image = "image",
+    text = "text"
+}
+export declare enum PopupTriggerRule {
+    eventName = "eventName",
+    timeoutDelay = "timeoutDelay",
+    maxViewsNumber = "maxViewsNumber",
+    elementDetailId = "elementDetailId"
+}
+export type Popup = {
+    id: number;
+    name: string;
+    target: PopupTarget;
+    modal: PopupModal;
+    translations: Translation[];
+    metafields: Metafield[];
+    published: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type PopupImage = {
+    popupId: number;
+    imageId: number;
+    locale: string | null;
+    position: number | null;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type PopupTrigger = {
+    id: number;
+    name: string;
+    rule: PopupTriggerRule;
+    value: string;
+    popupId: number;
+    published: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type CreatePopupDto = OmitRequire<Popup, 'id' | 'createdAt' | 'updatedAt', 'name' | 'target' | 'modal'> & {
+    triggers?: CreatePopupTriggerDto[];
+};
+export type UpdatePopupDto = Partial<Omit<CreatePopupDto, 'triggers'>>;
+export type CreatePopupImageDto = OmitRequire<PopupImage, 'popupId' | 'createdAt' | 'updatedAt' | 'imageId'> & CreateImageDto;
+export type UpdatePopupImageDto = Omit<CreatePopupImageDto, 'file'>;
+export type CreatePopupTriggerDto = OmitRequire<PopupTrigger, 'id' | 'createdAt' | 'updatedAt' | 'popupId', 'name' | 'rule' | 'value'>;
+export type UpdatePopupTriggerDto = Partial<CreatePopupTriggerDto>;
+export type FindOnePopupDto = WithRelation<Popup, 'PopupTrigger', WithRelation<PopupTrigger, 'PopupImage', WithRelation<PopupImage, 'Image', Image>[]>[]>;
+export type SortingPopupDto = SortingParamsDto<{
+    name?: Sorting;
+    published?: Sorting;
+}>;
+export type ClausesPopupDto = WhereClausesDto<{
+    name?: StringClause;
+    published?: BooleanClause;
+}>;
+export type QueryPopupDto = QueryParamsDto<SortingPopupDto, ClausesPopupDto>;

package/dist/popups/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopupTriggerRule = exports.PopupModal = exports.PopupTarget = void 0;
+var PopupTarget;
+(function (PopupTarget) {
+    PopupTarget["menu"] = "menu";
+    PopupTarget["menuDetail"] = "menuDetail";
+    PopupTarget["collectionDetail"] = "collectionDetail";
+})(PopupTarget || (exports.PopupTarget = PopupTarget = {}));
+var PopupModal;
+(function (PopupModal) {
+    PopupModal["image"] = "image";
+    PopupModal["text"] = "text";
+})(PopupModal || (exports.PopupModal = PopupModal = {}));
+var PopupTriggerRule;
+(function (PopupTriggerRule) {
+    PopupTriggerRule["eventName"] = "eventName";
+    PopupTriggerRule["timeoutDelay"] = "timeoutDelay";
+    PopupTriggerRule["maxViewsNumber"] = "maxViewsNumber";
+    PopupTriggerRule["elementDetailId"] = "elementDetailId";
+})(PopupTriggerRule || (exports.PopupTriggerRule = PopupTriggerRule = {}));

package/dist/productAttributes/graphql.d.ts

@@ -0,0 +1,6 @@
+import { PaginatedGQLQueryDto } from "../core/dto/pagination";
+import { Resolvers } from "../core/types/resolver";
+export declare const ProductAttributesResolvers: Resolvers<['productAttributes'], ['removeProductAttributes']>;
+export type QueryProductAttributeGQLDto = PaginatedGQLQueryDto;
+export declare const ProductAttributeValuesResolvers: Resolvers<['productAttributeValues'], ['removeProductAttributeValues']>;
+export type QueryProductAttributeValueGQLDto = PaginatedGQLQueryDto;

package/dist/productAttributes/graphql.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductAttributeValuesResolvers = exports.ProductAttributesResolvers = void 0;
+exports.ProductAttributesResolvers = {
+    query: {
+        productAttributes: {
+            name: 'productAttributes',
+            query: `query ProductAttributeList($limit: Int, $after: Int, $before: Int){
+        productAttributes(limit: $limit, after: $after, before: $before){
+          edges {
+            node {
+              id
+            }
+            cursor
+          }
+          nodes {
+            id
+            name
+            slug
+            translations {
+              key
+              locale
+              value
+            }
+            metafields {
+              key 
+              value
+            }
+            published
+            createdAt
+            updatedAt
+          }
+          meta {
+            startCursor
+            endCursor
+            hasNextPage
+            hasPreviousPage
+          }
+        }
+      }`,
+        },
+    },
+    mutation: {
+        removeProductAttributes: {
+            name: 'removeProductAttributes',
+            query: `mutation ProductAttributeDelete($id: [Int!]!){
+        removeProductAttributes(id: $id) {
+          count
+        }
+      }`,
+        },
+    }
+};
+exports.ProductAttributeValuesResolvers = {
+    query: {
+        productAttributeValues: {
+            name: 'productAttributeValues',
+            query: `query ProductAttributeValueList($limit: Int, $after: Int, $before: Int){
+        productAttributeValues(limit: $limit, after: $after, before: $before){
+          edges {
+            node {
+              id
+            }
+            cursor
+          }
+          nodes {
+            id
+            name
+            productAttributeId
+            translations {
+              key
+              locale
+              value
+            }
+            metafields {
+              key 
+              value
+            }
+            published
+            createdAt
+            updatedAt
+          }
+          meta {
+            startCursor
+            endCursor
+            hasNextPage
+            hasPreviousPage
+          }
+        }
+      }`,
+        },
+    },
+    mutation: {
+        removeProductAttributeValues: {
+            name: 'removeProductAttributeValues',
+            query: `mutation ProductAttributeValueDelete($id: [Int!]!){
+        removeProductAttributeValues(id: $id) {
+          count
+        }
+      }`,
+        },
+    }
+};

package/dist/productAttributes/index.d.ts

@@ -0,0 +1,16 @@
+import { PaginatedDto, PaginatedGQL } from "../core/dto/pagination";
+import { RemoveGQL } from "../core/model/remove-gql.response";
+import { RestApiModuleI, ApiModule, GraphApiModuleI } from "../model";
+import { QueryProductAttributeGQLDto } from "./graphql";
+import { CreateProductAttributeDto, CreateProductAttributeValueDto, ProductAttribute, ProductAttributeValue, QueryProductAttributeDto, UpdateProductAttributeDto } from "./types";
+export default class ProductAttributes extends ApiModule implements RestApiModuleI, GraphApiModuleI {
+    create(args: CreateProductAttributeDto): Promise<ProductAttribute>;
+    findAll(args?: QueryProductAttributeDto): Promise<PaginatedDto<ProductAttribute>>;
+    findOne(id: number): Promise<ProductAttribute>;
+    update(id: number, data: UpdateProductAttributeDto): Promise<ProductAttribute>;
+    remove(id: number): Promise<ProductAttribute>;
+    list(args?: QueryProductAttributeGQLDto): Promise<PaginatedGQL<ProductAttribute>>;
+    removeMany(id: number | number[]): Promise<RemoveGQL>;
+    createValue(attributeId: number, args: CreateProductAttributeValueDto): Promise<ProductAttributeValue>;
+    findAllValues(attributeId: number): Promise<ProductAttributeValue[]>;
+}

package/dist/productAttributes/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const queryParams_1 = require("../core/utils/queryParams");
+const model_1 = require("../model");
+const graphql_1 = require("./graphql");
+class ProductAttributes extends model_1.ApiModule {
+    create(args) {
+        return this._call('post', '/product-attributes', args);
+    }
+    findAll(args = {}) {
+        return this._call('get', '/product-attributes', (0, queryParams_1.queryParams)(args));
+    }
+    findOne(id) {
+        return this._call('get', `/product-attributes/${id}`);
+    }
+    update(id, data) {
+        return this._call('patch', `/product-attributes/${id}`, data);
+    }
+    remove(id) {
+        return this._call('delete', `/product-attributes/${id}`);
+    }
+    list(args = {}) {
+        return this._graphql(graphql_1.ProductAttributesResolvers.query.productAttributes, args);
+    }
+    removeMany(id) {
+        return this._graphql(graphql_1.ProductAttributesResolvers.mutation.removeProductAttributes, {
+            id
+        });
+    }
+    createValue(attributeId, args) {
+        return this._call('post', `/product-attributes/${attributeId}/attribute-values`, args);
+    }
+    findAllValues(attributeId) {
+        return this._call('get', `/product-attributes/${attributeId}/attribute-values`);
+    }
+}
+exports.default = ProductAttributes;

package/dist/productAttributes/types.d.ts

@@ -0,0 +1,37 @@
+import { BooleanClause, StringClause, WhereClausesDto } from "../core/dto/clauses";
+import { Sorting, SortingParamsDto } from "../core/dto/sorting";
+import { QueryParamsDto } from "../core/utils/queryParams";
+import { Metafield, OmitRequire, Translation } from "../types";
+export type ProductAttribute = {
+    id: number;
+    name: string;
+    slug: string;
+    translations: Translation[];
+    metafields: Metafield[];
+    published: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type ProductAttributeValue = {
+    id: number;
+    name: string;
+    productAttributeId: number;
+    translations: Translation[];
+    metafields: Metafield[];
+    published: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type CreateProductAttributeDto = OmitRequire<ProductAttribute, 'id' | 'createdAt' | 'updatedAt' | 'slug', 'name'>;
+export type UpdateProductAttributeDto = Partial<CreateProductAttributeDto>;
+export type CreateProductAttributeValueDto = OmitRequire<ProductAttributeValue, 'id' | 'createdAt' | 'updatedAt' | 'productAttributeId', 'name'>;
+export type UpdateProductAttributeValueDto = Partial<CreateProductAttributeValueDto>;
+export type SortingProductAttributeDto = SortingParamsDto<{
+    name?: Sorting;
+    published?: Sorting;
+}>;
+export type ClausesProductAttributeDto = WhereClausesDto<{
+    name?: StringClause;
+    published?: BooleanClause;
+}>;
+export type QueryProductAttributeDto = QueryParamsDto<SortingProductAttributeDto, ClausesProductAttributeDto>;

package/dist/productAttributes/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/productAttributes/values.d.ts

@@ -0,0 +1,11 @@
+import { PaginatedGQL } from "../core/dto/pagination";
+import { RemoveGQL } from "../core/model/remove-gql.response";
+import { ApiModule, GraphApiModuleI } from "../model";
+import { QueryProductAttributeValueGQLDto } from "./graphql";
+import { ProductAttributeValue, UpdateProductAttributeValueDto } from "./types";
+export default class ProductAttributeValues extends ApiModule implements GraphApiModuleI {
+    update(id: number, data: UpdateProductAttributeValueDto): Promise<ProductAttributeValue>;
+    remove(id: number): Promise<ProductAttributeValue>;
+    list(args?: QueryProductAttributeValueGQLDto): Promise<PaginatedGQL<ProductAttributeValue>>;
+    removeMany(id: number | number[]): Promise<RemoveGQL>;
+}