// tsconfig.json
{
  "files":
  [
    "src/index.d.ts",
  ],
  "compileOnSave": false,
  "compilerOptions": {
    "outDir": "./dist/out-tsc",
    "baseUrl": "src",
    "sourceMap": true,
    "declaration": false,
    "moduleResolution": "node",
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "target": "es5",
    "typeRoots":
    [
      "node_modules/@types",
      "src/index.d.ts"
    ],
    "lib": [
      "es2016",
      "dom"
    ],
  }
}

// index.d.ts

declare const enum ERRORS
{
    CATEGORY_DOESNT_EXIST = 0,
    PRODUCT_DOESNT_EXIST = 1,
}

/*declare const textFieldErrors =
{
    required: "Acest câmp trebuie completat.",
    pattern: "Formatul introdus este invalid.",
    email: "Email-ul introdus nu este unul valid.",
    minlength: "Conținutul trebuie să aiba minim %% caractere.",
    matchPassword: "Parolele introduse nu coincid.",
    uniqueEmail: "Acest email este deja folosit."
};
*/
interface Point
{
    x: number;
    y: number;
}

interface URL
{
    url: string;
    name: string;
}

interface Pagination
{
    active: number;
    total: number;
}

interface Color
{
    name: string;
    value: string;
}

interface Image
{
    url: string;
    alt: string;
    title: string;
    ratio_width: number;
    ratio_height: number;
}

declare type Breadcrumb = URL[];

/*
 * Product
 */

declare namespace ProductResponse
 {
     export interface small
     {

     }
     export interface medium
     {
        id: number;
        name: string;
        url: string;
        stock: number;
        price: number;
        discount: number;
        rate: number;
     }

     export interface full
     {
        data:
        {
            id: number;
            name: string;
            url: string;
            stock: number;
            rate: number;
            reviews: number;
            price: number;
            discount: number;
            description: string;
            created_at: number;
            updated_at: number;
        };
        images: Image[];
        breadcrumb: Breadcrumb;
        reviews: ReviewResponse[];
        auth?:
        {
            can_review: boolean;
            review?: ReviewResponse;
        };
     }
 }

/*
 * Product END
 */

 /*
  * Cart
  */

declare namespace CartResponse
{
    type List = ListItem[];
    export interface ListItem
    {
        id: number;
        quantity: number;
        stock: number;
    }

    type Store = StoreItem[];
    export interface StoreItem
    {
        id: number;
        code: number;
    }

    type Product = ProductItem[];
    export interface ProductItem
    {
        id: number;
        name: string;
        url: string;
        image: Image;
        stock: number;
        price: number;
        discount: number;
        quantity: number;
    }
}

interface CartItem
{
    id: number;
    quantity: number;
}

declare type CartList = CartItem[];

 /*
  * Cart END
  */

/*
 * Review
 */

interface ReviewsResponse
{
    data: ReviewResponse[];
    total: number;
}

interface ReviewResponse
{
    id: number;
    author_id: number;
    author: string;
    rate: number;
    message: string;
    created_at: number;
    updated_at: number;
}

/*
 * Review END
 */


 /*
  * User
  */

 declare namespace User
 {
     export interface Address
     {
        id: number;
        fullname: string;
        phone: string;
        country: number;
        line1: string;
        line2: string;
        city: string;
        state: string;
        //postal: number;
     }
 }


/*
 * User END
 */

interface Token
{
    token_type: string;
    expires_in: number;
    access_token: string;
    refresh_token?: string;
}

interface SigninResponseError
{
    error: string;
    message: string
}

/*
 * Category
 */


interface CategoryDataResponse
{
    category:
    {
        id: number;
        url: string;
        name: string;
        breadcrumb: URL[];
        tree: CategoryTree;
        price: CategoryPrice;
        specifications: CategoryFilter[];
    };
    products: ProductResponse.medium[];
    pagination: Pagination;
}

interface CategoryTreeItem
{
    id: number;
    url: string;
    name: string;
}

interface CategoryTree
{
    parent: CategoryTreeItem;
    childs: CategoryTreeItem[];
}

interface CategoryPrice
{
    min: number;
    max: number;
}

interface CategoryFilter
{
    id: number;
    name: string;
    type: number;
    fields: CategoryFilterField[];
    ctrl?: any;
}

interface CategoryFilterField
{
    id: number;
    name: string;
}
/*
 * Category END
 */

/*
 * Bug report
 */

export interface BugReportData
{
    file: string;
    browser_url: string;
    api_url?: string;
    api_body?: string;
    api_type?: string;
    response_error: string;
}

/*
 * Bug report END
 */