@dokamerce/web-sdk 0.9.0

package/dist/graphql/__generated__/gateway.d.ts

@@ -0,0 +1,2073 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    DateTime: {
+        input: any;
+        output: any;
+    };
+};
+export type Attribute = {
+    __typename?: 'Attribute';
+    active: Scalars['Boolean']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    type: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    values?: Maybe<Array<AttributeValue>>;
+};
+export declare enum AttributeFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export type AttributeFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type AttributeSort = {
+    field: AttributeFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type AttributeValue = {
+    __typename?: 'AttributeValue';
+    default: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+};
+export type Brand = {
+    __typename?: 'Brand';
+    active?: Maybe<Scalars['Boolean']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    logo?: Maybe<File>;
+    name: Scalars['String']['output'];
+    orderNumber: Scalars['Float']['output'];
+    slug: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum BrandFieldsEnum {
+    Active = "active",
+    CreatedAt = "createdAt",
+    Description = "description",
+    Id = "id",
+    Name = "name",
+    OrderNumber = "orderNumber",
+    Slug = "slug",
+    UpdatedAt = "updatedAt"
+}
+export type BrandFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type BrandSort = {
+    field: BrandFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type Category = {
+    __typename?: 'Category';
+    children?: Maybe<Array<Category>>;
+    createdAt: Scalars['DateTime']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    names?: Maybe<Array<LocalizedText>>;
+    parent?: Maybe<Category>;
+    slug: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum CategoryFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export type CategoryFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type CategorySort = {
+    field: CategoryFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type Color = {
+    __typename?: 'Color';
+    createdAt: Scalars['DateTime']['output'];
+    hexCode: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum ColorFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export type ColorFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type ColorSort = {
+    field: ColorFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type CompleteFileUploadInput = {
+    errorReason?: InputMaybe<Scalars['String']['input']>;
+    parts?: InputMaybe<Array<FileUploadPartInput>>;
+    status: StatusEnum;
+};
+export type CreateCustomerInput = {
+    fullName: Scalars['String']['input'];
+};
+export type CreateOrderInput = {
+    total: Scalars['Float']['input'];
+};
+export type CreateProductInput = {
+    name: Scalars['String']['input'];
+};
+export type CreateSellerInput = {
+    active: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    orderNumber: Scalars['Int']['input'];
+    slug: Scalars['String']['input'];
+    verified: Scalars['Boolean']['input'];
+};
+export type Customer = {
+    __typename?: 'Customer';
+    createdAt: Scalars['DateTime']['output'];
+    fullName: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum CustomerFieldsEnum {
+    CreatedAt = "createdAt",
+    FullName = "fullName",
+    Id = "id",
+    UpdatedAt = "updatedAt"
+}
+export type CustomerFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type CustomerSort = {
+    field: CustomerFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type File = {
+    __typename?: 'File';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    size?: Maybe<Scalars['Int']['output']>;
+    status: FileStatusEnum;
+    thumbnails: FileThumbnails;
+    type?: Maybe<Scalars['String']['output']>;
+    updatedAt: Scalars['DateTime']['output'];
+    url?: Maybe<Scalars['String']['output']>;
+};
+export declare enum FileStatusEnum {
+    Completed = "COMPLETED",
+    Failed = "FAILED",
+    Processing = "PROCESSING",
+    Uploading = "UPLOADING"
+}
+export type FileThumbnails = {
+    __typename?: 'FileThumbnails';
+    thumbnail450Url?: Maybe<Scalars['String']['output']>;
+    thumbnail900Url?: Maybe<Scalars['String']['output']>;
+};
+export type FileUpload = {
+    __typename?: 'FileUpload';
+    file: File;
+    uploadId: Scalars['ID']['output'];
+    urls: Array<FileUploadUrl>;
+};
+export type FileUploadPartInput = {
+    order: Scalars['Int']['input'];
+    tag: Scalars['String']['input'];
+};
+export type FileUploadUrl = {
+    __typename?: 'FileUploadUrl';
+    order: Scalars['Int']['output'];
+    url: Scalars['String']['output'];
+};
+export type IdArrayFilter = {
+    every?: InputMaybe<Array<Scalars['ID']['input']>>;
+    none?: InputMaybe<Array<Scalars['ID']['input']>>;
+    some?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export type InfiniteAttributeEdge = {
+    __typename?: 'InfiniteAttributeEdge';
+    cursor: Scalars['String']['output'];
+    node: Attribute;
+};
+export type InfiniteAttributesConnection = {
+    __typename?: 'InfiniteAttributesConnection';
+    edges: Array<InfiniteAttributeEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteBrandEdge = {
+    __typename?: 'InfiniteBrandEdge';
+    cursor: Scalars['String']['output'];
+    node: Brand;
+};
+export type InfiniteBrandsConnection = {
+    __typename?: 'InfiniteBrandsConnection';
+    edges: Array<InfiniteBrandEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteCategoriesConnection = {
+    __typename?: 'InfiniteCategoriesConnection';
+    edges: Array<InfiniteCategoryEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteCategoryEdge = {
+    __typename?: 'InfiniteCategoryEdge';
+    cursor: Scalars['String']['output'];
+    node: Category;
+};
+export type InfiniteColorEdge = {
+    __typename?: 'InfiniteColorEdge';
+    cursor: Scalars['String']['output'];
+    node: Color;
+};
+export type InfiniteColorsConnection = {
+    __typename?: 'InfiniteColorsConnection';
+    edges: Array<InfiniteColorEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteCustomerEdge = {
+    __typename?: 'InfiniteCustomerEdge';
+    cursor: Scalars['String']['output'];
+    node: Customer;
+};
+export type InfiniteCustomersConnection = {
+    __typename?: 'InfiniteCustomersConnection';
+    edges: Array<InfiniteCustomerEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteMetricEdge = {
+    __typename?: 'InfiniteMetricEdge';
+    cursor: Scalars['String']['output'];
+    node: Metric;
+};
+export type InfiniteMetricsConnection = {
+    __typename?: 'InfiniteMetricsConnection';
+    edges: Array<InfiniteMetricEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteOrderEdge = {
+    __typename?: 'InfiniteOrderEdge';
+    cursor: Scalars['String']['output'];
+    node: Order;
+};
+export type InfiniteOrdersConnection = {
+    __typename?: 'InfiniteOrdersConnection';
+    edges: Array<InfiniteOrderEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfinitePageInfo = {
+    __typename?: 'InfinitePageInfo';
+    endCursor?: Maybe<Scalars['String']['output']>;
+    hasNextPage: Scalars['Boolean']['output'];
+    hasPreviousPage: Scalars['Boolean']['output'];
+    startCursor?: Maybe<Scalars['String']['output']>;
+};
+export type InfiniteProductEdge = {
+    __typename?: 'InfiniteProductEdge';
+    cursor: Scalars['String']['output'];
+    node: Product;
+};
+export type InfiniteProductsConnection = {
+    __typename?: 'InfiniteProductsConnection';
+    edges: Array<InfiniteProductEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteSellerEdge = {
+    __typename?: 'InfiniteSellerEdge';
+    cursor: Scalars['String']['output'];
+    node: Seller;
+};
+export type InfiniteSellersConnection = {
+    __typename?: 'InfiniteSellersConnection';
+    edges: Array<InfiniteSellerEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteSizeGroupEdge = {
+    __typename?: 'InfiniteSizeGroupEdge';
+    cursor: Scalars['String']['output'];
+    node: SizeGroup;
+};
+export type InfiniteSizesConnection = {
+    __typename?: 'InfiniteSizesConnection';
+    edges: Array<InfiniteSizeGroupEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InfiniteTagEdge = {
+    __typename?: 'InfiniteTagEdge';
+    cursor: Scalars['String']['output'];
+    node: Tag;
+};
+export type InfiniteTagsConnection = {
+    __typename?: 'InfiniteTagsConnection';
+    edges: Array<InfiniteTagEdge>;
+    pageInfo: InfinitePageInfo;
+};
+export type InitiateFileUploadInput = {
+    meta?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    os: Scalars['String']['input'];
+    referenceId: Scalars['String']['input'];
+    size: Scalars['Int']['input'];
+    version: Scalars['String']['input'];
+};
+export type LocalizedText = {
+    __typename?: 'LocalizedText';
+    locale: Scalars['String']['output'];
+    value: Scalars['String']['output'];
+};
+export type Metric = {
+    __typename?: 'Metric';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    symbol: Scalars['String']['output'];
+    type: UnitType;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum MetricFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Name = "name",
+    Symbol = "symbol",
+    Type = "type",
+    UpdatedAt = "updatedAt"
+}
+export type MetricFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type MetricSort = {
+    field: MetricFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    completeFileUpload: File;
+    createCustomer: Customer;
+    createOrder: Order;
+    createProduct: Product;
+    createSeller: Seller;
+    deleteProduct: Status;
+    deleteSeller: Status;
+    initiateFileUpload: FileUpload;
+    updateCustomer: Customer;
+    updateOrder: Order;
+    updateProduct: Product;
+    updateSeller: Seller;
+};
+export type MutationCompleteFileUploadArgs = {
+    data: CompleteFileUploadInput;
+    id: Scalars['ID']['input'];
+};
+export type MutationCreateCustomerArgs = {
+    data: CreateCustomerInput;
+};
+export type MutationCreateOrderArgs = {
+    data: CreateOrderInput;
+};
+export type MutationCreateProductArgs = {
+    data: CreateProductInput;
+};
+export type MutationCreateSellerArgs = {
+    data: CreateSellerInput;
+};
+export type MutationDeleteProductArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteSellerArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationInitiateFileUploadArgs = {
+    data: InitiateFileUploadInput;
+};
+export type MutationUpdateCustomerArgs = {
+    data: UpdateCustomerInput;
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateOrderArgs = {
+    data: UpdateOrderInput;
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateProductArgs = {
+    data: UpdateProductInput;
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateSellerArgs = {
+    data: UpdateSellerInput;
+    id: Scalars['ID']['input'];
+};
+export type Order = {
+    __typename?: 'Order';
+    createdAt: Scalars['DateTime']['output'];
+    customer: Customer;
+    id: Scalars['ID']['output'];
+    total: Scalars['Int']['output'];
+    updatedAt?: Maybe<Scalars['DateTime']['output']>;
+};
+export declare enum OrderFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Total = "total",
+    UpdatedAt = "updatedAt"
+}
+export type OrderFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type OrderSort = {
+    field: OrderFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type PaginatedAttributeEdge = {
+    __typename?: 'PaginatedAttributeEdge';
+    cursor: Scalars['String']['output'];
+    node: Attribute;
+};
+export type PaginatedAttributesConnection = {
+    __typename?: 'PaginatedAttributesConnection';
+    edges: Array<PaginatedAttributeEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedBrandEdge = {
+    __typename?: 'PaginatedBrandEdge';
+    cursor: Scalars['String']['output'];
+    node: Brand;
+};
+export type PaginatedBrandsConnection = {
+    __typename?: 'PaginatedBrandsConnection';
+    edges: Array<PaginatedBrandEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedCategoriesConnection = {
+    __typename?: 'PaginatedCategoriesConnection';
+    edges: Array<PaginatedCategoryEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedCategoryEdge = {
+    __typename?: 'PaginatedCategoryEdge';
+    cursor: Scalars['String']['output'];
+    node: Category;
+};
+export type PaginatedColorEdge = {
+    __typename?: 'PaginatedColorEdge';
+    cursor: Scalars['String']['output'];
+    node: Color;
+};
+export type PaginatedColorsConnection = {
+    __typename?: 'PaginatedColorsConnection';
+    edges: Array<PaginatedColorEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedCustomerEdge = {
+    __typename?: 'PaginatedCustomerEdge';
+    cursor: Scalars['String']['output'];
+    node: Customer;
+};
+export type PaginatedCustomersConnection = {
+    __typename?: 'PaginatedCustomersConnection';
+    edges: Array<PaginatedCustomerEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedMetricEdge = {
+    __typename?: 'PaginatedMetricEdge';
+    cursor: Scalars['String']['output'];
+    node: Metric;
+};
+export type PaginatedMetricsConnection = {
+    __typename?: 'PaginatedMetricsConnection';
+    edges: Array<PaginatedMetricEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedOrderEdge = {
+    __typename?: 'PaginatedOrderEdge';
+    cursor: Scalars['String']['output'];
+    node: Order;
+};
+export type PaginatedOrdersConnection = {
+    __typename?: 'PaginatedOrdersConnection';
+    edges: Array<PaginatedOrderEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedPageInfo = {
+    __typename?: 'PaginatedPageInfo';
+    currentPage: Scalars['Float']['output'];
+    hasNextPage: Scalars['Boolean']['output'];
+    hasPreviousPage: Scalars['Boolean']['output'];
+    totalEdges: Scalars['Float']['output'];
+    totalPages: Scalars['Float']['output'];
+};
+export type PaginatedProductEdge = {
+    __typename?: 'PaginatedProductEdge';
+    cursor: Scalars['String']['output'];
+    node: Product;
+};
+export type PaginatedProductsConnection = {
+    __typename?: 'PaginatedProductsConnection';
+    edges: Array<PaginatedProductEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedSellerEdge = {
+    __typename?: 'PaginatedSellerEdge';
+    cursor: Scalars['String']['output'];
+    node: Seller;
+};
+export type PaginatedSellersConnection = {
+    __typename?: 'PaginatedSellersConnection';
+    edges: Array<PaginatedSellerEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedSizeGroupEdge = {
+    __typename?: 'PaginatedSizeGroupEdge';
+    cursor: Scalars['String']['output'];
+    node: SizeGroup;
+};
+export type PaginatedSizesConnection = {
+    __typename?: 'PaginatedSizesConnection';
+    edges: Array<PaginatedSizeGroupEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type PaginatedTagEdge = {
+    __typename?: 'PaginatedTagEdge';
+    cursor: Scalars['String']['output'];
+    node: Tag;
+};
+export type PaginatedTagsConnection = {
+    __typename?: 'PaginatedTagsConnection';
+    edges: Array<PaginatedTagEdge>;
+    pageInfo: PaginatedPageInfo;
+};
+export type Product = {
+    __typename?: 'Product';
+    active: Scalars['Boolean']['output'];
+    barcode?: Maybe<Scalars['String']['output']>;
+    brand?: Maybe<Brand>;
+    category: Category;
+    createdAt: Scalars['DateTime']['output'];
+    deleted: Scalars['Boolean']['output'];
+    deletedAt?: Maybe<Scalars['DateTime']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+    featured: Scalars['Boolean']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    price: Scalars['Float']['output'];
+    publishedAt?: Maybe<Scalars['DateTime']['output']>;
+    seller?: Maybe<Seller>;
+    shortDescription?: Maybe<Scalars['String']['output']>;
+    sku?: Maybe<Scalars['String']['output']>;
+    slug: Scalars['String']['output'];
+    soldCount: Scalars['Int']['output'];
+    status: Scalars['String']['output'];
+    stock: Scalars['Int']['output'];
+    todayDeal: Scalars['Boolean']['output'];
+    type: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    views: Scalars['Int']['output'];
+};
+export declare enum ProductFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export type ProductFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type ProductSort = {
+    field: ProductFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type Query = {
+    __typename?: 'Query';
+    attribute?: Maybe<Array<Attribute>>;
+    brand?: Maybe<Array<Brand>>;
+    customer?: Maybe<Array<Customer>>;
+    file: File;
+    infiniteAttributes: InfiniteAttributesConnection;
+    infiniteBrands: InfiniteBrandsConnection;
+    infiniteCategories: InfiniteCategoriesConnection;
+    infiniteColors: InfiniteColorsConnection;
+    infiniteCustomers: InfiniteCustomersConnection;
+    infiniteMetrics: InfiniteMetricsConnection;
+    infiniteOrders: InfiniteOrdersConnection;
+    infiniteProducts: InfiniteProductsConnection;
+    infiniteSellers: InfiniteSellersConnection;
+    infiniteSizes: InfiniteSizesConnection;
+    infiniteTags: InfiniteTagsConnection;
+    metric?: Maybe<Array<Metric>>;
+    order?: Maybe<Array<Order>>;
+    paginatedAttributes?: Maybe<PaginatedAttributesConnection>;
+    paginatedBrands?: Maybe<PaginatedBrandsConnection>;
+    paginatedCategories?: Maybe<PaginatedCategoriesConnection>;
+    paginatedColors?: Maybe<PaginatedColorsConnection>;
+    paginatedCustomers?: Maybe<PaginatedCustomersConnection>;
+    paginatedMetrics?: Maybe<PaginatedMetricsConnection>;
+    paginatedOrders?: Maybe<PaginatedOrdersConnection>;
+    paginatedProducts?: Maybe<PaginatedProductsConnection>;
+    paginatedSellers?: Maybe<PaginatedSellersConnection>;
+    paginatedSizes?: Maybe<PaginatedSizesConnection>;
+    paginatedTags?: Maybe<PaginatedTagsConnection>;
+    product?: Maybe<Array<Product>>;
+    seller?: Maybe<Seller>;
+    size?: Maybe<Array<SizeGroup>>;
+    tag?: Maybe<Array<Tag>>;
+};
+export type QueryAttributeArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryBrandArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryCustomerArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryFileArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryInfiniteAttributesArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<AttributeFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<AttributeSort>>;
+};
+export type QueryInfiniteBrandsArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<BrandFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<BrandSort>>;
+};
+export type QueryInfiniteCategoriesArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<CategoryFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CategorySort>>;
+};
+export type QueryInfiniteColorsArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<ColorFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ColorSort>>;
+};
+export type QueryInfiniteCustomersArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<CustomerFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CustomerSort>>;
+};
+export type QueryInfiniteMetricsArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<MetricFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<MetricSort>>;
+};
+export type QueryInfiniteOrdersArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<OrderFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<OrderSort>>;
+};
+export type QueryInfiniteProductsArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<ProductFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ProductSort>>;
+};
+export type QueryInfiniteSellersArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<SellerFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<SellerSort>>;
+};
+export type QueryInfiniteSizesArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<SizeFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<SizeGroupSort>>;
+};
+export type QueryInfiniteTagsArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<TagFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<TagSort>>;
+};
+export type QueryMetricArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryOrderArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryPaginatedAttributesArgs = {
+    filter?: InputMaybe<AttributeFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<AttributeSort>>;
+};
+export type QueryPaginatedBrandsArgs = {
+    filter?: InputMaybe<BrandFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<BrandSort>>;
+};
+export type QueryPaginatedCategoriesArgs = {
+    filter?: InputMaybe<CategoryFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CategorySort>>;
+};
+export type QueryPaginatedColorsArgs = {
+    filter?: InputMaybe<ColorFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ColorSort>>;
+};
+export type QueryPaginatedCustomersArgs = {
+    filter?: InputMaybe<CustomerFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CustomerSort>>;
+};
+export type QueryPaginatedMetricsArgs = {
+    filter?: InputMaybe<MetricFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<MetricSort>>;
+};
+export type QueryPaginatedOrdersArgs = {
+    filter?: InputMaybe<OrderFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<OrderSort>>;
+};
+export type QueryPaginatedProductsArgs = {
+    filter?: InputMaybe<ProductFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ProductSort>>;
+};
+export type QueryPaginatedSellersArgs = {
+    filter?: InputMaybe<SellerFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<SellerSort>>;
+};
+export type QueryPaginatedSizesArgs = {
+    filter?: InputMaybe<SizeFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<SizeGroupSort>>;
+};
+export type QueryPaginatedTagsArgs = {
+    filter?: InputMaybe<TagFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<TagSort>>;
+};
+export type QueryProductArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QuerySellerArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QuerySizeArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryTagArgs = {
+    id: Scalars['ID']['input'];
+};
+export type Seller = {
+    __typename?: 'Seller';
+    active: Scalars['Boolean']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    createdById?: Maybe<Scalars['ID']['output']>;
+    deleted: Scalars['Boolean']['output'];
+    deletedAt?: Maybe<Scalars['DateTime']['output']>;
+    deletedById?: Maybe<Scalars['ID']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    logo?: Maybe<File>;
+    name: Scalars['String']['output'];
+    orderNumber: Scalars['Int']['output'];
+    rating?: Maybe<Scalars['Float']['output']>;
+    slug: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    updatedById?: Maybe<Scalars['ID']['output']>;
+    verified: Scalars['Boolean']['output'];
+};
+export declare enum SellerFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export type SellerFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type SellerSort = {
+    field: SellerFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export declare enum SizeFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Title = "title",
+    UnitCreatedAt = "unit___createdAt",
+    UnitId = "unit___id",
+    UnitName = "unit___name",
+    UnitSymbol = "unit___symbol",
+    UnitType = "unit___type",
+    UnitUpdatedAt = "unit___updatedAt",
+    UpdatedAt = "updatedAt",
+    ValuesId = "values___id",
+    ValuesValue = "values___value"
+}
+export type SizeFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type SizeGroup = {
+    __typename?: 'SizeGroup';
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    title: Scalars['String']['output'];
+    unit: Metric;
+    updatedAt: Scalars['DateTime']['output'];
+    values: Array<SizeValue>;
+};
+export type SizeGroupSort = {
+    field: SizeFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export type SizeValue = {
+    __typename?: 'SizeValue';
+    id: Scalars['ID']['output'];
+    value: Scalars['String']['output'];
+};
+export declare enum SortOrderEnum {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export type Status = {
+    __typename?: 'Status';
+    reason?: Maybe<Scalars['String']['output']>;
+    status: StatusEnum;
+};
+export declare enum StatusEnum {
+    Error = "ERROR",
+    Ok = "OK"
+}
+export type StringArrayFilter = {
+    every?: InputMaybe<Array<Scalars['String']['input']>>;
+    none?: InputMaybe<Array<Scalars['String']['input']>>;
+    some?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type Subscription = {
+    __typename?: 'Subscription';
+    subscribeFileUpload: File;
+};
+export type SubscriptionSubscribeFileUploadArgs = {
+    id: Scalars['ID']['input'];
+};
+export type Tag = {
+    __typename?: 'Tag';
+    color?: Maybe<Scalars['String']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export declare enum TagFieldsEnum {
+    CreatedAt = "createdAt",
+    Id = "id",
+    Name = "name",
+    UpdatedAt = "updatedAt"
+}
+export type TagFilter = {
+    id?: InputMaybe<IdArrayFilter>;
+    name?: InputMaybe<StringArrayFilter>;
+};
+export type TagSort = {
+    field: TagFieldsEnum;
+    order?: InputMaybe<SortOrderEnum>;
+};
+export declare enum UnitType {
+    Count = "COUNT",
+    Length = "LENGTH",
+    Volume = "VOLUME",
+    Weight = "WEIGHT"
+}
+export type UpdateCustomerInput = {
+    fullName?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateOrderInput = {
+    total?: InputMaybe<Scalars['Float']['input']>;
+};
+export type UpdateProductInput = {
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateSellerInput = {
+    active?: InputMaybe<Scalars['Boolean']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    orderNumber?: InputMaybe<Scalars['Int']['input']>;
+    slug?: InputMaybe<Scalars['String']['input']>;
+    verified?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type AttributeFragmentFragment = {
+    __typename?: 'Attribute';
+    id: string;
+    name: string;
+    createdAt: any;
+    updatedAt: any;
+};
+export type InfiniteAttributesQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<AttributeFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<AttributeSort> | AttributeSort>;
+}>;
+export type InfiniteAttributesQuery = {
+    __typename?: 'Query';
+    infiniteAttributes: {
+        __typename?: 'InfiniteAttributesConnection';
+        edges: Array<{
+            __typename?: 'InfiniteAttributeEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Attribute';
+                id: string;
+                name: string;
+                createdAt: any;
+                updatedAt: any;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedAttributesQueryVariables = Exact<{
+    filter?: InputMaybe<AttributeFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<AttributeSort> | AttributeSort>;
+}>;
+export type PaginatedAttributesQuery = {
+    __typename?: 'Query';
+    paginatedAttributes?: {
+        __typename?: 'PaginatedAttributesConnection';
+        edges: Array<{
+            __typename?: 'PaginatedAttributeEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Attribute';
+                id: string;
+                name: string;
+                createdAt: any;
+                updatedAt: any;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export type BrandFragmentFragment = {
+    __typename?: 'Brand';
+    id: string;
+    name: string;
+    active?: boolean | null;
+    description?: string | null;
+    orderNumber: number;
+    slug: string;
+    logo?: {
+        __typename?: 'File';
+        url?: string | null;
+    } | null;
+};
+export type InfiniteBrandsQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<BrandFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<BrandSort> | BrandSort>;
+    withLogo?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type InfiniteBrandsQuery = {
+    __typename?: 'Query';
+    infiniteBrands: {
+        __typename?: 'InfiniteBrandsConnection';
+        edges: Array<{
+            __typename?: 'InfiniteBrandEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Brand';
+                id: string;
+                name: string;
+                active?: boolean | null;
+                description?: string | null;
+                orderNumber: number;
+                slug: string;
+                logo?: {
+                    __typename?: 'File';
+                    url?: string | null;
+                    createdAt: any;
+                    id: string;
+                    name: string;
+                    size?: number | null;
+                    status: FileStatusEnum;
+                    type?: string | null;
+                    updatedAt: any;
+                    thumbnails: {
+                        __typename?: 'FileThumbnails';
+                        thumbnail450Url?: string | null;
+                        thumbnail900Url?: string | null;
+                    };
+                } | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedBrandsQueryVariables = Exact<{
+    filter?: InputMaybe<BrandFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<BrandSort> | BrandSort>;
+    withLogo?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type PaginatedBrandsQuery = {
+    __typename?: 'Query';
+    paginatedBrands?: {
+        __typename?: 'PaginatedBrandsConnection';
+        edges: Array<{
+            __typename?: 'PaginatedBrandEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Brand';
+                id: string;
+                name: string;
+                active?: boolean | null;
+                description?: string | null;
+                orderNumber: number;
+                slug: string;
+                logo?: {
+                    __typename?: 'File';
+                    url?: string | null;
+                    createdAt: any;
+                    id: string;
+                    name: string;
+                    size?: number | null;
+                    status: FileStatusEnum;
+                    type?: string | null;
+                    updatedAt: any;
+                    thumbnails: {
+                        __typename?: 'FileThumbnails';
+                        thumbnail450Url?: string | null;
+                        thumbnail900Url?: string | null;
+                    };
+                } | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export type CategoryFragmentFragment = {
+    __typename?: 'Category';
+    id: string;
+    name: string;
+    description?: string | null;
+    slug: string;
+    createdAt: any;
+    updatedAt: any;
+    names?: Array<{
+        __typename?: 'LocalizedText';
+        locale: string;
+        value: string;
+    }> | null;
+};
+export type InfiniteCategoriesQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<CategoryFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CategorySort> | CategorySort>;
+    withChildren?: InputMaybe<Scalars['Boolean']['input']>;
+    withParent?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type InfiniteCategoriesQuery = {
+    __typename?: 'Query';
+    infiniteCategories: {
+        __typename?: 'InfiniteCategoriesConnection';
+        edges: Array<{
+            __typename?: 'InfiniteCategoryEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Category';
+                id: string;
+                name: string;
+                description?: string | null;
+                slug: string;
+                createdAt: any;
+                updatedAt: any;
+                parent?: {
+                    __typename?: 'Category';
+                    id: string;
+                    name: string;
+                    description?: string | null;
+                    slug: string;
+                    createdAt: any;
+                    updatedAt: any;
+                    names?: Array<{
+                        __typename?: 'LocalizedText';
+                        locale: string;
+                        value: string;
+                    }> | null;
+                } | null;
+                children?: Array<{
+                    __typename?: 'Category';
+                    id: string;
+                    name: string;
+                    description?: string | null;
+                    slug: string;
+                    createdAt: any;
+                    updatedAt: any;
+                    names?: Array<{
+                        __typename?: 'LocalizedText';
+                        locale: string;
+                        value: string;
+                    }> | null;
+                }> | null;
+                names?: Array<{
+                    __typename?: 'LocalizedText';
+                    locale: string;
+                    value: string;
+                }> | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedCategoriesQueryVariables = Exact<{
+    filter?: InputMaybe<CategoryFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CategorySort> | CategorySort>;
+    withChildren?: InputMaybe<Scalars['Boolean']['input']>;
+    withParent?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type PaginatedCategoriesQuery = {
+    __typename?: 'Query';
+    paginatedCategories?: {
+        __typename?: 'PaginatedCategoriesConnection';
+        edges: Array<{
+            __typename?: 'PaginatedCategoryEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Category';
+                id: string;
+                name: string;
+                description?: string | null;
+                slug: string;
+                createdAt: any;
+                updatedAt: any;
+                parent?: {
+                    __typename?: 'Category';
+                    id: string;
+                    name: string;
+                    description?: string | null;
+                    slug: string;
+                    createdAt: any;
+                    updatedAt: any;
+                    names?: Array<{
+                        __typename?: 'LocalizedText';
+                        locale: string;
+                        value: string;
+                    }> | null;
+                } | null;
+                children?: Array<{
+                    __typename?: 'Category';
+                    id: string;
+                    name: string;
+                    description?: string | null;
+                    slug: string;
+                    createdAt: any;
+                    updatedAt: any;
+                    names?: Array<{
+                        __typename?: 'LocalizedText';
+                        locale: string;
+                        value: string;
+                    }> | null;
+                }> | null;
+                names?: Array<{
+                    __typename?: 'LocalizedText';
+                    locale: string;
+                    value: string;
+                }> | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export type ColorFragmentFragment = {
+    __typename?: 'Color';
+    updatedAt: any;
+    hexCode: string;
+    id: string;
+    name: string;
+    createdAt: any;
+};
+export type InfiniteColorsQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<ColorFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ColorSort> | ColorSort>;
+}>;
+export type InfiniteColorsQuery = {
+    __typename?: 'Query';
+    infiniteColors: {
+        __typename?: 'InfiniteColorsConnection';
+        edges: Array<{
+            __typename?: 'InfiniteColorEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Color';
+                updatedAt: any;
+                hexCode: string;
+                id: string;
+                name: string;
+                createdAt: any;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedColorsQueryVariables = Exact<{
+    filter?: InputMaybe<ColorFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ColorSort> | ColorSort>;
+}>;
+export type PaginatedColorsQuery = {
+    __typename?: 'Query';
+    paginatedColors?: {
+        __typename?: 'PaginatedColorsConnection';
+        edges: Array<{
+            __typename?: 'PaginatedColorEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Color';
+                updatedAt: any;
+                hexCode: string;
+                id: string;
+                name: string;
+                createdAt: any;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export type CustomerFragmentFragment = {
+    __typename?: 'Customer';
+    id: string;
+    fullName: string;
+    createdAt: any;
+    updatedAt: any;
+};
+export type CreateCustomerMutationVariables = Exact<{
+    data: CreateCustomerInput;
+}>;
+export type CreateCustomerMutation = {
+    __typename?: 'Mutation';
+    createCustomer: {
+        __typename?: 'Customer';
+        id: string;
+        fullName: string;
+        createdAt: any;
+        updatedAt: any;
+    };
+};
+export type UpdateCustomerMutationVariables = Exact<{
+    data: UpdateCustomerInput;
+    id: Scalars['ID']['input'];
+}>;
+export type UpdateCustomerMutation = {
+    __typename?: 'Mutation';
+    updateCustomer: {
+        __typename?: 'Customer';
+        id: string;
+        fullName: string;
+        createdAt: any;
+        updatedAt: any;
+    };
+};
+export type InfiniteCustomersQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<CustomerFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CustomerSort> | CustomerSort>;
+}>;
+export type InfiniteCustomersQuery = {
+    __typename?: 'Query';
+    infiniteCustomers: {
+        __typename?: 'InfiniteCustomersConnection';
+        edges: Array<{
+            __typename?: 'InfiniteCustomerEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Customer';
+                id: string;
+                fullName: string;
+                createdAt: any;
+                updatedAt: any;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedCustomersQueryVariables = Exact<{
+    filter?: InputMaybe<CustomerFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<CustomerSort> | CustomerSort>;
+}>;
+export type PaginatedCustomersQuery = {
+    __typename?: 'Query';
+    paginatedCustomers?: {
+        __typename?: 'PaginatedCustomersConnection';
+        edges: Array<{
+            __typename?: 'PaginatedCustomerEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Customer';
+                id: string;
+                fullName: string;
+                createdAt: any;
+                updatedAt: any;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export type FileThumbnailsFieldsFragment = {
+    __typename?: 'FileThumbnails';
+    thumbnail450Url?: string | null;
+    thumbnail900Url?: string | null;
+};
+export type FileUploadUrlFieldsFragment = {
+    __typename?: 'FileUploadUrl';
+    order: number;
+    url: string;
+};
+export type FileUploadFieldsFragment = {
+    __typename?: 'FileUpload';
+    uploadId: string;
+    file: {
+        __typename?: 'File';
+        createdAt: any;
+        id: string;
+        name: string;
+        size?: number | null;
+        status: FileStatusEnum;
+        type?: string | null;
+        updatedAt: any;
+        url?: string | null;
+        thumbnails: {
+            __typename?: 'FileThumbnails';
+            thumbnail450Url?: string | null;
+            thumbnail900Url?: string | null;
+        };
+    };
+    urls: Array<{
+        __typename?: 'FileUploadUrl';
+        order: number;
+        url: string;
+    }>;
+};
+export type FileFieldsFragment = {
+    __typename?: 'File';
+    createdAt: any;
+    id: string;
+    name: string;
+    size?: number | null;
+    status: FileStatusEnum;
+    type?: string | null;
+    updatedAt: any;
+    url?: string | null;
+    thumbnails: {
+        __typename?: 'FileThumbnails';
+        thumbnail450Url?: string | null;
+        thumbnail900Url?: string | null;
+    };
+};
+export type InitiateFileUploadMutationVariables = Exact<{
+    data: InitiateFileUploadInput;
+}>;
+export type InitiateFileUploadMutation = {
+    __typename?: 'Mutation';
+    initiateFileUpload: {
+        __typename?: 'FileUpload';
+        uploadId: string;
+        file: {
+            __typename?: 'File';
+            createdAt: any;
+            id: string;
+            name: string;
+            size?: number | null;
+            status: FileStatusEnum;
+            type?: string | null;
+            updatedAt: any;
+            url?: string | null;
+            thumbnails: {
+                __typename?: 'FileThumbnails';
+                thumbnail450Url?: string | null;
+                thumbnail900Url?: string | null;
+            };
+        };
+        urls: Array<{
+            __typename?: 'FileUploadUrl';
+            order: number;
+            url: string;
+        }>;
+    };
+};
+export type CompleteFileUploadMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    data: CompleteFileUploadInput;
+}>;
+export type CompleteFileUploadMutation = {
+    __typename?: 'Mutation';
+    completeFileUpload: {
+        __typename?: 'File';
+        createdAt: any;
+        id: string;
+        name: string;
+        size?: number | null;
+        status: FileStatusEnum;
+        type?: string | null;
+        updatedAt: any;
+        url?: string | null;
+        thumbnails: {
+            __typename?: 'FileThumbnails';
+            thumbnail450Url?: string | null;
+            thumbnail900Url?: string | null;
+        };
+    };
+};
+export type FileQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type FileQuery = {
+    __typename?: 'Query';
+    file: {
+        __typename?: 'File';
+        createdAt: any;
+        id: string;
+        name: string;
+        size?: number | null;
+        status: FileStatusEnum;
+        type?: string | null;
+        updatedAt: any;
+        url?: string | null;
+        thumbnails: {
+            __typename?: 'FileThumbnails';
+            thumbnail450Url?: string | null;
+            thumbnail900Url?: string | null;
+        };
+    };
+};
+export type MetricFragmentFragment = {
+    __typename?: 'Metric';
+    createdAt: any;
+    id: string;
+    name: string;
+    symbol: string;
+    type: UnitType;
+    updatedAt: any;
+};
+export type InfiniteMetricsQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<MetricFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<MetricSort> | MetricSort>;
+}>;
+export type InfiniteMetricsQuery = {
+    __typename?: 'Query';
+    infiniteMetrics: {
+        __typename?: 'InfiniteMetricsConnection';
+        edges: Array<{
+            __typename?: 'InfiniteMetricEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Metric';
+                createdAt: any;
+                id: string;
+                name: string;
+                symbol: string;
+                type: UnitType;
+                updatedAt: any;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type OrderFragmentFragment = {
+    __typename?: 'Order';
+    id: string;
+    total: number;
+    createdAt: any;
+    updatedAt?: any | null;
+};
+export type CreateOrderMutationVariables = Exact<{
+    data: CreateOrderInput;
+}>;
+export type CreateOrderMutation = {
+    __typename?: 'Mutation';
+    createOrder: {
+        __typename?: 'Order';
+        id: string;
+        total: number;
+        createdAt: any;
+        updatedAt?: any | null;
+    };
+};
+export type UpdateOrderMutationVariables = Exact<{
+    data: UpdateOrderInput;
+    id: Scalars['ID']['input'];
+}>;
+export type UpdateOrderMutation = {
+    __typename?: 'Mutation';
+    updateOrder: {
+        __typename?: 'Order';
+        id: string;
+        total: number;
+        createdAt: any;
+        updatedAt?: any | null;
+    };
+};
+export type InfiniteOrdersQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<OrderFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<OrderSort> | OrderSort>;
+}>;
+export type InfiniteOrdersQuery = {
+    __typename?: 'Query';
+    infiniteOrders: {
+        __typename?: 'InfiniteOrdersConnection';
+        edges: Array<{
+            __typename?: 'InfiniteOrderEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Order';
+                id: string;
+                total: number;
+                createdAt: any;
+                updatedAt?: any | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedOrdersQueryVariables = Exact<{
+    filter?: InputMaybe<OrderFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<OrderSort> | OrderSort>;
+}>;
+export type PaginatedOrdersQuery = {
+    __typename?: 'Query';
+    paginatedOrders?: {
+        __typename?: 'PaginatedOrdersConnection';
+        edges: Array<{
+            __typename?: 'PaginatedOrderEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Order';
+                id: string;
+                total: number;
+                createdAt: any;
+                updatedAt?: any | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export type ProductFragmentFragment = {
+    __typename?: 'Product';
+    id: string;
+    name: string;
+};
+export type InfiniteProductsQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<ProductFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ProductSort> | ProductSort>;
+}>;
+export type InfiniteProductsQuery = {
+    __typename?: 'Query';
+    infiniteProducts: {
+        __typename?: 'InfiniteProductsConnection';
+        edges: Array<{
+            __typename?: 'InfiniteProductEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Product';
+                id: string;
+                name: string;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedProductsQueryVariables = Exact<{
+    filter?: InputMaybe<ProductFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<ProductSort> | ProductSort>;
+}>;
+export type PaginatedProductsQuery = {
+    __typename?: 'Query';
+    paginatedProducts?: {
+        __typename?: 'PaginatedProductsConnection';
+        edges: Array<{
+            __typename?: 'PaginatedProductEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Product';
+                id: string;
+                name: string;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export type ProductQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type ProductQuery = {
+    __typename?: 'Query';
+    product?: Array<{
+        __typename?: 'Product';
+        id: string;
+        name: string;
+    }> | null;
+};
+export type CreateProductMutationVariables = Exact<{
+    data: CreateProductInput;
+}>;
+export type CreateProductMutation = {
+    __typename?: 'Mutation';
+    createProduct: {
+        __typename?: 'Product';
+        id: string;
+        name: string;
+    };
+};
+export type UpdateProductMutationVariables = Exact<{
+    data: UpdateProductInput;
+    id: Scalars['ID']['input'];
+}>;
+export type UpdateProductMutation = {
+    __typename?: 'Mutation';
+    updateProduct: {
+        __typename?: 'Product';
+        id: string;
+        name: string;
+    };
+};
+export type DeleteProductMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type DeleteProductMutation = {
+    __typename?: 'Mutation';
+    deleteProduct: {
+        __typename?: 'Status';
+        reason?: string | null;
+        status: StatusEnum;
+    };
+};
+export type SellerFragmentFragment = {
+    __typename?: 'Seller';
+    id: string;
+    name: string;
+    description?: string | null;
+    active: boolean;
+    orderNumber: number;
+    slug: string;
+    rating?: number | null;
+    verified: boolean;
+    createdAt: any;
+    updatedAt: any;
+};
+export type CreateSellerMutationVariables = Exact<{
+    data: CreateSellerInput;
+}>;
+export type CreateSellerMutation = {
+    __typename?: 'Mutation';
+    createSeller: {
+        __typename?: 'Seller';
+        id: string;
+        name: string;
+        description?: string | null;
+        active: boolean;
+        orderNumber: number;
+        slug: string;
+        rating?: number | null;
+        verified: boolean;
+        createdAt: any;
+        updatedAt: any;
+    };
+};
+export type UpdateSellerMutationVariables = Exact<{
+    data: UpdateSellerInput;
+    id: Scalars['ID']['input'];
+}>;
+export type UpdateSellerMutation = {
+    __typename?: 'Mutation';
+    updateSeller: {
+        __typename?: 'Seller';
+        id: string;
+        name: string;
+        description?: string | null;
+        active: boolean;
+        orderNumber: number;
+        slug: string;
+        rating?: number | null;
+        verified: boolean;
+        createdAt: any;
+        updatedAt: any;
+    };
+};
+export type InfiniteSellersQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['String']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<SellerFilter>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<SellerSort> | SellerSort>;
+    withLogo?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type InfiniteSellersQuery = {
+    __typename?: 'Query';
+    infiniteSellers: {
+        __typename?: 'InfiniteSellersConnection';
+        edges: Array<{
+            __typename?: 'InfiniteSellerEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Seller';
+                id: string;
+                name: string;
+                description?: string | null;
+                active: boolean;
+                orderNumber: number;
+                slug: string;
+                rating?: number | null;
+                verified: boolean;
+                createdAt: any;
+                updatedAt: any;
+                logo?: {
+                    __typename?: 'File';
+                    createdAt: any;
+                    id: string;
+                    name: string;
+                    size?: number | null;
+                    status: FileStatusEnum;
+                    type?: string | null;
+                    updatedAt: any;
+                    url?: string | null;
+                    thumbnails: {
+                        __typename?: 'FileThumbnails';
+                        thumbnail450Url?: string | null;
+                        thumbnail900Url?: string | null;
+                    };
+                } | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'InfinitePageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+        };
+    };
+};
+export type PaginatedSellersQueryVariables = Exact<{
+    filter?: InputMaybe<SellerFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    sort?: InputMaybe<Array<SellerSort> | SellerSort>;
+    withLogo?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type PaginatedSellersQuery = {
+    __typename?: 'Query';
+    paginatedSellers?: {
+        __typename?: 'PaginatedSellersConnection';
+        edges: Array<{
+            __typename?: 'PaginatedSellerEdge';
+            cursor: string;
+            node: {
+                __typename?: 'Seller';
+                id: string;
+                name: string;
+                description?: string | null;
+                active: boolean;
+                orderNumber: number;
+                slug: string;
+                rating?: number | null;
+                verified: boolean;
+                createdAt: any;
+                updatedAt: any;
+                logo?: {
+                    __typename?: 'File';
+                    createdAt: any;
+                    id: string;
+                    name: string;
+                    size?: number | null;
+                    status: FileStatusEnum;
+                    type?: string | null;
+                    updatedAt: any;
+                    url?: string | null;
+                    thumbnails: {
+                        __typename?: 'FileThumbnails';
+                        thumbnail450Url?: string | null;
+                        thumbnail900Url?: string | null;
+                    };
+                } | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PaginatedPageInfo';
+            currentPage: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalEdges: number;
+            totalPages: number;
+        };
+    } | null;
+};
+export declare const AttributeFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const BrandFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const CategoryFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const ColorFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const CustomerFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const FileThumbnailsFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const FileFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const FileUploadUrlFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const FileUploadFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const MetricFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const OrderFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const ProductFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const SellerFragmentFragmentDoc: import("graphql").DocumentNode;
+export declare const InfiniteAttributesDocument: import("graphql").DocumentNode;
+export declare const PaginatedAttributesDocument: import("graphql").DocumentNode;
+export declare const InfiniteBrandsDocument: import("graphql").DocumentNode;
+export declare const PaginatedBrandsDocument: import("graphql").DocumentNode;
+export declare const InfiniteCategoriesDocument: import("graphql").DocumentNode;
+export declare const PaginatedCategoriesDocument: import("graphql").DocumentNode;
+export declare const InfiniteColorsDocument: import("graphql").DocumentNode;
+export declare const PaginatedColorsDocument: import("graphql").DocumentNode;
+export declare const CreateCustomerDocument: import("graphql").DocumentNode;
+export declare const UpdateCustomerDocument: import("graphql").DocumentNode;
+export declare const InfiniteCustomersDocument: import("graphql").DocumentNode;
+export declare const PaginatedCustomersDocument: import("graphql").DocumentNode;
+export declare const InitiateFileUploadDocument: import("graphql").DocumentNode;
+export declare const CompleteFileUploadDocument: import("graphql").DocumentNode;
+export declare const FileDocument: import("graphql").DocumentNode;
+export declare const InfiniteMetricsDocument: import("graphql").DocumentNode;
+export declare const CreateOrderDocument: import("graphql").DocumentNode;
+export declare const UpdateOrderDocument: import("graphql").DocumentNode;
+export declare const InfiniteOrdersDocument: import("graphql").DocumentNode;
+export declare const PaginatedOrdersDocument: import("graphql").DocumentNode;
+export declare const InfiniteProductsDocument: import("graphql").DocumentNode;
+export declare const PaginatedProductsDocument: import("graphql").DocumentNode;
+export declare const ProductDocument: import("graphql").DocumentNode;
+export declare const CreateProductDocument: import("graphql").DocumentNode;
+export declare const UpdateProductDocument: import("graphql").DocumentNode;
+export declare const DeleteProductDocument: import("graphql").DocumentNode;
+export declare const CreateSellerDocument: import("graphql").DocumentNode;
+export declare const UpdateSellerDocument: import("graphql").DocumentNode;
+export declare const InfiniteSellersDocument: import("graphql").DocumentNode;
+export declare const PaginatedSellersDocument: import("graphql").DocumentNode;