import { ContentType } from '@coolio/http';
export interface Attributes {
    [x: string]: any;
}
export declare type RelationshipData<Type extends string = string> = {
    id: string;
    type: Type;
};
export declare type RelationshipType<Type extends string = string> = RelationshipData<Type> | RelationshipData<Type>[];
declare type RawRelationship<T> = {
    data: T;
    links?: {
        self?: string;
        related: string;
    };
    related?: string;
};
export declare type Relationship = RawRelationship<RelationshipData>;
export declare type RelationshipArray = RawRelationship<RelationshipData[]>;
export declare type ResolvedRelationship<D extends AnyData = AnyData> = RawRelationship<D>;
export declare type ResolvedRelationshipArray<D extends AnyData = AnyData> = RawRelationship<D[]>;
export declare type Relationships = Record<string, RawRelationship<RelationshipType> | undefined>;
export declare type UnresolvedRelationships = Record<string, Relationship | RelationshipArray>;
export declare type ResolvedRelationships = Record<string, ResolvedRelationship | ResolvedRelationshipArray | undefined>;
export declare type OptionalRels = Relationships | undefined;
export declare type IncludedRelationships<D extends AnyData = AnyData> = D[];
export interface Data<Attrs extends Attributes, Rels extends OptionalRels = {}> {
    id: string;
    type: string;
    attributes: Attrs;
    relationships: Rels;
    links: {
        self: string;
    };
}
export declare type AnyData = Data<any, any>;
declare type EmptyRecord = {
    [key: string]: never;
};
export declare type AttributesOf<D> = D extends {
    attributes: Attributes;
} ? D['attributes'] : EmptyRecord;
export declare type RelationshipsOf<D> = D extends {
    relationships: Relationships;
} ? D['relationships'] : EmptyRecord;
/**
 * MergeData type
 * --------------
 * This sophisticated type allows to correctly infer nicely formatted data from JSON API format.
 * `id`, `type`, `attributes` and `relationships` suddenly become a single, combined object with easy access to it.
 * Same is applied to arrays.
 */
export declare type MergedData<D> = D extends AnyData ? (AttributesOf<D> & (RelationshipsOf<D> extends Relationships ? {
    [k in keyof RelationshipsOf<D>]: MergedData<RelationshipsOf<D>[k]['data']>;
} : RelationshipsOf<D>) & ({
    id: string;
    type: string;
    self: string;
})) : D extends AnyData[] ? (AttributesOf<D[0]> & (RelationshipsOf<D[0]> extends Relationships ? {
    [k in keyof RelationshipsOf<D[0]>]: MergedData<RelationshipsOf<D[0]>[k]['data']>;
} : RelationshipsOf<D[0]>) & ({
    id: string;
    type: string;
    self: string;
}))[] : (D extends RelationshipData ? D['id'] : D extends RelationshipData[] ? D[0]['id'][] : never);
export interface ListMetaData {
    totalResourceCount: number;
}
/**
 * Included groups
 * ---------------
 * Included groups allow you to extract stuff from 'included' JSON API field
 * basing on specified name-type pairs, and add proper types to it.
 *
 */
export interface IncludedGroup<D extends AnyData = AnyData> {
    type: string;
    __d: D;
}
export declare type IncludedGroupsSchema = Record<string, IncludedGroup>;
export declare type IncludedGroups<Groups extends IncludedGroupsSchema = IncludedGroupsSchema> = {
    [k in keyof Groups]: Groups[k]['__d'][];
};
export declare type MergedIncludedGroups<G extends IncludedGroups<any>> = {
    [k in keyof G]: MergedData<G[k]>;
};
/**
 * This interface covers JSON API response for single element.
 */
export interface RawResponse<D extends AnyData, M extends {} = {}> {
    data: D;
    meta?: M;
    included?: IncludedRelationships;
}
/**
 * This interface covers JSON API response for multiple elements.
 */
export interface RawListResponse<D extends AnyData, M extends ListMetaData = ListMetaData> {
    data: D[];
    links: {
        self?: string;
        first: string;
        next?: string;
        prev?: string;
        last: string;
    };
    included?: IncludedRelationships;
    meta: M;
}
export declare const Headers: {
    'Content-Type': ContentType;
    Accept: ContentType;
};
export declare enum SortOrder {
    ASCENDING = "",
    DESCENDING = "-"
}
export {};
//# sourceMappingURL=types.d.ts.map