dummy-json-sdk-beta/dist/index.d.ts

A SDK for DummyJSON API (Beta version).

interface _Identity {
    id: number;
}
type _Picked<T extends _Identity, K extends readonly (keyof T)[] | undefined> = K extends readonly (keyof T)[] ? Pick<T, K[number] | "id"> : T;
type _PickedList<T extends _Identity, K extends readonly (keyof T)[] | undefined> = K extends readonly (keyof T)[] ? Array<Pick<T, K[number] | "id">> : T[];
type NestedKeyOf<T> = T extends object ? {
    [K in keyof T]: K extends string ? T[K] extends object ? `${K}.${NestedKeyOf<T[K]>}` : `${K}` : never;
}[keyof T] : never;
type GetNestedValueType<T, K extends string> = K extends `${infer First}.${infer Rest}` ? First extends keyof T ? GetNestedValueType<T[First], Rest> : never : K extends keyof T ? T[K] : never;
interface InitConfig {
    limit?: number;
    delay?: number;
    Authorization?: string;
    refreshToken?: string;
}
interface HttpOptions extends RequestInit {
    url: string;
    method?: "GET" | "POST" | "PUT" | "DELETE";
    query?: object;
}
interface Pagination {
    total?: number;
    limit?: number;
    skip?: number;
}
interface BaseQuery<T extends _Identity = any, K extends readonly (keyof T)[] = readonly (keyof T)[]> extends Omit<Pagination, "total"> {
    select?: K;
    sortBy?: keyof T;
    order?: "asc" | "desc";
}
interface Dimension {
    width: number;
    height: number;
    depth: number;
}
interface Review {
    rating: number;
    comment: string;
    date: string;
    reviewerName: string;
    reviewerEmail: string;
}
interface Meta {
    createdAt: string;
    updatedAt: string;
    barcode: string;
    qrCode: string;
}
interface BaseProduct {
    id: number;
    title: string;
    description: string;
    category: string;
    price: number;
    discountPercentage: number;
    rating: number;
    stock: number;
    tags: string[];
    brand: string;
    sku: string;
    weight: number;
    dimensions: Dimension;
    warrantyInformation: string;
    shippingInformation: string;
    availabilityStatus: string;
    reviews: Review[];
    returnPolicy: string;
    minimumOrderQuantity: number;
    meta: Meta;
    thumbnail: string;
    images: string[];
}
type Product<K extends readonly (keyof BaseProduct)[] = any> = _Picked<BaseProduct, K>;
interface Products<K extends readonly (keyof BaseProduct)[] = any> extends Pagination {
    products: _PickedList<BaseProduct, K>;
}
interface Category {
    slug: string;
    name: string;
    url: string;
}
interface AuthBody {
    username: string;
    password: string;
    expiredInMins?: number;
}
interface Credential$1 {
    accessToken: string;
    refreshToken: string;
}
interface LoginData extends Credential$1 {
    id: number;
    username: string;
    email: string;
    firstName: string;
    lastName: string;
    gender: string;
    image: string;
}
interface Hair {
    color: string;
    type: string;
}
interface Coordinate {
    lat: number;
    lng: number;
}
interface Bank {
    cardExpire: string;
    cardNumber: string;
    cardType: string;
    currency: string;
    iban: string;
}
interface Address {
    address: string;
    city: string;
    state: string;
    stateCode: string;
    postalCode: string;
    coordinates: Coordinate;
    country: string;
}
interface Company {
    department: string;
    name: string;
    title: string;
    address: Address;
}
interface Crypto {
    coin: string;
    wallet: string;
    network: string;
}
interface BaseUser {
    id: number;
    firstName: string;
    lastName: string;
    maidenName: string;
    age: number;
    gender: string;
    email: string;
    phone: string;
    username: string;
    password: string;
    birthDate: string;
    image: string;
    bloodGroup: string;
    height: number;
    weight: number;
    eyeColor: string;
    hair: Hair;
    ip: string;
    address: Address;
    macAddress: string;
    university: string;
    bank: Bank;
    company: Company;
    ein: string;
    ssn: string;
    userAgent: string;
    crypto: Crypto;
    role: string;
}
type User<K extends readonly (keyof BaseUser)[] = any> = _Picked<BaseUser, K>;
interface Users<K extends readonly (keyof BaseUser)[] = any> extends Pagination {
    users: _PickedList<BaseUser, K>;
}
interface Cart extends _Identity {
    products: Product[];
    total: number;
    discounterTotal: number;
    userId: number;
    totalProducts: number;
    totalQuantity: number;
}
interface Carts extends _Identity, Pagination {
    carts: Cart[];
}
interface BaseRecipe extends _Identity {
    name: string;
    ingredients: string[];
    instructions: string[];
    prepTimeMinutes: number;
    cookTimeMinutes: number;
    servings: number;
    difficulty: string;
    cuisine: string;
    caloriesPerServing: number;
    tags: string[];
    userId: number;
    image: string;
    rating: number;
    reviewCount: number;
    mealType: string[];
}
type Recipe<K extends readonly (keyof BaseRecipe)[] = any> = _Picked<BaseRecipe, K>;
interface Recipes<K extends readonly (keyof BaseRecipe)[] = any> extends Pagination {
    recipes: _PickedList<BaseRecipe, K>;
}
interface Reaction {
    likes: number;
    dislikes: number;
}
interface BasePost extends _Identity {
    title: string;
    body: string;
    tags: string[];
    reactions: Reaction;
    views: number;
    userId: number;
}
type Post<K extends readonly (keyof BasePost)[] = any> = _Picked<BasePost, K>;
interface Posts<K extends readonly (keyof BasePost)[] = any> extends Pagination {
    posts: _PickedList<BasePost, K>;
}
type Tag = Category;
interface BaseComment extends _Identity {
    body: string;
    postId: number;
    likes: number;
    user: Pick<BaseUser, "id" | "username"> & {
        fullName: string;
    };
}
type Comment<K extends readonly (keyof BaseComment)[] = any> = _Picked<BaseComment, K>;
interface Comments<K extends readonly (keyof BaseComment)[] = any> extends Pagination {
    comments: _PickedList<BaseComment, K>;
}
interface BaseTodo extends _Identity {
    todo: string;
    completed: boolean;
    userId: number;
}
type Todo<K extends readonly (keyof BaseTodo)[] = any> = _Picked<BaseTodo, K>;
interface Todos<K extends readonly (keyof BaseTodo)[] = any> extends Pagination {
    todos: _PickedList<BaseTodo, K>;
}
interface BaseQuote extends _Identity {
    quote: string;
    author: string;
}
type Quote<K extends readonly (keyof BaseQuote)[] = any> = _Picked<BaseQuote, K>;
interface Quotes<K extends readonly (keyof BaseQuote)[] = any> extends Pagination {
    quotes: _PickedList<BaseQuote, K>;
}

declare class BaseEndpoint {
    #private;
    constructor(instance: DummyJson);
    private mergeHeaders;
    protected createRequest(options?: Pick<HttpOptions, "headers">): {
        get: <T = any>(url: string, query?: any, options?: Omit<HttpOptions, "url" | "method" | "query" | "body">) => Promise<T>;
        post: <T = any>(url: string, body?: any, options?: Omit<HttpOptions, "url" | "body" | "method">) => Promise<T>;
    };
    private handleRequest;
}

declare class AuthEndpoint extends BaseEndpoint {
    #private;
    login(body: AuthBody): Promise<LoginData>;
    me(): Promise<BaseUser>;
    refresh(body: Pick<AuthBody, "expiredInMins">): Promise<Credential>;
}

declare class CartEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Carts>;
    get(cartId: number): Promise<Cart>;
    get(by: "user", userId: number): Promise<Carts>;
}

declare class CommentEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Comments>;
    get<K extends readonly (keyof BaseComment)[]>(query: BaseQuery<BaseComment, K>): Promise<Comments<K>>;
    get(id: number): Promise<Comment>;
    get<K extends readonly (keyof BaseComment)[]>(id: number, query: BaseQuery<BaseComment, K>): Promise<Comment<K>>;
    get(by: "post", postId: number): Promise<Comments>;
    get<K extends readonly (keyof BaseComment)[]>(by: "post", postId: number, query: BaseQuery<BaseComment, K>): Promise<Comments<K>>;
}

declare class PostEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Posts>;
    get<K extends readonly (keyof BasePost)[]>(query: BaseQuery<BasePost, K>): Promise<Posts<K>>;
    get(id: number): Promise<Post>;
    get<K extends readonly (keyof BasePost)[]>(id: number, query: BaseQuery<BasePost, K>): Promise<Post<K>>;
    get(by: "tag", tag: string): Promise<Posts>;
    get<K extends readonly (keyof BasePost)[]>(by: "tag", tag: string, query: BaseQuery<BasePost, K>): Promise<Posts<K>>;
    get(by: "user", userId: number): Promise<Posts>;
    get<K extends readonly (keyof BasePost)[]>(by: "user", userId: number, query: BaseQuery<BasePost, K>): Promise<Posts<K>>;
    tags(): Promise<Tag[]>;
    tags(type: "tag-list"): Promise<string[]>;
    comments(id: number): Promise<Comments>;
    comments<K extends readonly (keyof BaseComment)[]>(id: number, query: BaseQuery<BaseComment, K>): Promise<Comments<K>>;
}

declare class ProductEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Products>;
    get<K extends readonly (keyof BaseProduct)[]>(query: BaseQuery<BaseProduct, K>): Promise<Products<K>>;
    get(id: number): Promise<BaseProduct>;
    get<K extends readonly (keyof BaseProduct)[]>(id: number, query: BaseQuery<BaseProduct, K>): Promise<Product<K>>;
    get(category: string): Promise<Products>;
    get<K extends readonly (keyof BaseProduct)[]>(category: string, query: BaseQuery<BaseProduct, K>): Promise<Products<K>>;
    search(keywords: string): Promise<Products>;
    search<K extends readonly (keyof BaseProduct)[]>(keywords: string, query: BaseQuery<BaseProduct, K>): Promise<Products<K>>;
    categories(): Promise<Category[]>;
    categories(type: "list"): Promise<string[]>;
}

declare class QuoteEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Quotes>;
    get<K extends readonly (keyof BaseQuote)[]>(query: BaseQuery<BaseQuote, K>): Promise<Quotes<K>>;
    get(id: number): Promise<Quote>;
    get<K extends readonly (keyof BaseQuote)[]>(id: number, query: BaseQuery<BaseQuote, K>): Promise<Quotes<K>>;
    random(): Promise<Quotes>;
    random(max: number): Promise<Quotes>;
}

declare class RecipeEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Recipes>;
    get<K extends readonly (keyof BaseRecipe)[]>(query: BaseQuery<BaseRecipe, K>): Promise<Recipes<K>>;
    get(id: number): Promise<Recipe>;
    get<K extends readonly (keyof BaseRecipe)[]>(id: number, query: BaseQuery<BaseRecipe, K>): Promise<Recipe<K>>;
    get(by: "tag", tag: string): Promise<Recipes>;
    get<K extends readonly (keyof BaseRecipe)[]>(by: "tag", tag: string, query: BaseQuery<BaseRecipe, K>): Promise<Recipes<K>>;
    get(by: "meal-type", meal: string): Promise<Recipes>;
    get<K extends readonly (keyof BaseRecipe)[]>(by: "meal-type", meal: string, query: BaseQuery<BaseRecipe, K>): Promise<Recipes<K>>;
}

declare class TodoEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Todos>;
    get<K extends readonly (keyof BaseTodo)[]>(query: BaseQuery<BaseTodo, K>): Promise<Todos<K>>;
    get(id: number): Promise<Todo>;
    get<K extends readonly (keyof BaseTodo)[]>(id: number, query: BaseQuery<BaseTodo, K>): Promise<Todo<K>>;
    get(by: "user", userId: number): Promise<Todos>;
    get<K extends readonly (keyof BaseTodo)[]>(by: "user", userId: number, query: BaseQuery): Promise<Todos<K>>;
    random(): Promise<Todos>;
    random(max: number): Promise<Todos>;
}

declare class UserEndpoint extends BaseEndpoint {
    #private;
    get(): Promise<Users>;
    get<K extends readonly (keyof BaseUser)[]>(query: BaseQuery<BaseUser, K>): Promise<Users<K>>;
    get(id: number): Promise<User>;
    get<K extends readonly (keyof BaseUser)[]>(id: number, query: BaseQuery<BaseUser, K>): Promise<User<K>>;
    search(keyword: string): Promise<Users>;
    search<K extends readonly (keyof BaseUser)[]>(keyword: string, query: BaseQuery<BaseUser, K>): Promise<Users<K>>;
    filter<K extends NestedKeyOf<BaseUser>>(key: K, value: GetNestedValueType<BaseUser, K>): Promise<Users>;
    filter<K extends NestedKeyOf<BaseUser>, Q extends readonly (keyof BaseUser)[]>(key: K, value: GetNestedValueType<BaseUser, K>, query: BaseQuery<BaseUser, Q>): Promise<Users<Q>>;
    carts(id: number): Promise<Carts>;
    posts(id: number): Promise<Posts>;
    todos(id: number): Promise<Quotes>;
}

declare class DummyJson {
    #private;
    baseURL: string;
    auth: AuthEndpoint;
    carts: CartEndpoint;
    comments: CommentEndpoint;
    posts: PostEndpoint;
    products: ProductEndpoint;
    quotes: QuoteEndpoint;
    recipes: RecipeEndpoint;
    todos: TodoEndpoint;
    users: UserEndpoint;
    constructor(config?: InitConfig);
    static get instance(): DummyJson;
    setAccessToken(accessToken: string): void;
    setRefreshToken(refreshToken: string): void;
    get config(): InitConfig | undefined;
}

export { type Address, type AuthBody, type Bank, type BaseComment, type BasePost, type BaseProduct, type BaseQuery, type BaseQuote, type BaseRecipe, type BaseTodo, type BaseUser, type Cart, type Carts, type Category, type Comment, type Comments, type Company, type Coordinate, type Credential$1 as Credential, type Crypto, type Dimension, DummyJson, type GetNestedValueType, type Hair, type HttpOptions, type InitConfig, type LoginData, type Meta, type NestedKeyOf, type Pagination, type Post, type Posts, type Product, type Products, type Quote, type Quotes, type Reaction, type Recipe, type Recipes, type Review, type Tag, type Todo, type Todos, type User, type Users };