import * as BluebirdPromise from 'bluebird';

export declare class CogniteSDKError extends Error {
  readonly message: string;
  readonly status?: number | undefined;
  constructor(message: string, status?: number | undefined);
}

export declare type Options = {
  baseUrl: string;
  project: string | null;
  version: string;
  apiKey: string | null;
  withCredentials: boolean;
};

export declare type Login = {
  user: string;
  loggedIn: boolean;
  project: string;
  projectId: number;
};

export declare type LoginUrl = {
  url: string;
};

export declare type Timeseries = {
  name?: string;
  isString?: boolean;
  unit?: string;
  assetId?: number;
  isStep?: boolean;
  description?: string;
  securityCategories?: number[];
  metadata?: { [K in string]: string };
  source?: string;
  sourceId?: string;
  id?: number;
  createdTime?: number;
  lastUpdatedTime?: number;
};

export declare type Asset = {
  id: number;
  name?: string;
  path?: number[];
  parentId?: number;
  description?: string;
  metadata?: { [K in string]: string };
  source?: string;
  sourceId?: string;
  createdTime?: number;
  lastUpdatedTime?: number;
  refId?: string;
  parentName?: string;
  parentRefId?: string;
};

export declare type Project = {
  name: string;
  urlName: string;
  authentication?: {
    type: string;
    protocol: string;
    azureADConfiguration: { [K in string]: string };
    validDomains: string[];
    oauth2Configuration: {};
  };
};

export declare type Event = {
  id: number;
  startTime?: number;
  endTime?: number;
  description?: string;
  type?: string;
  subtype?: string;
  assetIds?: number[];
  source?: string;
  sourceId?: string;
  createdTime?: number;
  lastUpdatedTime?: number;
  metadata?: { [K in string]: string };
};

export declare type Datapoint = {
  timestamp: number;
  value: string;
};

export declare type Row = number | null[];

export declare type DatapointsFrame = {
  columnHeaders: string[];
  rows: Row[];
};

export declare type File = {
  id?: number;
  fileName?: string;
  directory?: string;
  source?: string;
  sourceId?: string;
  fileType?: string;
  assetIds?: number[];
  uploadedAt?: number;
  createdTime?: number;
  lastUpdatedTime?: number;
  isUploaded?: boolean;
};

export declare type Items<T> = {
  items: T[];
};
export declare type Table = {
  tableName: string;
};

export declare type GetDatapointsResponse = {
  name: string;
  datapoints: Array<Datapoint>;
};

declare function get<TResult>(
  url: string,
  {
    params,
  }?: {
    params?: any;
  },
  middleware?: boolean
): Promise<TResult>;

declare function post<TResult>(
  url: string,
  body: any,
  middleware?: boolean
): Promise<TResult>;

declare function setBearerToken(token: string): void;

declare function getAccessTokenFromSession(
  silentRedirectURL: string | null
): Promise<{} | null>;

declare function configure(opts: Partial<Options>): Options;

declare function loginWithRedirect({
  project,
  redirectUrl,
  errorRedirectUrl,
}?: {
  project?: string | undefined;
  redirectUrl?: any;
  errorRedirectUrl?: any;
}): Promise<void>;

declare function loginWithApiKey(apiKey: string): Promise<Login>;

declare function tagMatching({
  project,
  platform,
  fuzzyThreshold,
  tagIds,
}: {
  project?: string | undefined;
  platform?: string | undefined;
  fuzzyThreshold?: number | undefined;
  tagIds?: never[] | undefined;
}): Promise<{}>;

declare function unsetApiKey(): void;

declare function logout({
  redirectUrl,
}: {
  redirectUrl?: null | undefined;
}): Promise<string>;

declare function getAsset({
  project,
  assetId,
}: {
  project?: string;
  assetId: number;
}): Promise<Items<Asset>>;

declare function getAssetSubtree({
  project,
  assetId,
  ...params
}: {
  project?: string;
  assetId: number;
  [key: string]: any;
}): Promise<Items<Asset>>;

declare function getAssets({
  project,
  ...params
}: {
  project?: string | undefined;
  [key: string]: any;
}): Promise<Items<Asset>>;

declare function searchAssets({
  project,
  assetSubtrees,
  ...params
}: {
  project?: string;
  assetSubtrees?: number[];
  [key: string]: any;
}): Promise<Items<Asset>>;

declare function getProject({
  project,
}: {
  project?: string | undefined;
}): Promise<Items<Project>>;

declare function getEvents({
  project,
  ...params
}: {
  [x: string]: any;
  project?: string | undefined;
}): Promise<Items<Event>>;

declare function getEvent({
  project,
  id,
}: {
  project?: string;
  id: number;
}): Promise<Items<Event>>;

declare function searchEvents({
  project,
  assetSubtrees,
  ...params
}: {
  project?: string;
  assetSubtrees?: number[];
  [key: string]: any;
}): Promise<Items<Event>>;

declare function createEvents({
  project,
  body,
}: {
  project?: string;
  body: Items<Partial<Event>>;
}): Promise<Items<Event>>;

declare function updateEvents({
  project,
  body,
}: {
  project?: string;
  body: Items<Partial<Event>>;
}): Promise<Items<Event>>;

declare function getTimeSeries({
  project,
  ...params
}?: {
  project?: string | undefined;
  [key: string]: any;
}): Promise<Items<Timeseries>>;

declare function getDatapoints({
  project,
  name,
  ...params
}: {
  project?: string;
  name: string;
  [key: string]: any;
}): Promise<Items<GetDatapointsResponse>>;

declare function getDatapointsFrame({
  project,
  body,
}: {
  project?: string;
  body: any;
}): Promise<DatapointsFrame>;

declare function getLatestDataPoint({
  project,
  name,
  ...params
}: {
  project?: string;
  name: string;
  [key: string]: any;
}): Promise<Items<Datapoint>>;

declare function getFiles({
  project,
  ...params
}: {
  [x: string]: any;
  project?: string | undefined;
}): Promise<Items<File>>;

declare function getFile({
  project,
  id,
}: {
  project?: string;
  id: number;
  [key: string]: any;
}): Promise<Items<File>>;

declare function searchFiles({
  project,
  assetSubtrees,
  assetIds,
  metadata,
  ...params
}: {
  project?: string;
  assetSubtrees?: number[];
  assetIds?: number[];
  metadata?: { [key: string]: string };
  [key: string]: any;
}): Promise<Items<File>>;

declare function getDownloadLink({
  project,
  id,
}: {
  project?: string;
  id: number;
  [key: string]: any;
}): Promise<string>;

declare function timeseriesSearch({
  project,
  q,
  asset,
  ...rest
}: {
  project?: string;
  q: string;
  asset: string;
  [key: string]: any;
}): BluebirdPromise<Timeseries[]>;

declare function searchTimeSeries({
  project,
  assetIds,
  assetSubtrees,
  ...params
}: {
  project?: string;
  q: string;
  assetIds: number[];
  assetSubtrees: number[];
}): Promise<Items<Timeseries>>;

declare function getTablesInDatabase({
  apiKey,
  project,
  dbName,
}: {
  apiKey?: string;
  project?: string;
  dbName: string;
}): Promise<Items<Table>>;

declare function createTable({
  apiKey,
  project,
  dbName,
}: {
  apiKey?: string;
  project?: string;
  table: string;
  dbName: string;
}): Promise<Items<Table>>;

declare const _default: {
  loginWithRedirect: typeof loginWithRedirect;
  getLoginStatus: () => Promise<Login>;
  configure: typeof configure;
  logout: typeof logout;
  getAssets: typeof getAssets;
  getAssetSubtree: typeof getAssetSubtree;
  getAsset: typeof getAsset;
  searchAssets: typeof searchAssets;
  loginWithApiKey: typeof loginWithApiKey;
  unsetApiKey: typeof unsetApiKey;
  getProject: typeof getProject;
  getEvents: typeof getEvents;
  getEvent: typeof getEvent;
  searchEvents: typeof searchEvents;
  createEvents: typeof createEvents;
  updateEvents: typeof updateEvents;
  getLatestDataPoint: typeof getLatestDataPoint;
  getTimeSeries: typeof getTimeSeries;
  getDatapointsFrame: typeof getDatapointsFrame;
  get: typeof get;
  post: typeof post;
  getDatapoints: typeof getDatapoints;
  tagMatching: typeof tagMatching;
  getFiles: typeof getFiles;
  getFile: typeof getFile;
  getDownloadLink: typeof getDownloadLink;
  timeseriesSearch: typeof timeseriesSearch;
  searchTimeSeries: typeof searchTimeSeries;
  getAccessTokenFromSession: typeof getAccessTokenFromSession;
  setBearerToken: typeof setBearerToken;
  getTablesInDatabase: typeof getTablesInDatabase;
  createTable: typeof createTable;
};

export default _default;