/// <reference types="es6-promise" />
declare module 'cs-core-sdk/core/error' {
	/**
	 * @export
	 * @class CSSDKError
	 */
	export class CSSDKError {
	  constructor(message?: any, payload?: any);
	}

	/**
	 * @export
	 * @class WebApiError
	 * @extends {CSSDKError}
	 */
	export class WebApiError extends CSSDKError {
	  constructor(message?: any, payload?: any);
	  getStatusCode(): number;
	}

	/**
	 * @export
	 * @class ConfigurationError
	 * @extends {CSSDKError}
	 */
	export class ConfigurationError extends CSSDKError {
	  constructor(message?: any, payload?: any);
	}
}
declare module 'cs-core-sdk/core/environment' {
	/**
	 * Environment object that specifies communication endpoints for the SDK
	 * @export
	 * @class Environment
	 */
	export class Environment {
	    /**
	     * Sandbox environment. This is the default one. Use it for development.
	     */
	    static Sandbox: Environment;
	    /**
	     * Production environment of CSAS. Use it in production with production API Key.
	     */
	    static Production: Environment;
	    /**
	    * Base URL path. Start of API context
	    */
	    apiContextBaseUrl: string;
	    /**
	     Base URL path for OAuth2 authentication.
	    */
	    oAuth2ContextBaseUrl: string;
	    /**
	     * Creates new Environment instance
	     *
	     * @param apiContextBaseUrl Base URL path. Start of API context
	     * @param oAuth2ContextBaseUrl Base URL path for OAuth2 authentication.
	     */
	    constructor(apiContextBaseUrl: string, oAuth2ContextBaseUrl: string);
	}

}
declare module 'cs-core-sdk/core/web-api-configuration' {
	import { Environment } from 'cs-core-sdk/core/environment';
	/**
	 * Configuration of SDK
	 * @export
	 * @class WebApiConfiguration
	 */
	export class WebApiConfiguration {
	    /**
	     * WebApi key to use
	     */
	    webApiKey: string;
	    /**
	     * Language to use. Defaults to 'cs-CZ'
	     */
	    language: string;
	    /**
	     * Signing key for request signing. It is not set by default.
	     */
	    signingKey: string;
	    /**
	     * Environment to use. Default is Sandbox environment
	     */
	    environment: Environment;
	    /**
	   * Oath2 configuration. It is not set by default.
	   */
	    oauth2: Oauth2Config;
	    /**
	     * Copies the configuration.
	     * @returns {WebApiConfiguration}
	     *
	     * @memberOf WebApiConfiguration
	     */
	    copy(): WebApiConfiguration;
	}
	/**
	 * Configuration of oAuth2
	 * @export
	 * @interface Oauth2Config
	 */
	export interface Oauth2Config {
	    /**
	     * ID of the client
	     */
	    clientId: string;
	    /**
	     * secret of the client
	     */
	    clientSecret?: string;
	    /**
	     * URI where client will be redirected upon logging in
	     */
	    redirectUri?: string;
	}

}
declare module 'cs-core-sdk/core/signer' {
	/**
	 * @export
	 * @class Signer
	 */
	export class Signer {
	    private _apiKey;
	    private _privateKey;
	    /**
	     * Creates an instance of Signer.
	     * @param {string} apiKey
	     * @param {string} privateKey
	     *
	     * @memberOf Signer
	     */
	    constructor(apiKey: string, privateKey: string);
	    /**
	     * @returns {string}
	     *
	     * @memberOf Signer
	     */
	    generateNonce(): string;
	    /**
	     * @param {string} url
	     * @param {string} data
	     * @param {string} nonce
	     * @returns {string}
	     *
	     * @memberOf Signer
	     */
	    generateSignatureForRequest(url: string, data: string, nonce: string): string;
	    /**
	     * @param {string} url
	     * @param {string} data
	     * @param {object} headers
	     *
	     * @memberOf Signer
	     */
	    signRequest(url: string, data: string, headers: any): void;
	    /**
	     * @param {any} url
	     * @returns {string}
	     *
	     * @memberOf Signer
	     */
	    stripServer(url: any): string;
	}

}
declare module 'cs-core-sdk/web-api/web-api-client' {
	import { WebApiConfiguration } from 'cs-core-sdk/core/web-api-configuration';
	import { WebApiContext } from 'cs-core-sdk/core/web-api-context';
	/**
	 * @export
	 * @interface CallOptions
	 */
	export interface CallOptions {
	    url: string;
	    method?: string;
	    params?: any;
	    data?: any;
	}
	/**
	 * @export
	 * @interface Response
	 */
	export interface Response {
	    data?: any;
	    status?: number;
	    headers?: any;
	    config?: any;
	}
	/**
	 * @export
	 * @abstract
	 * @class WebApiClient
	 * @implements {PathSegment}
	 */
	export abstract class WebApiClient implements PathSegment {
	    config: WebApiConfiguration;
	    sharedContext: WebApiContext;
	    private apiBasePath;
	    static GlobalRequestHeaders: any;
	    /**
	     * Creates an instance of WebApiClient.
	     * @param {WebApiConfiguration} config
	     * @param {string} basePath
	     *
	     * @memberOf WebApiClient
	     */
	    constructor(config: WebApiConfiguration, basePath: string);
	    /**
	     * Returns Base URL for all resources in this client.
	     * @returns {string}
	     *
	     * @memberOf WebApiClient
	     */
	    getPath(): string;
	    /**
	     * Prepares request for API call
	     * @param {string} url
	     * @param {string} method
	     * @param {any=} params
	     * @param {any=} data
	     * @param {any=} headers
	     * @param {string} [responseType]
	     * @returns {Promise<any>}
	     *
	     * @memberOf WebApiClient
	     */
	    callApi(url: string, method: string, params?: any, data?: any, headers?: any, responseType?: string): Promise<any>;
	    /**
	     * @private
	     * @param {string} url
	     * @param {string} method
	     * @param {any=} params
	     * @param {any=} data
	     * @param {any=} headers
	     * @param {string=} responseType
	     * @returns {any}
	     *
	     * @memberOf WebApiClient
	     */
	    private makeCall(url, method, params?, data?, headers?, responseType?);
	    private _ensureRightConfiguration;
	}
	/**
	 * @export
	 * @interface PathSegment
	 */
	export interface PathSegment {
	    /**
	     * @returns {string}
	     *
	     * @memberOf PathSegment
	     */
	    getPath(): string;
	}

}
declare module 'cs-core-sdk/core/access-token-provider' {
	import { WebApiClient } from 'cs-core-sdk/web-api/web-api-client';
	import { WebApiConfiguration } from 'cs-core-sdk/core/web-api-configuration';
	/**
	 * @export
	 * @class AccessTokenProvider
	 * @implements {AccessTokenProviderInterface}
	 */
	export class AccessTokenProvider implements AccessTokenProviderInterface {
	    private token;
	    private client;
	    private code;
	    private secret;
	    /**
	     * Set access token given in initialization
	     * @param {WebApiConfiguration} config
	     */
	    constructor(config: WebApiConfiguration);
	    /**
	     * Set token and expiration properties of a given tokeng
	     * @param {AccessToken|string} token
	     * @returns {void}
	     */
	    useAccessToken(token: AccessToken | string): void;
	    /**
	     * @param {string} code
	     */
	    useCode(code: string): void;
	    /**
	     * @returns {string}
	     */
	    getCode(): string;
	    /**
	     * @returns {Promise<AccessToken>}
	     */
	    getAccessToken(): Promise<AccessToken>;
	    /**
	     * Refresh access token and return it in promise
	     * @returns {Promise<AccessToken>}
	     */
	    refreshAccessToken(): Promise<AccessToken>;
	    /**
	     * Helper method to join and encode data
	     * @private
	     * @param {any} data
	     * @returns {string}
	     */
	    private joinAndEncodeData(data);
	}
	/**
	 * @export
	 * @interface AccessTokenProviderInterface
	 */
	export interface AccessTokenProviderInterface {
	    /**
	     * Returns access token
	     */
	    getAccessToken(): Promise<AccessToken>;
	    /**
	     * Calls the API in order to refresh token and returns
	     */
	    refreshAccessToken(): Promise<AccessToken>;
	    /**
	     * Sets access token on
	     */
	    useAccessToken(token: AccessToken | string): void;
	    useCode(string: any): void;
	    getCode(): string;
	}
	/**
	 * @export
	 * @interface AccessToken
	 */
	export interface AccessToken {
	    token: string;
	    expiresIn: number;
	    tokenType: string;
	    refreshToken?: string;
	}
	/**
	 * @export
	 * @class AccessTokenProviderClient
	 * @extends {WebApiClient}
	 */
	export class AccessTokenProviderClient extends WebApiClient {
	    constructor(config: any);
	}

}
declare module 'cs-core-sdk/core/oauth-provider' {
	import { WebApiConfiguration } from 'cs-core-sdk/core/web-api-configuration';
	import { AccessTokenProvider, AccessToken } from 'cs-core-sdk/core/access-token-provider';
	/**
	 * @export
	 * @class OauthProvider
	 * @implements {OathInterface}
	 */
	export class OauthProvider implements OathInterface {
	    accessTokenProvider: AccessTokenProvider;
	    config: WebApiConfiguration;
	    /**
	     * Creates an instance of OauthProvider.
	     * @param {AccessTokenProvider} accessTokenProvider
	     * @param {WebApiConfiguration} config
	     *
	     * @memberOf OauthProvider
	     */
	    constructor(accessTokenProvider: AccessTokenProvider, config: WebApiConfiguration);
	    /**
	     * Returns url for authentication based on provided config
	     * @returns {string}
	     *
	     * @memberOf OauthProvider
	     */
	    getOauth2Url(): string;
	    /**
	     * Parses callback uri and extracts information that is used for requesting access token
	     *
	     * @param {string} url
	     * @returns {Promise<AccessToken>}
	     *
	     * @memberOf OauthProvider
	     */
	    processRedirect(url: string): Promise<AccessToken>;
	}
	/**
	 * @export
	 * @interface OathInterface
	 */
	export interface OathInterface {
	    getOauth2Url(): string;
	    processRedirect(url: string): any;
	}

}
declare module 'cs-core-sdk/core/web-api-context' {
	import { OauthProvider, OathInterface } from 'cs-core-sdk/core/oauth-provider';
	import { AccessTokenProvider, AccessTokenProviderInterface, AccessToken } from 'cs-core-sdk/core/access-token-provider';
	/**
	 * @export
	 * @class WebApiContext
	 * @implements {AccessTokenProviderInterface}
	 * @implements {OathInterface}
	 */
	export class WebApiContext implements AccessTokenProviderInterface, OathInterface {
	    accessTokenProvider: AccessTokenProvider;
	    oauthProvider: OauthProvider;
	    /**
	     * Delegate getAccessToken call to accessTokenProvider if there is any
	     * @returns {Promise<AccessToken>}
	     *
	     * @memberOf WebApiContext
	     */
	    getAccessToken(): Promise<AccessToken>;
	    /**
	     * Delegate refreshAccessToken call to accessTokenProvider if there is any
	     * @returns {Promise<AccessToken>}
	     *
	     * @memberOf WebApiContext
	     */
	    refreshAccessToken(): Promise<AccessToken>;
	    /**
	   * Returns login url to CSAS MEP in string
	   * @returns {string}
	   *
	   * @memberOf WebApiContext
	   */
	    getOauth2Url(): string;
	    /**
	   * Extracts access token from redirect url and sets it on AccessTokenProvider
	   * @param {string} url
	   * @returns {Promise<AccessToken>}
	   *
	   * @memberOf WebApiContext
	   */
	    processRedirect(url: string): Promise<AccessToken>;
	    /**
	     * Set AccessToken on AccessTokenProvider
	     * @param {(AccessToken | string)} token
	     * @returns {void}
	     *
	     * @memberOf WebApiContext
	     */
	    useAccessToken(token: AccessToken | string): void;
	    /**
	     * Set code on accessTokenProvider that is used for retrieving access token if you are using Authorization Code grant type
	     * @param {string} code
	     * @returns {void}
	     *
	     * @memberOf WebApiContext
	     */
	    useCode(code: string): void;
	    /**
	   * Returns code on accessTokenProvider that is used for retrieving access token if you are using Authorization Code grant type
	   * @returns {string}
	   *
	   * @memberOf WebApiContext
	   */
	    getCode(): string;
	    /**
	     * Ensure that accessTokenProvider is set
	     * @private
	     * @returns {void}
	     *
	     * @memberOf WebApiContext
	     */
	    private _ensureRightConfiguration();
	}

}
declare module 'cs-core-sdk/core/core' {
	export * from 'cs-core-sdk/core/error';
	export { WebApiConfiguration } from 'cs-core-sdk/core/web-api-configuration';
	export { WebApiContext } from 'cs-core-sdk/core/web-api-context';
	export { Environment } from 'cs-core-sdk/core/environment';
	export { Signer } from 'cs-core-sdk/core/signer';

}
declare module 'cs-core-sdk/web-api/lists' {
	/**
	 * @export
	 * @class ListResponseStructure
	 * @implements {ListResponse<T>}
	 * @template T
	 */
	export class ListResponseStructure<T> implements ListResponse<T> {
	    /**
	     * @type {T[]}
	     * @memberOf ListResponseStructure
	     */
	    items: T[];
	}
	export class PaginatedListResponseStructure<T> implements PaginatedListResponse<T> {
	    /**
	     * Information about pagination
	     * @type {Pagination}
	     * @memberOf PaginatedListResponseStructure
	     */
	    pagination: Pagination;
	    /**
	     * Items in list
	     *
	     * @type {T[]}
	     * @memberOf PaginatedListResponseStructure
	     */
	    items: T[];
	    /**
	     * Returns a promise that resolves into next page of results
	     * @returns {Promise<PaginatedListResponse<T>>}
	     *
	     * @memberOf PaginatedListResponseStructure
	     */
	    nextPage: () => Promise<PaginatedListResponse<T>>;
	    /**
	     * Returns a promise that resolves into previous page of results
	     * @returns {Promise<PaginatedListResponse<T>>}
	     *
	     * @memberOf PaginatedListResponseStructure
	     */
	    prevPage: () => Promise<PaginatedListResponse<T>>;
	}
	/**
	 * @export
	 * @interface Pagination
	 */
	export interface Pagination {
	    /**
	     * Current page number
	     * @type {number}
	     * @memberOf Pagination
	     */
	    pageNumber: number;
	    /**
	     * Number of items per page
	     * @type {number}
	     * @memberOf Pagination
	     */
	    pageSize: number;
	    /**
	     * Number of pages
	     * @type {number}
	     * @memberOf Pagination
	     */
	    pageCount: number;
	    /**
	     * Next page number
	     * @type {number}
	     * @memberOf Pagination
	     */
	    nextPage: number;
	    /**
	     * Previous page number
	     * @type {number}
	     * @memberOf Pagination
	     */
	    prevPage: number;
	    /**
	     * Whether there is next page available
	     * @type {boolean}
	     * @memberOf Pagination
	     */
	    hasNextPage: boolean;
	    /**
	     * Whether there is previous page available
	     * @type {boolean}
	     * @memberOf Pagination
	     */
	    hasPrevPage: boolean;
	}
	/**
	 * List of non-paginated items.
	 * @export
	 * @interface ListResponse
	 * @template T
	 */
	export interface ListResponse<T> {
	    /**
	     * Items in list
	     * @type {T[]}
	     * @memberOf ListResponse
	     */
	    items: T[];
	}
	/**
	 * List of paginated items
	 * @export
	 * @interface PaginatedListResponse
	 * @extends {ListResponse<T>}
	 * @template T
	 */
	export interface PaginatedListResponse<T> extends ListResponse<T> {
	    /**
	     * Information about pagination
	     *
	     * @type {ResponsePagination}
	     * @memberOf PaginatedListResponse
	     */
	    pagination: ResponsePagination;
	    /**
	     * Returns a promise that resolves into next page of results
	     * @returns {Promise<PaginatedListResponse<T>>}
	     *
	     * @memberOf PaginatedListResponse
	     */
	    nextPage: () => Promise<PaginatedListResponse<T>>;
	    /**
	     * Returns a promise that resolves into previous page of results
	     * @returns {Promise<PaginatedListResponse<T>>}
	     *
	     * @memberOf PaginatedListResponse
	     */
	    prevPage: () => Promise<PaginatedListResponse<T>>;
	}
	export enum Order {
	    ASCENDING = "asc",
	    DESCENDING = "desc",
	}
	/**
	 * @export
	 * @interface Sortable
	 */
	export interface Sortable<T> {
	    sort?: T | T[] | string | string[];
	    order?: Order | Order[] | string | string[];
	}
	export interface Paginated {
	    pageNumber: number;
	    pageSize: number;
	}
	export interface ResponsePagination {
	    /**
	     * Current page number
	     */
	    pageNumber: number;
	    /**
	     * Number of items per page
	     */
	    pageSize: number;
	    /**
	     * Number of pages
	     */
	    pageCount: number;
	    /**
	     * Next page number
	     */
	    nextPage: number;
	    /**
	     * Prev page number
	     */
	    prevPage: number;
	    /**
	     * Whether there is next page available
	     */
	    hasNextPage: boolean;
	    /**
	     * Whether there is previous page available
	     */
	    hasPrevPage: boolean;
	}

}
declare module 'cs-core-sdk/web-api/resource' {
	import { WebApiClient, PathSegment } from 'cs-core-sdk/web-api/web-api-client';
	/**
	 * @export
	 * @abstract
	 * @class Resource
	 * @implements {PathSegment}
	 */
	export abstract class Resource implements PathSegment {
	    protected _client: WebApiClient;
	    protected _path: string;
	    /**
	     * Creates an instance of Resource.
	     * @param {string} basePath
	     * @param {WebApiClient} client
	     *
	     * @memberOf Resource
	     */
	    constructor(basePath: string, client: WebApiClient);
	    /**
	     * Returns the associated WebApiClient
	     * @returns {WebApiClient}
	     *
	     * @memberOf Resource
	     */
	    getClient(): WebApiClient;
	    /**
	     * Returns current URL path
	     * @returns {string}
	     *
	     * @memberOf Resource
	     */
	    getPath(): string;
	    /**
	     * @protected
	     * @param {string} appendix
	     * @returns {string}
	     *
	     * @memberOf Resource
	     */
	    protected pathAppendedWith(appendix: string): string;
	    /**
	     * @protected
	     * @param {any=} params
	     * @returns {Promise<any>}
	     *
	     * @memberOf Resource
	     */
	    protected _get(params?: any): Promise<any>;
	    /**
	     * @protected
	     * @param {string} pathSuffix
	     * @param {any=} params
	     * @returns {Promise<any>}
	     *
	     * @memberOf Resource
	     */
	    protected _getWithSuffix(pathSuffix: string, params?: any): Promise<any>;
	}

}
declare module 'cs-core-sdk/web-api/instance-resource' {
	import { Resource } from 'cs-core-sdk/web-api/resource';
	import { WebApiClient } from 'cs-core-sdk/web-api/web-api-client';
	/**
	 * @export
	 * @abstract
	 * @class InstanceResource
	 * @extends {Resource}
	 */
	export abstract class InstanceResource extends Resource {
	    protected _id: any;
	    /**
	     * Creates an instance of InstanceResource.
	     * @param {any} id
	     * @param {string} basePath
	     * @param {WebApiClient} client
	     *
	     * @memberOf InstanceResource
	     */
	    constructor(id: any, basePath: string, client: WebApiClient);
	    /**
	     * Returns id of the WebApi entity this instance resource represents
	     * @readonly
	     * @type {any}
	     * @memberOf InstanceResource
	     */
	    readonly id: any;
	    /**
	     * Returns utl path of this instance resource
	     * @returns {string}
	     *
	     * @memberOf InstanceResource
	     */
	    getPath(): string;
	}

}
declare module 'cs-core-sdk/signing/filled-signing-object' {
	import { SigningObject } from 'cs-core-sdk/signing/signing-object';
	import { WebApiClient } from 'cs-core-sdk/web-api/web-api-client';
	import { TacSigningProcess, NoAuthSigningProcess, CaseMobileSigningProcess } from 'cs-core-sdk/signing/signing-process';
	/**
	 * @export
	 * @class FilledSigningObject
	 * @extends {SigningObject}
	 */
	export class FilledSigningObject extends SigningObject {
	    authorizationType: string;
	    scenarios: [[string]];
	    /**
	     * Creates an instance of FilledSigningObject.
	     * @param {GetInfoResponse} response
	     * @param {WebApiClient} client
	     * @param {string} url
	     * @param {any} order
	     *
	     * @memberOf FilledSigningObject
	     */
	    constructor(response: GetInfoResponse, client: WebApiClient, url: string, order: any);
	    /**
	     * Returns itself in Promise.
	     * @returns {Promise<FilledSigningObject>}
	     *
	     * @memberOf FilledSigningObject
	     */
	    getInfo: () => Promise<FilledSigningObject>;
	    /**
	     * Starts signing process with TAC (that usually means signing using OneTimePassword from SMS)
	     * This method will inform the API that the client will sign using TAC.
	     * Returned 'TACSigningProcess' is used to finish the signing or throws Error if the call fails
	     * @returns {Promise<TacSigningProcess>}
	     *
	     * @memberOf FilledSigningObject
	     */
	    startSigningWithTac: () => Promise<TacSigningProcess>;
	    /**
	     * Starts signing process with CASE_MOBILE (that usually means signing using OneTimePassword from SMS)
	     * This method will inform the API that the client will sign using CASE_MOBILE.
	     * Returned 'CaseMobileSigningProcess' is used to finish the signing or throws Error if the call fails
	     * @returns {Promise<CaseMobileSigningProcess>}
	     *
	     * @memberOf FilledSigningObject
	     */
	    startSigningWithCaseMobile: () => Promise<CaseMobileSigningProcess>;
	    /**
	     * Starts signing process with NO_AUTHORIZATION (that usually means signing the order just by clicking some button in UI)
	     * This method signalizes the intent to the API that this order will be signed using NO_AUTHORIZATION method
	     * Returned 'NoAuthSigningProcess' is used to finish the signing or throws Error if the call fails
	     * @returns {Promise<NoAuthSigningProcess>}
	     *
	     * @memberOf FilledSigningObject
	     */
	    startSigningWithNoAuthorization: () => Promise<NoAuthSigningProcess>;
	    /**
	     * Determines whether the signing can be currently done with the given AuthorizationType.
	     * @param {string} authorizationType
	     * @returns {boolean}
	     *
	     * @memberOf FilledSigningObject
	     */
	    canBeSignedWith: (authorizationType: string) => boolean;
	    /**
	     * List all current possible authorization types. The list will be empty if the entity is not in a signable state.
	     * @returns {string[]}
	     *
	     * @memberOf FilledSigningObject
	     */
	    getPossibleAuthorizationTypes: () => string[];
	}
	/**
	 * @export
	 * @interface GetInfoResponse
	 */
	export interface GetInfoResponse {
	    authorizationType: string;
	    scenarios: [[string]];
	    signInfo: {
	        state: string;
	        signId: string;
	    };
	}

}
declare module 'cs-core-sdk/signing/signing-process' {
	import { FilledSigningObject } from 'cs-core-sdk/signing/filled-signing-object';
	import { RequestSigner } from 'cs-core-sdk/signing/request-signer';
	import { SigningObject } from 'cs-core-sdk/signing/signing-object';
	/**
	 *
	 *
	 * @export
	 * @class SigningProcess
	 */
	export class SigningProcess {
	    signingObject: SigningObject;
	    protected requestSigner: RequestSigner;
	    /**
	     * Creates an instance of SigningProcess.
	     * @param {RequestSigner} requestSigner
	     * @param {SigningObject} signingObject
	     *
	     * @memberOf SigningProcess
	     */
	    constructor(requestSigner: RequestSigner, signingObject: SigningObject);
	}
	/**
	 * @export
	 * @class TacSigningProcess
	 * @extends {SigningProcess}
	 */
	export class TacSigningProcess extends SigningProcess {
	    /**
	     * Creates an instance of TacSigningProcess.
	     * @param {RequestSigner} requestSigner
	     * @param {SigningObject} signingObject
	     *
	     * @memberOf TacSigningProcess
	     */
	    constructor(requestSigner: RequestSigner, signingObject: SigningObject);
	    /**
	     * Finishes signing process with TAC (that usually means signing using OneTimePassword from SMS)
	     * You can call this method only if you successfully called `startSigningWithTac` before.
	     * @param {string} oneTimePassword
	     * @returns {Promise<SigningObject>}
	     *
	     * @memberOf TacSigningProcess
	     */
	    finishSigning: (oneTimePassword: string) => Promise<SigningObject>;
	}
	/**
	 * @export
	 * @class CaseMobileSigningProcess
	 * @extends {SigningProcess}
	 */
	export class CaseMobileSigningProcess extends SigningProcess {
	    /**
	     * Creates an instance of CaseMobileSigningProcess.
	     * @param {RequestSigner} requestSigner
	     * @param {SigningObject} signingObject
	     *
	     * @memberOf CaseMobileSigningProcess
	     */
	    constructor(requestSigner: RequestSigner, signingObject: SigningObject);
	    /**
	     * Finishes signing process with CASE_MOBILE (that usually means signing using OneTimePassword from SMS)
	     * You can call this method only if you successfully called `startSigningWithCaseMobile` before.
	     * @param {string} oneTimePassword
	     * @returns {Promise<SigningObject>}
	     *
	     * @memberOf CaseMobileSigningProcess
	     */
	    finishSigning: (oneTimePassword: string) => Promise<SigningObject>;
	}
	/**
	 * @export
	 * @class NoAuthSigningProcess
	 * @extends {SigningProcess}
	 */
	export class NoAuthSigningProcess extends SigningProcess {
	    /**
	     * Creates an instance of NoAuthSigningProcess.
	     * @param {RequestSigner} requestSigner
	     * @param {SigningObject} signingObject
	     *
	     * @memberOf NoAuthSigningProcess
	     */
	    constructor(requestSigner: RequestSigner, signingObject: SigningObject);
	    /**
	     * Finishes signing process using NO_AUTHORIZATION method
	     * You can call this method only if you successfully called `startSigningWithNoAuthorization` before.
	     * @returns {Promise<FilledSigningObject>}
	     *
	     * @memberOf NoAuthSigningProcess
	     */
	    finishSigning: () => Promise<FilledSigningObject>;
	}

}
declare module 'cs-core-sdk/signing/request-signer' {
	import { WebApiClient } from 'cs-core-sdk/web-api/web-api-client';
	import { Signable } from 'cs-core-sdk/web-api/api-query';
	import { TacSigningProcess, NoAuthSigningProcess, CaseMobileSigningProcess } from 'cs-core-sdk/signing/signing-process';
	import { FilledSigningObject } from 'cs-core-sdk/signing/filled-signing-object';
	import { SigningObject } from 'cs-core-sdk/signing/signing-object';
	/**
	 * @export
	 * @class RequestSigner
	 */
	export class RequestSigner {
	    private client;
	    private url;
	    /**
	     * Creates an instance of RequestSigner.
	     * @param {WebApiClient} client
	     * @param {string} url
	     *
	     * @memberOf RequestSigner
	     */
	    constructor(client: WebApiClient, url: string);
	    /**
	     * Obtains current signing info with full details from the API.
	     * @param {string} signId
	     * @param {Signable} order
	     *
	     * @memberOf RequestSigner
	     */
	    getSigningInfo: (signId: string, order: Signable) => Promise<FilledSigningObject>;
	    /**
	     * Starts signing process with TAC (that usually means signing using OneTimePassword from SMS)
	     * This method will inform the API that the client will sign using TAC.
	     * @param {string} signId
	     * @returns {Promise<TacSigningProcess>}
	     *
	     * @memberOf RequestSigner
	     */
	    startSigningWithTac: (signId: string) => Promise<TacSigningProcess>;
	    /**
	     * Starts signing process with CASE_MOBILE (that usually means signing using OneTimePassword from SMS)
	     * This method will inform the API that the client will sign using CASE_MOBILE.
	     * @param {string} signId
	     * @returns {Promise<CaseMobileSigningProcess>}
	     *
	     * @memberOf RequestSigner
	     */
	    startSigningWithCaseMobile: (signId: string) => Promise<CaseMobileSigningProcess>;
	    /**
	     * Starts signing process with NO_AUTHORIZATION (that usually means signing the order just by clicking some button in UI)
	     * This method signalizes the intent to the API that this order will be signed using NO_AUTHORIZATION method
	     * @param {string} signId
	     * @returns {Promise<NoAuthSigningProcess>}
	     *
	     * @memberOf RequestSigner
	     */
	    startSigningWithNoAuthorization: (signId: string) => Promise<NoAuthSigningProcess>;
	    /**
	     * Finishes signing process with TAC (that usually means signing using OneTimePassword from SMS)
	     * You can call this method only if you successfully called `startSigningWithTAC` before.
	     * @param {string} oneTimePassword
	     * @param {string} signId
	     * @returns {Promise<SigningObject>}
	     *
	     * @memberOf RequestSigner
	     */
	    finishSigningWithTac: (oneTimePassword: string, signId: string) => Promise<SigningObject>;
	    /**
	     * Finishes signing process with CASE_MOBILE (that usually means signing using OneTimePassword from SMS)
	     * You can call this method only if you successfully called `startSigningWithCaseMobile` before.
	     * @param {string} oneTimePassword
	     * @param {string} signId
	     * @returns {Promise<SigningObject>}
	     *
	     * @memberOf RequestSigner
	     */
	    finishSigningWithCaseMobile: (oneTimePassword: string, signId: string) => Promise<SigningObject>;
	    /**
	     * This method signalizes the API that the user confirmed signing the order by consent (usually by clicking some button in the UI).
	     * You can call this method only if you successfully called `startSigningWithNoAuthorization` before.
	     * @param {string} signId
	     * @returns {Promise<SigningObject>}
	     *
	     * @memberOf RequestSigner
	     */
	    finishSigningWithNoAuth: (signId: string) => Promise<SigningObject>;
	}

}
declare module 'cs-core-sdk/signing/signing-object' {
	import { WebApiClient } from 'cs-core-sdk/web-api/web-api-client';
	import { Signable } from 'cs-core-sdk/web-api/api-query';
	import { RequestSigner } from 'cs-core-sdk/signing/request-signer';
	import { FilledSigningObject } from 'cs-core-sdk/signing/filled-signing-object';
	/**
	 * @export
	 * @class SigningObject
	 */
	export class SigningObject {
	    state: string;
	    signId: string;
	    order: Signable;
	    protected requestSigner: RequestSigner;
	    /**
	     * Creates an instance of SigningObject.
	     * @param {any} order
	     * @param {WebApiClient} client
	     * @param {string} url
	     *
	     * @memberOf SigningObject
	     */
	    constructor(order: any, client: WebApiClient, url: string);
	    /**
	     * Obtains current signing info with full details from the API. This method always fetches fresh `FilledSigningObject` from the API.
	     * @returns {Promise<FilledSigningObject>}
	     *
	     * @memberOf SigningObject
	     */
	    refreshSigningInfo: () => Promise<FilledSigningObject>;
	    /**
	     * Obtains current signing info with full details from the API OR it returns itself if this signing object is already a `FilledSigningObject`
	     * @returns {Promise<FilledSigningObject>}
	     *
	     *
	     * @memberOf SigningObject
	     */
	    getInfo: () => Promise<FilledSigningObject>;
	    /**
	     * Returns true or false based on state property
	     * @returns {boolean}
	     *
	     * @memberOf SigningObject
	     */
	    isDone: () => boolean;
	    /**
	     * Returns true or false based on state property
	     * @returns {boolean}
	     *
	     * @memberOf SigningObject
	     */
	    isOpen: () => boolean;
	    /**
	     * Returns true or false based on state property
	     * @returns {boolean}
	     *
	     * @memberOf SigningObject
	     */
	    isCanceled: () => boolean;
	}

}
declare module 'cs-core-sdk/web-api/api-query' {
	import { InstanceResource } from 'cs-core-sdk/web-api/instance-resource';
	import { Paginated, ListResponse, PaginatedListResponse } from 'cs-core-sdk/web-api/lists';
	import { SigningObject } from 'cs-core-sdk/signing/signing-object';
	/**
	 * Marks Resource or Entity that supports .get Verb.
	 * @export
	 * @interface GetEnabled
	 * @template TResponse
	 */
	export interface GetEnabled<TResponse> {
	    /**
	     * Makes a GET call to WebApi and returns a `TResponse` back.
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf GetEnabled
	     */
	    get: () => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .get verb with parameters.
	 * @export
	 * @interface ParametrizedGetEnabled
	 * @template TParameters
	 * @template TResponse
	 */
	export interface ParametrizedGetEnabled<TParameters, TResponse> {
	    /**
	     * Makes a GET call to WebApi and returns a `TResponse` back.
	     * @param {TParameters} parameters
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ParametrizedGetEnabled
	     */
	    get: (parameters: TParameters) => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that returns InstanceResource through .withId call
	 * @export
	 * @interface HasInstanceResource
	 * @template T
	 */
	export interface HasInstanceResource<T extends InstanceResource> {
	    /**
	     * Get an instance resource with a given id.
	     * note: This method does not make any calls to the WebApi by itself.
	     * Use  other methods, such as `.get()` on the returned `InstanceResource` to make the call.
	     * @param {any} id
	     * @returns {T}
	     *
	     * @memberOf HasInstanceResource
	     */
	    withId: (id: any) => T;
	}
	/**
	 * Marks Resource or Entity that supports .create verb
	 * @export
	 * @interface CreateEnabled
	 * @template TRequest
	 * @template TResponse
	 */
	export interface CreateEnabled<TRequest, TResponse> {
	    /**
	     * Makes a POST call to WebApi and returns a `TResponse` returned from server.
	     * @param {TRequest} request
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf CreateEnabled
	     */
	    create: (request: TRequest) => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .create verb without body payload
	 * @export
	 * @interface EmptyCreateEnabled
	 * @template TResponse
	 */
	export interface EmptyCreateEnabled<TResponse> {
	    /**
	     * Makes a POST call to WebApi and returns a `TResponse` returned from server.
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf EmptyCreateEnabled
	     */
	    create: () => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .update verb
	 * @export
	 * @interface UpdateEnabled
	 * @template TRequest
	 * @template TResponse
	 */
	export interface UpdateEnabled<TRequest, TResponse> {
	    /**
	     * @param {TRequest} request
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf UpdateEnabled
	     */
	    update: (request: TRequest) => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .update verb without any parameters
	 * @export
	 * @interface EmptyUpdateEnabled
	 * @template TResponse
	 */
	export interface EmptyUpdateEnabled<TResponse> {
	    /**
	     * @param {TResponse} request
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf EmptyUpdateEnabled
	     */
	    update: (request: TResponse) => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .delete verb
	 * @export
	 * @interface DeleteEnabled
	 * @template TResponse
	 */
	export interface DeleteEnabled<TResponse> {
	    /**
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf DeleteEnabled
	     */
	    delete: () => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .delete with query parameters
	 * @export
	 * @interface ParametrizedDeleteEnabled
	 * @template TParameters
	 * @template TResponse
	 */
	export interface ParametrizedDeleteEnabled<TParameters, TResponse> {
	    /**
	     * @param {TParameters}
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ParametrizedDeleteEnabled
	     */
	    delete: (parameters: TParameters) => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .list verb
	 * @export
	 * @interface ListEnabled
	 * @template TItem
	 */
	export interface ListEnabled<TItem> {
	    /**
	     * @returns {Promise<ListResponse<TItem>>}
	     *
	     * @memberOf ListEnabled
	     */
	    list: () => Promise<ListResponse<TItem>>;
	}
	/**
	 * Marks Resource or Entity that supports .list verb with parameters
	 * @export
	 * @interface ParametrizedListEnabled
	 * @template TParameters
	 * @template TItem
	 */
	export interface ParametrizedListEnabled<TParameters, TItem> {
	    /**
	     * @param {TParameters} parameters
	     * @returns {Promise<ListResponse<TItem>>}
	     *
	     * @memberOf ParametrizedListEnabled
	     */
	    list: (parameters: TParameters) => Promise<ListResponse<TItem>>;
	}
	/**
	 * Marks Resource or Entity that supports .list verb with parameters and pagination
	 * @export
	 * @interface PaginatedListEnabled
	 * @template TItem
	 */
	export interface PaginatedListEnabled<TItem> {
	    list: (parameters: Paginated) => Promise<PaginatedListResponse<TItem>>;
	}
	/**
	 * Marks Resource or Entity that supports .url verb
	 * @export
	 * @interface HasUrl
	 */
	export interface HasUrl {
	    /**
	     * @returns {string}
	     *
	     * @memberOf HasUrl
	     */
	    url: () => string;
	}
	/**
	 * Marks Resource or Entity that supports .url verb with parameters
	 * @export
	 * @interface HasParametrizedUrl
	 * @template TParameters
	 */
	export interface HasParametrizedUrl<TParameters> {
	    /**
	     * @param {TParameters} parameters
	     * @returns {string}
	     *
	     * @memberOf HasParametrizedUrl
	     */
	    url: (parameters: TParameters) => string;
	}
	/**
	 * Response with no body.
	 *
	 * @export
	 * @interface EmptyResponse
	 */
	export interface EmptyResponse {
	}
	/**
	 * Marks response that is signable. It has SigningObject with key signing available.
	 * @export
	 * @interface Signable
	 */
	export interface Signable {
	    signing: SigningObject;
	}
	/**
	 * Marks Resource or Entity that supports .download verb.
	 * @interface DownloadEnabled
	 */
	export interface DownloadEnabled<TResponse> {
	    /**
	     * @returns {Promise<TResponse>}
	     */
	    download: () => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .download verb with parameters.
	 * @interface ParametrizedDownloadEnabled
	 */
	export interface ParametrizedDownloadEnabled<TParameters, TResponse> {
	    /**
	     * @param {TParameters} parameters
	     * @returns {Promise<TResponse>}
	     */
	    download: (parameters: TParameters) => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .export verb.
	 * @interface ExportEnabled
	 */
	export interface ExportEnabled<TResponse> {
	    /**
	     * @returns {Promise<TResponse>}
	     */
	    export: () => Promise<TResponse>;
	}
	/**
	 * Marks Resource or Entity that supports .export verb with parameters.
	 * @interface ParametrizedExportEnabled
	 */
	export interface ParametrizedExportEnabled<TParameters, TResponse> {
	    /**
	     * @param {TParameters} parameters
	     * @returns {Promise<TResponse>}
	     */
	    export: (parameters: TParameters) => Promise<TResponse>;
	}

}
declare module 'cs-core-sdk/web-api/entity-utils' {
	/**
	 * @export
	 * @class EntityUtils
	 */
	export class EntityUtils {
	    /**
	     * @static
	     * @param {any} obj
	     * @param {any} f
	     * @param {any} [ctx=null]
	     * @returns
	     *
	     * @memberOf EntityUtils
	     */
	    static deepMap(obj: any, f: any, ctx?: any): any;
	    /**
	     * Marks response that is signable. It has SigningObject with key signing available.
	     * @static
	     * @param {any} object
	     * @param {string} idKey
	     *
	     * @memberOf EntityUtils
	     */
	    static addIdProperty(object: any, idKey: string): void;
	    /**
	     * @static
	     * @param {any} object
	     * @returns {*}
	     *
	     * @memberOf EntityUtils
	     */
	    static copyData(object: any): any;
	    /**
	     * @static
	     * @param {any} object
	     * @param {string} oldName
	     * @param {string} newName
	     *
	     * @memberOf EntityUtils
	     */
	    static renameProperty(object: any, oldName: string, newName: string): void;
	    /**
	     * @static
	     * @param {function} accessFunction
	     * @param {any} key
	     * @param {function} transformFunction
	     *
	     * @memberOf EntityUtils
	     */
	    static tryTransform(accessFunction: () => any, key: any, transformFunction: (val: any) => any): void;
	    /**
	     * @static
	     * @param {function} accessFunction
	     * @param {any} key
	     *
	     * @memberOf EntityUtils
	     */
	    static tryStringToDateTransform(accessFunction: () => any, key: any): void;
	    /**
	     * @static
	     * @param {function} accessFunction
	     * @param {any} key
	     *
	     * @memberOf EntityUtils
	     */
	    static tryStringify(accessFunction: () => any, key: any): void;
	    /**
	     * Date.parse with progressive enhancement for ISO 8601 <https://github.com/csnover/js-iso8601>
	     * NON-CONFORMANT EDITION.
	     * © 2011 Colin Snover <http://zetafleet.com>
	     * Released under MIT license.
	     *
	     * @param {any} date
	     * @returns {number}
	     */
	    static parseISODate(date: any): number;
	    /**
	     * Copy all of the properties in the source objects over to the destination object,
	     * and return the destination object. It's in-order, so the last source will override
	     * properties of the same name in previous arguments.
	     *
	     * @param {object} originalParams
	     * @param {object} additionalParams
	     * @returns {void}
	     */
	    static extend(originalParams: object, additionalParams: object): void;
	    /**
	     * @static
	     * @param {string|string[]} dates
	     * @param {any} obj
	     * @returns {void}
	     *
	     * @memberOf EntityUtils
	     */
	    static addDatesFromISO(dates: string | [string], obj: any): void;
	    /**
	     * @static
	     * @param {any} dates
	     * @param {any} obj
	     * @param {string} [items] itemsKey
	     * @returns {void}
	     *
	     * @memberOf EntityUtils
	     */
	    static addDatesToItems(dates: any, obj: any, itemsKey?: string): void;
	    /**
	     * @static
	     * @param {any} dates
	     * @param {object} obj
	     * @returns {void}
	     *
	     * @memberOf EntityUtils
	     */
	    static transformDatesToISO(dates: any, obj: object): void;
	    /**
	     * @static
	     * @param {any} dates
	     * @param {object} obj
	     * @returns {void}
	     *
	     * @memberOf EntityUtils
	     */
	    static transformDatesToSimpleISO(dates: any, obj: object): void;
	    /**
	     * @static
	     * @param {any} params
	     * @param {any} paramKey
	     * @returns {void}
	     *
	     * @memberOf EntityUtils
	     */
	    static transformArrayParamsToString(params: any, paramKey: any): void;
	    /**
	     * @static
	     * @param {string} path
	     * @param {any} params
	     * @returns {string}
	     *
	     * @memberOf EntityUtils
	     */
	    static addParamsToPath(path: string, params: any): string;
	    /**
	     * @private
	     * @static
	     * @param {any} params
	     * @param {any} paramKey
	     * @returns {void}
	     *
	     * @memberOf EntityUtils
	     */
	    private static transformParamsToString(params, paramKey);
	    /**
	     * @private
	     * @static
	     * @param {any} date
	     * @param {any} obj
	     * @returns {void}
	     *
	     * @memberOf EntityUtils
	     */
	    private static addISODate(date, obj);
	}

}
declare module 'cs-core-sdk/web-api/resource-utils' {
	import { Resource } from 'cs-core-sdk/web-api/resource';
	import { ListResponse, PaginatedListResponse } from 'cs-core-sdk/web-api/lists';
	/**
	 * @export
	 * @class ResourceUtils
	 */
	export class ResourceUtils {
	    /**
	     * @static
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {any} params
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallGet<TResponse>(resource: Resource, params: any): Promise<TResponse>;
	    /**
	     * @static
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {any} params
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallGetWithSuffix<TResponse>(resource: Resource, pathSuffix: string, params: any): Promise<TResponse>;
	    /**
	     * @static
	     * @template TRequest
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {TRequest=} payload
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallCreate<TRequest, TResponse>(resource: Resource, payload?: TRequest): Promise<TResponse>;
	    /**
	     * @static
	     * @template TRequest
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {TRequest=} payload
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallCreateWithSuffix<TRequest, TResponse>(resource: Resource, pathSuffix: string, payload?: TRequest): Promise<TResponse>;
	    /**
	     * @static
	     * @template TRequest
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {TRequest=} payload
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallUpdate<TRequest, TResponse>(resource: Resource, payload?: TRequest): Promise<TResponse>;
	    /**
	     * @static
	     * @template TRequest
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {TRequest=} payload
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallUpdateWithSuffix<TRequest, TResponse>(resource: Resource, pathSuffix: string, payload?: TRequest): Promise<TResponse>;
	    /**
	     * @static
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {any} params
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallDelete<TResponse>(resource: Resource, params: any): Promise<TResponse>;
	    /**
	     * @static
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {any} params
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallDeleteWithSuffix<TResponse>(resource: Resource, pathSuffix: string, params: any): Promise<TResponse>;
	    /**
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {string} method
	     * @param {any=} params
	     * @param {Uint8Array} data
	     * @param {any=} headers
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    UploadDataWithSuffix<TResponse>(resource: Resource, pathSuffix: string, method: string, params: any, data: Uint8Array, headers?: any): Promise<TResponse>;
	    /**
	     * @static
	     * @template TData
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {string} method
	     * @param {any=} params
	     * @param {TData=} data
	     * @param {any=} headers
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallDownload<TData, TResponse>(resource: Resource, pathSuffix: string, method: string, params?: any, data?: TData, headers?: any): Promise<TResponse>;
	    /**
	     * @static
	     * @template TData
	     * @template TResponse
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {string} method
	     * @param {any=} params
	     * @param {TData=} data
	     * @param {any=} headers
	     * @param {string=} responseType
	     * @returns {Promise<TResponse>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallApiWithSuffix<TData, TResponse>(resource: Resource, pathSuffix: string, method: string, params?: any, data?: TData, headers?: any, responseType?: string): Promise<TResponse>;
	    /**
	     * @static
	     * @template TItem
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {string=} itemsKey
	     * @param {any=} params
	     * @param {function=} responseTransform
	     * @returns {Promise<PaginatedListResponse<TItem>>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallPaginatedListWithSuffix<TItem>(resource: Resource, pathSuffix: string, itemsKey?: string, params?: any, responseTransform?: (response: PaginatedListResponse<TItem>) => PaginatedListResponse<TItem>): Promise<PaginatedListResponse<TItem>>;
	    /**
	     * @static
	     * @template TItem
	     * @param {Resource} resource
	     * @param {string} pathSuffix
	     * @param {string=} itemsKey
	     * @param {any=} params
	     * @returns {Promise<ListResponse<TItem>>}
	     *
	     * @memberOf ResourceUtils
	     */
	    static CallListWithSuffix<TItem>(resource: Resource, pathSuffix: string, itemsKey?: string, params?: any): Promise<ListResponse<TItem>>;
	}

}
declare module 'cs-core-sdk/web-api/web-api' {
	export * from 'cs-core-sdk/web-api/lists';
	export * from 'cs-core-sdk/web-api/api-query';
	export * from 'cs-core-sdk/web-api/resource';
	export * from 'cs-core-sdk/web-api/instance-resource';
	export * from 'cs-core-sdk/web-api/resource-utils';
	export { WebApiClient } from 'cs-core-sdk/web-api/web-api-client';
	export { EntityUtils } from 'cs-core-sdk/web-api/entity-utils';

}
declare module 'cs-core-sdk/test-utils/judge' {
	import { Environment } from 'cs-core-sdk/core/environment';
	/**
	 * @export
	 * @class JudgeSession
	 */
	export class JudgeSession {
	    sessionId: string;
	    private baseUrl;
	    /**
	     * Creates an instance of JudgeSession.
	     * @param {string} sessionId
	     * @param {string} [baseUrl]
	     *
	     * @memberOf JudgeSession
	     */
	    constructor(sessionId: string, baseUrl?: string);
	    /**
	     * @param {string} nextCase
	     * @returns {Promise<any>}
	     *
	     * @memberOf JudgeSession
	     */
	    setNextCase(nextCase: string): Promise<any>;
	}
	/**
	 * @export
	 * @class Judge
	 */
	export class Judge {
	    static JudgeSessionHeaderName: string;
	    static JudgeCaseHeaderName: string;
	    static DefaultBaseURL: string;
	    static DefaultTestEnvironment: Environment;
	    private baseUrl;
	    /**
	     * Creates an instance of Judge.
	     * @param {string=} baseUrl
	     *
	     * @memberOf Judge
	     */
	    constructor(baseUrl?: string);
	    /**
	     * @readonly
	     * @returns {Environment}
	     *
	     * @memberOf Judge
	     */
	    readonly testEnvironment: Environment;
	    /**
	     * @private
	     * @static
	     * @type {string}
	     * @memberOf Judge
	     */
	    private static CurrentSessionId;
	    /**
	     * @returns {JudgeSession}
	     *
	     * @memberOf Judge
	     */
	    startNewSession(): JudgeSession;
	}

}
declare module 'cs-core-sdk/test-utils/test-utils' {
	/**
	 * @export
	 * @class TestUtils
	 */
	export class TestUtils {
	    /**
	     * @static
	     * @param {any} obj
	     * @param {any} props
	     *
	     * @memberOf TestUtils
	     */
	    static expectToBe(obj: any, props: any): void;
	    /**
	     * @static
	     * @param {any} e
	     *
	     * @memberOf TestUtils
	     */
	    static logJudgeError(e: any): void;
	    /**
	     * @static
	     * @param {object} target
	     * @param {object} dates
	     *
	     * @memberOf TestUtils
	     */
	    static expectDate(target: object, dates: object): void;
	    /**
	     * @static
	     * @param {string} url
	     * @param {string} toBeUrl
	     * @returns {void}
	     *
	     * @memberOf TestUtils
	     */
	    static expectUrl(url: string, toBeUrl: string): void;
	}

}
declare module 'cs-core-sdk/signing/signing-utils' {
	import { WebApiClient } from 'cs-core-sdk/web-api/web-api-client';
	/**
	 * @export
	 * @class SigningUtils
	 */
	export class SigningUtils {
	    /**
	     * Replaces order's signInfo property with new SigningObject with passed parameters
	     *
	     * @static
	     * @param {any} order
	     * @param {WebApiClient} client
	     * @param {string} url
	     * @returns {void}
	     *
	     * @memberOf SigningUtils
	     */
	    static createSigningObject(order: any, client: WebApiClient, url: string): void;
	}

}
declare module 'cs-core-sdk/signing/signing' {
	export { FilledSigningObject } from 'cs-core-sdk/signing/filled-signing-object';
	export * from 'cs-core-sdk/signing/signing-process';
	export { RequestSigner } from 'cs-core-sdk/signing/request-signer';
	export { SigningObject } from 'cs-core-sdk/signing/signing-object';
	export { SigningUtils } from 'cs-core-sdk/signing/signing-utils';

}
declare module 'cs-core-sdk/core-sdk' {
	import { WebApiContext, WebApiConfiguration } from 'cs-core-sdk/core/core';
	import { Environment } from 'cs-core-sdk/core/core';
	import { Oauth2Config } from 'cs-core-sdk/core/web-api-configuration';
	/**
	 * Allows configuration of CoreSDK
	 * @export
	 * @class CoreSDKConfigurator
	 */
	export class CoreSDKConfigurator {
	    /**
	     * Set the WebAPI key.
	     * @param {string} webApiKey
	     * @returns {CoreSDKConfigurator}
	     *
	     * @memberOf CoreSDKConfigurator
	     */
	    useWebApiKey(webApiKey: string): CoreSDKConfigurator;
	    /**
	     * Specifies the private key for CSCoreSDK request signing.
	     * @param {string} signingKey
	     * @returns {CoreSDKConfigurator}
	     *
	     * @memberOf CoreSDKConfigurator
	     */
	    useRequestSigning(signingKey: string): CoreSDKConfigurator;
	    /**
	     * Set other then the default language cs-CZ.
	     * @param {string} language a language to be set
	     * @returns {CoreSDKConfigurator} reference for configuration chaining
	     *
	     * @memberOf CoreSDKConfigurator
	     */
	    useLanguage(language: string): CoreSDKConfigurator;
	    /**
	     * Sets the environment which the SDK should use.
	     *
	     * @param {Environment} environment environment to use
	     * @returns {CoreSDKConfigurator} reference for configuration chaining
	     *
	     * @memberOf CoreSDKConfigurator
	     */
	    useEnvironment(environment: Environment): CoreSDKConfigurator;
	    /**
	     * Sets the config for oAuth 2
	     *
	     * @param {Oauth2Config} oauth2 Oauth2Config to use
	     * @returns {CoreSDKConfigurator} reference for configuration chaining
	     *
	     * @memberOf CoreSDKConfigurator
	     */
	    useOauth2(oauth2: Oauth2Config): CoreSDKConfigurator;
	}
	/**
	 * Shared WebApiConfiguration
	 */
	export var config: WebApiConfiguration;
	/**
	 * Internal structure to share information between different SDKs
	 */
	export var sharedContext: WebApiContext;
	/**
	 * Set the WebAPI key.
	 * @param {string} webApiKey
	 * @returns {CoreSDKConfigurator}
	 */
	export var useWebApiKey: (webApiKey: string) => CoreSDKConfigurator;
	/**
	 * Specifies the private key for CSCoreSDK request signing.
	 * @param {string} signingKey The private key to sign reguests.
	 * @returns {CoreSDKConfigurator} reference for configuration chaining.
	 */
	export var useRequestSigning: (signingKey: string) => CoreSDKConfigurator;
	/**
	 *  Set other then the default language cs-CZ.
	 *  @param {string} language a language to be set.
	 *  @returns {CoreSDKConfigurator} reference for configuration chaining.
	 */
	export var useLanguage: (language: string) => CoreSDKConfigurator;
	/**
	 * Sets the environment which the SDK should use.
	 * @param {Environment} environment environment to use
	 * @returns {CoreSDKConfigurator} reference for configuration chaining.
	 */
	export var useEnvironment: (environment: Environment) => CoreSDKConfigurator;
	/**
	 * Sets the config for oAuth 2
	 * @param {Oauth2Config} oauth2 Oauth2Config to use
	 * @returns {CoreSDKConfigurator} reference for configuration chaining.
	 */
	export var useOauth2: (oauth2: Oauth2Config) => CoreSDKConfigurator;
	export * from 'cs-core-sdk/core/core';
	export * from 'cs-core-sdk/web-api/web-api';
	export * from 'cs-core-sdk/test-utils/judge';
	export * from 'cs-core-sdk/test-utils/test-utils';
	export * from 'cs-core-sdk/signing/signing';

}
declare module 'cs-core-sdk'{ export * from 'cs-core-sdk/core-sdk'}