/**
 * HTTP request methods.
 *
 * HTTP defines a set of request methods to indicate the desired action to be
 * performed for a given resource. Although they can also be nouns, these
 * request methods are sometimes referred as HTTP verbs. Each of them implements
 * a different semantic, but some common features are shared by a group of them:
 * e.g. a request method can be safe, idempotent, or cacheable.
 *
 * @public
 */
declare enum HTTPMethod {
    /**
     * The `DELETE` method deletes the specified resource.
     */
    DELETE = "DELETE",
    /**
     * The `GET` method requests a representation of the specified resource.
     * Requests using GET should only retrieve data.
     */
    GET = "GET",
    /**
     * The PATCH method is used to apply partial modifications to a resource.
     */
    PATCH = "PATCH",
    /**
     * The `POST` method is used to submit an entity to the specified resource,
     * often causing a change in state or side effects on the server.
     */
    POST = "POST",
    /**
     * The `PUT` method replaces all current representations of the target
     * resource with the request payload.
     */
    PUT = "PUT",
    /**
     * The CONNECT method starts two-way communications with the requested
     * resource. It can be used to open a tunnel.
     */
    CONNECT = "CONNECT"
}
/**
 * 200 - 299
 */
declare enum HttpSuccessfulResponseStatus {
    OK = "200"
}
/** @internal */
type HttpSuccessfulResponseStatusCodes = `${HttpSuccessfulResponseStatus}`;
/**
 * 300 - 399
 */
declare enum HttpRedirectionResponseStatus {
    NotModified = "304"
}
/** @internal */
type HttpRedirectionResponseStatusCodes = `${HttpRedirectionResponseStatus}`;
/**
 * 400 - 499
 */
declare enum HttpClientResponseStatus {
    BadRequest = "400",
    Unauthorized = "401",
    Forbidden = "403",
    NotFound = "404",
    NotAcceptable = "406",
    RequestTimeout = "408",
    TooManyRequests = "429"
}
/** @internal */
type HttpClientResponseStatusCodes = `${HttpClientResponseStatus}`;
/**
 * 500 - 599
 */
declare enum HttpServerResponseStatus {
    InternalServerError = "500",
    BadGateway = "502",
    ServiceUnavailable = "503",
    GatewayTimeout = "504"
}
/** @internal */
type HttpServerResponseStatusCodes = `${HttpServerResponseStatus}`;
declare enum FetchErrors {
    UNSUPPORTED_RESPONSE_CONTENT_TYPE = "UNSUPPORTED_RESPONSE_CONTENT_TYPE",
    UNEXPECTED_ERROR = "UNEXPECTED_ERROR",
    SYNTAX_ERROR = "SYNTAX_ERROR",
    UNKNOWN = "UNKNOWN"
}
/** @internal */
type FetchErrorsCodes = `${FetchErrors}`;
declare enum OnBeforeRESTCallErrors {
    ON_BEFORE_REST_CALL_ERROR = "ON_BEFORE_REST_CALL_ERROR"
}
/** @internal */
type OnBeforeRESTCallErrorCodes = `${OnBeforeRESTCallErrors}`;
type HeadersObject = {
    [key: string]: string;
};

interface IBeforeRESTCallError {
    Code: OnBeforeRESTCallErrorCodes;
    Message: OnBeforeRESTCallErrorCodes;
}
interface IBeforeRESTCallSuccess {
    Code: 'SUCCESS';
    Message: 'SUCCESS';
}
declare abstract class Main {
    protected parent: IClient;
    /** @internal */
    constructor(parent: IClient);
    protected onBeforeRESTCall(): Promise<IBeforeRESTCallError | IBeforeRESTCallSuccess>;
    protected getDefaults(method: HTTPMethod): {
        baseUrl: string;
        method: HTTPMethod;
        headers: Headers;
    };
    protected getHeaderWithDeviceToken(): Headers;
    protected getHeaderWithUserToken(): Headers;
    protected getHeaderWithSessionEnabled(): Headers;
}

/**
 * Base shape for a Response. This interface is extended
 * to provide the specific shape for the responses
 * of each resource+verb.
 */
interface Response {
    status: string;
    body?: unknown;
    headers: Headers | HeadersObject;
}
interface HttpError {
    Code: string;
    Message: string;
}
/** @noInheritDoc */
interface HttpErrorResponse extends Response {
    status: HttpClientResponseStatusCodes | HttpServerResponseStatusCodes;
    body: HttpError;
}
interface FetchError {
    Code: FetchErrorsCodes;
    Message: FetchErrorsCodes;
}
/** @noInheritDoc */
interface FetchErrorResponse extends Response {
    status: FetchErrorsCodes;
    body: FetchError;
}
interface OnBeforeRESTCallError {
    Code: OnBeforeRESTCallErrorCodes;
    Message: OnBeforeRESTCallErrorCodes;
}
/** @noInheritDoc */
interface OnBeforeRESTCallErrorResponse extends Response {
    status: OnBeforeRESTCallErrorCodes;
    body: OnBeforeRESTCallError;
}
type ErrorResponse = HttpErrorResponse | FetchErrorResponse | OnBeforeRESTCallErrorResponse;

/**
 * Reset password link
 */
interface AuthResetPasswordLink {
    success: boolean;
}
/** @noInheritDoc */
interface AuthResetPasswordLink200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Reset password link response
     */
    body: AuthResetPasswordLink;
}
/**
 * Login code sent
 */
interface AuthLoginCodeSent {
    success: boolean;
}
/** @noInheritDoc */
interface AuthLoginCodeSent200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Login code sent response
     */
    body: AuthLoginCodeSent;
}
/**
 * Renew token
 */
interface AuthRenewToken {
    Token: string;
    RefreshToken: string;
}
/** @noInheritDoc */
interface AuthRenewToken200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Renew token response
     */
    body: AuthRenewToken;
}
interface AuthSendResetMobile {
    success: boolean;
}
/** @noInheritDoc */
interface AuthSendResetMobile200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Send reset mobile response
     */
    body: AuthSendResetMobile;
}
interface AuthGetOrgClientCredentials {
    orgName: string;
    logoURL: string;
    userPoolId: string;
    nativeAuthEnabled: boolean;
    cognitoDomainUrl: string;
    identityProviders: Array<{
        iconURL: string;
        displayName: string;
        identityProviderName: string;
    }>;
}
/** @noInheritDoc */
interface AuthGetOrgClientCredentials200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: AuthGetOrgClientCredentials;
}
/**
 * Authenticate
 */
interface AuthAuthenticate {
    OrganizationID: string;
    ID: string;
    Type: string;
    SessionGen: number;
    Region: string;
    exp: number;
    iat: number;
    iss: string;
    RoleID: string;
    Policies: {
        LoginUser: boolean;
    };
    Permissions: object;
}
/** @noInheritDoc */
interface AuthAuthenticate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Authenticate body response
     */
    body: AuthAuthenticate;
}
/**
 * Validate
 */
interface AuthValidate {
    OrganizationID: string;
    ID: string;
    Type: string;
    SessionGen: number;
    Region: string;
    exp: number;
    iat: number;
    iss: string;
    RoleID: string;
    Policies: {
        LoginUser: boolean;
    };
    Permissions: object;
}
/** @noInheritDoc */
interface AuthValidate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Validate body response
     */
    body: AuthValidate;
}
/**
 * SSO Token
 */
interface AuthSSOToken {
    idToken: string;
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
    tokenType: string;
}
/** @noInheritDoc */
interface AuthSSOToken200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * SSO Token body response
     */
    body: AuthSSOToken;
}
/**
 * Auth generate token
 */
interface AuthGenerateToken {
    Token: string;
}
/** @noInheritDoc */
interface AuthGenerateToken200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Generate Token body response
     */
    body: AuthGenerateToken;
}

/**
 * Reset password link request
 */
interface AuthResetPasswordLinkRequest {
    Email: string;
    /** organization_identifier */
    Identifier: string;
}
/**
 * Login code request
 */
interface AuthLoginCodeRequest {
    PhoneNumber: string;
    /** organization_identifier */
    Identifier: string;
}
/**
 * Renew token request
 */
interface AuthRenewTokenRequest {
    Token: string;
    RefreshToken: string;
}
interface AuthSendResetMobileRequest {
    Email?: string;
    PhoneNumber?: string;
}
/**
 * SSO Token request
 */
interface AuthSSOTokenRequest {
    redirectURL: string;
    orgIdentifier: string;
    /** AWS code */
    code: string;
}
interface AuthGenerateTokenRequest {
    Token: string;
    RefreshToken: string;
}

/**
 * Auths end points
 *
 * These endpoints provide user/device authentication.
 */
declare class Auths extends Main {
    /**
     * Request to send password reset link to user's email.
     *
     * Endpoint Action ID = 2300
     */
    requestResetPasswordLink(data: AuthResetPasswordLinkRequest): Promise<AuthResetPasswordLink200Response | ErrorResponse>;
    /**
     * Request to send password reset link to user's email.
     *
     * Edpoint Action ID = 2302
     */
    sendResetMobile(data: AuthSendResetMobileRequest): Promise<AuthSendResetMobile200Response | ErrorResponse>;
    /**
     * Request to send login code.
     *
     * Endpoint Action ID = 2303
     */
    requestLoginCode(data: AuthLoginCodeRequest): Promise<AuthLoginCodeSent200Response | ErrorResponse>;
    /**
     * Renew user/device access and refresh token. When you register a license or login with
     * user's credentials, a pair of Token and RefreshToken is sent to a client. The client
     * needs to send the matching pair to exchange it with a new pair. The old pair will not
     * be valid after calling this endpoint. RefreshToken is one-time use.
     *
     * Endpoint Action ID = 2304
     */
    renew(data: AuthRenewTokenRequest, tokenType: 'device' | 'user'): Promise<AuthRenewToken200Response | ErrorResponse>;
    /**
     * Generates a general token.
     *
     * Endpoint Action ID = 2305
     */
    generateToken(data: AuthGenerateTokenRequest): Promise<AuthGenerateToken200Response | ErrorResponse>;
    /**
     * Returns organization client credentials.
     *
     * Endpoint Action ID = 2306
     */
    getOrgClientCredentials(orgId: string): Promise<AuthGetOrgClientCredentials200Response | ErrorResponse>;
    /**
     * Validates a token passed as a authentication header and returns the decoded token with permissions.
     *
     * Endpoint Action ID = unknown at this time
     */
    authenticate(): Promise<AuthAuthenticate200Response | ErrorResponse>;
    /**
     * Validates a token passed as a authentication header and returns the decoded token with permissions.
     *
     * Endpoint Action ID = unknown at this time
     */
    validate(): Promise<AuthValidate200Response | ErrorResponse>;
    /**
     * Exchange Cognito code for Cognito Access token and Refresh token
     *
     * Endpoint Action ID = unknown at this time
     */
    ssoToken(data: AuthSSOTokenRequest): Promise<AuthSSOToken200Response | ErrorResponse>;
}

type DeviceTypeIDStrings = keyof typeof DeviceTypeID;
/**
 * Status response
 */
interface OrgRegisterLicenseRequest {
    /**
     * IPHONE = All iPhone devices
     *
     * IPAD = All generations of iPad devices
     *
     * DARWIN = Desktop MacOS based systems
     *
     * ANDROID_PHONE = All Android based phone devices
     *
     * WINDOWS = Desktop Windows64 based systems
     *
     * WIN32 = Desktop Windows32 based systems
     *
     * WINDOWS_TABLET = Windows-based tablet devices
     *
     * LINUX = Linux based devices
     *
     * DEBIAN = Debian based devices
     */
    DeviceTypeID: DeviceTypeIDStrings;
    /** License key */
    Key: string;
    Name: string;
    Identifier: string;
    Version: string;
    TokenExpiresIn?: number;
    TokenSubject?: string;
}
interface OrgUsersRequest {
    /** filter by user's Status. */
    statusId: string | null;
    /** filter by user's email */
    userName: string | null;
    /** filter by user's Role. */
    roleId: string | null;
    /** filter by user's gender. */
    gender: string | null;
    /** Account creation start date in the format YYYY-MM-DD */
    date: string | null;
    /** Account creation end date in the format YYYY-MM-DD. */
    endDate: string | null;
    /** default limit: 25 */
    limit: string | null;
    /** default offset: 0 */
    offset: string | null;
}
interface OrgMeasurementsRequest {
    /** filter by measurement Status ID. */
    statusId: string | null;
    /** filter by a Profile ID. */
    userProfileID: string | null;
    /** filter by a Profile name */
    userProfileName: string | null;
    /** filter by studyID */
    studyID: string | null;
    /** filter by user email. */
    userName: string | null;
    /** The date to return measurements for yyyy-mm-dd. */
    date: string | null;
    /** End date for range of measurements to receive. */
    endDate: string | null;
    /** default limit: 50 */
    limit: string | null;
    /** default offset: 0 */
    offset: string | null;
    /** filter by a Device ID. */
    deviceID: string | null;
    /** filter by a partner ID. */
    partnerId: string | null;
    /** filter by mode. */
    mode: string | null;
    sortBy: string | null;
    sortOrder: string | null;
    region: string | null;
}
interface OrgListProfileRequest {
    /** filter by profile StatusID. */
    statusId?: string;
    /** Profile owner's email to filter by. Example: john@doe.com. */
    ownerUser?: string;
    /** Profile's name to filter by. Example: john@doe.com */
    userProfileName?: string;
    /** filter by creation date. */
    created?: string;
    /** filter by date. */
    date?: string;
    /** filter by end date */
    endDate?: string;
    /** default limit: 25 */
    limit?: string;
    /** default offset: 0 */
    offset?: string;
}
interface OrgCreateUserRequest {
    FirstName: string;
    LastName: string;
    Email: string;
    Gender: string;
    DateOfBirth: string;
    RoleID: string;
    Password: string;
    organizationConfigLinkID?: string;
    expireAt?: string;
}
interface OrgUpdateUserRequest {
    FirstName: string;
    LastName: string;
    Gender: string;
    DateOfBirth: string;
    HeightCm: string;
    WeightKg: string;
}
interface OrgUpdateProfileRequest {
    Name: string;
    Email: string;
    Status: string;
}
interface OrgLoginRequest {
    Email: string;
    Password: string;
    Identifier: string;
    MFAToken?: number;
    TokenExpiresIn?: number;
    RefreshTokenExpiresIn?: number;
}
interface OrgContactUserRequest {
    Email: string;
    Type: string;
}

/**
 * Device type
 */
interface DeviceType {
    ID: string;
    Name: string;
    Description: string;
    IsMobile: boolean;
    IsTablet: boolean;
    IsDesktop: boolean;
}
/** @noInheritDoc */
interface DeviceTypes200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Device type response
     */
    body: DeviceType[];
}
/**
 * Device retrieve
 */
interface DeviceRetrieve {
    Name: string;
    DeviceTypeID: DeviceTypeIDStrings;
    StatusID: string;
    Identifier: string;
    Version: string;
    Created: number;
    Updated: number;
    count: string;
    Region: string;
}
/** @noInheritDoc */
interface DeviceRetrieve200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Device retrieve response
     */
    body: DeviceRetrieve;
}
/**
 * Device created
 */
interface DeviceCreated {
    ID: string;
}
/** @noInheritDoc */
interface DeviceCreated200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Device created response
     */
    body: DeviceCreated;
}
/** @noInheritDoc */
interface DeviceUpdated200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/** @noInheritDoc */
interface DeviceDeleted200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/**
 * Device list
 */
interface Device {
    ID: string;
    Name: string;
    DeviceTypeID: DeviceTypeIDStrings;
    StatusID: string;
    Identifier: string;
    Version: string;
    Measurements: number;
    LicenseID: string;
    Region: string;
    Created: number;
    Updated: number;
    TotalCount: number;
}
/** @noInheritDoc */
interface DeviceList200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * List of existing devices in an organization
     */
    body: Device[];
}
/** @noInheritDoc */
interface DeviceDeleteMeasurements200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/**
 * Device license
 */
interface DeviceLicense {
    ID: string;
    LicenseType: string;
    StatusID: string;
    Expiration: number;
    MaxDevices: number;
}
/** @noInheritDoc */
interface DeviceRetrieveLicenseId200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Device retrieve license ID response
     */
    body: DeviceLicense;
}

/**
 * Device create request
 */
interface DeviceCreateRequest {
    Name: string;
    DeviceTypeID: DeviceTypeIDStrings;
    Identifier: string;
    Version: string;
}
/**
 * Device update request
 */
interface DeviceUpdateRequest {
    Name: string;
    DeviceTypeID: DeviceTypeIDStrings;
    Status: string;
    Identifier: string;
    Version: string;
}
/**
 * Device list request
 */
interface DeviceListRequest {
    statusId: string | null;
    unique: string | null;
    deviceTypeID: DeviceTypeIDStrings | null;
    name: string | null;
    version: string | null;
    date: string | null;
    endDate: string | null;
    limit: string | null;
    offset: string | null;
    licenseID: string | null;
}

/**
 * Devices end points
 *
 * Devices can be used to record the platform by which a measurement
 * captured was conducted on. The DeviceTypeID references a pre-defined
 * set of devices with the following chart. New Device Types cannot be
 * created by organizations and are managed by the API specifically.
 * Devices types can be retrieved from a dedicated endpoint returning
 * all their values and meanings.
 */
declare class Devices extends Main {
    /**
     * Retrieves a list of allowed device types.
     *
     * Endpoint Action ID = 900
     */
    types(): Promise<DeviceTypes200Response | ErrorResponse>;
    /**
     * Retrieves a single reference to a device. The body response includes details
     * about the device and the number of measurements that have been associated with it.
     *
     * Endpoint Action ID = 902
     */
    retrieve(id: string): Promise<DeviceRetrieve200Response | ErrorResponse>;
    /**
     * Creates a new device reference to associate with measurements.
     * Each device is mapped to a device type ID.
     *
     * Endpoint Action ID = 903
     */
    create(data: DeviceCreateRequest): Promise<DeviceCreated200Response | ErrorResponse>;
    /**
     * Updates a device reference via the UUID supplied.
     *
     * Endpoint Action ID = 904
     */
    update(id: string, data: DeviceUpdateRequest): Promise<DeviceUpdated200Response | ErrorResponse>;
    /**
     * Deletes a device from the dataset.
     *
     * Endpoint Action ID = 905
     */
    remove(id: string): Promise<DeviceDeleted200Response | ErrorResponse>;
    /**
     * Retrieves a list of existing devices in an organization.
     *
     * Endpoint Action ID = 906
     */
    list(data?: DeviceListRequest): Promise<DeviceList200Response | ErrorResponse>;
    /**
     * Only DFX_ORG_ADMIN has permission to delete all measurements of a
     * specific device for their own organization.
     *
     * Endpoint Action ID = 907
     */
    deleteDeviceMeasurement(id: string): Promise<DeviceDeleteMeasurements200Response | ErrorResponse>;
    /**
     * We want to extend the EP to use deviceID (instead of {ID}) in the device token
     * to extract license information and return to client.
     *
     * Endpoint Action ID = 908
     */
    retrieveLicenseId(): Promise<DeviceRetrieveLicenseId200Response | ErrorResponse>;
}

interface ConsentObj {
    description: string;
    data_controller: {
        company: string;
        contact: string;
        email: string;
    };
    purposes: {
        authorized: boolean;
        purpose: string;
        description: string;
    }[];
    policy_url: string;
    policy_version: string;
    collection_mode: string;
}

/**
 * Enum for possible Status ID codes
 * @readonly
 * @enum {string}
 */
declare enum StatusID {
    ACTIVE = "ACTIVE",
    MAINTENANCE = "MAINTENANCE",
    ERROR = "ERROR",
    LATENCY = "LATENCY"
}
type GeneralStatusIDStrings = keyof typeof StatusID;
/**
 * Server Status response
 */
interface GeneralServerStatus {
    /**
     * ACTIVE = Online and fully operational
     *
     * MAINTENANCE = Offline for maintenance
     *
     * ERROR = Offline due to an error
     *
     * LATENCY = API is experience latency or a general slowdown
     */
    StatusID: GeneralStatusIDStrings;
    /** API version */
    Version: string;
    /** the location of the API by cluster */
    Region: string;
    /** when false means that user login (and thus a user token) is required for making measurements. */
    AllowAnonymous: boolean;
}
/**
 * Mime type
 */
interface GeneralMIMEType {
    /** GUID */
    ID: string;
    Mime: string;
    Name: string;
}
interface GeneralVerifyToken {
    ActiveLicense: boolean;
    DeviceID: string;
    ID: string;
    OrganizationID: string;
    Region: string;
    RemainingMeasurement: number | null;
    RoleID: string;
    SessionGen: number;
    Type: string;
    exp: number;
    iat: number;
    iss: string;
}
interface GeneralRegions {
    'as-east': 'AS East';
    'as-hk': 'AS Hong Kong';
    'cn-north': 'cn-north-1';
    'cn-west': 'cn-northwest-1';
    'eu-central': 'EU Central';
    'na-east': 'NA East';
    'sa-east': 'SA East';
}
/**
 * Available Status
 */
interface GeneralStatus {
    Description: string;
    ID: string;
    Name: string;
}
/**
 * Available Roles
 */
interface GeneralRoles {
    Description: string;
    ID: string;
    Name: string;
}
/** @noInheritDoc */
interface GeneralServerStatus200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Server Status
     */
    body: GeneralServerStatus;
}
/** @noInheritDoc */
interface GeneralListAcceptedMIMETypes200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * List accepted Mime types
     */
    body: GeneralMIMEType[];
}
/** @noInheritDoc */
interface GeneralVerifyToken200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Verify token
     */
    body: GeneralVerifyToken;
}
/** @noInheritDoc */
interface GeneralRegions200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Regions
     */
    body: GeneralRegions;
}
/** @noInheritDoc */
interface GeneralListAvailableStatuses200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * List Available Statuses
     */
    body: GeneralStatus[];
}
/** @noInheritDoc */
interface GeneralListAvailableRoles200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * List Available roles
     */
    body: GeneralRoles[];
}
interface RolesInteractionTree {
    rolesKeysArray: string[];
    roleNames: object;
    rolesNamesAsSelectInput: Array<{
        id: string;
        name: string;
    }>;
    rolesCanChangeSelfRole: Record<string, string[]>;
    rolesCanCreate: Record<string, string[]>;
    rolesCanDelete: Record<string, string[]>;
    rolesCanInterchangeOtherRoles: Record<string, string[]>;
    rolesCanList: Record<string, string[]>;
    rolesCanRead: Record<string, string[]>;
    rolesCanUpdate: Record<string, string[]>;
}
/** @noInheritDoc */
interface GetRolesInteractionTree200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: RolesInteractionTree;
}
interface Prescription {
    config: string;
}
/** @noInheritDoc */
interface GetPrescription200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: Prescription;
}
interface RetrieveConsent200Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: ConsentObj;
}
interface CreateConsent {
    success: true;
}
interface CreateConsent200Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: CreateConsent;
}
interface UpdateConsent {
    success: true;
}
interface UpdateConsent200Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UpdateConsent;
}

/**
 * General end points
 */
declare class General extends Main {
    /**
     * An endpoint that propagates the current API health status and
     * other information. This can be used during an apps initial boot
     * process to determine the accessibility of the API and propagate
     * a general status message to users.
     *
     * Endpoint Action ID = 100
     */
    status(): Promise<GeneralServerStatus200Response | ErrorResponse>;
    /**
     * Returns a list of system-wide accepted Mime types and their IDs.
     *
     * Endpoint Action ID = 101
     */
    listAcceptedMimeTypes(): Promise<GeneralListAcceptedMIMETypes200Response | ErrorResponse>;
    /**
     * Retrieves a list of available User Roles.
     *
     * Endpoint Action ID = 102
     */
    listAvailableUserRoles(): Promise<GeneralListAvailableRoles200Response | ErrorResponse>;
    /**
     * Retrieves a list of available status codes that can be used throughout
     * the application to update the StatusID field of various resources.
     *
     * Endpoint Action ID = 104
     */
    listAvailableStatuses(): Promise<GeneralListAvailableStatuses200Response | ErrorResponse>;
    /**
     * Checks validity of your Token and returns its encoded info.
     *
     * Endpoint Action ID = 107
     */
    verifyToken(token: string): Promise<GeneralVerifyToken200Response | ErrorResponse>;
    /**
     * Return the list of regions available for clusters.
     *
     * Endpoint Action ID = 108
     */
    regions(): Promise<GeneralRegions200Response | ErrorResponse>;
    /**
     * Retrieve consent.
     *
     * Endpoint Action ID = 109
     */
    retrieveConsent(): Promise<RetrieveConsent200Response | ErrorResponse>;
    /**
     * Create consent.
     *
     * Endpoint Action ID = 110
     */
    createConsent(data: ConsentObj): Promise<CreateConsent200Response | ErrorResponse>;
    /**
     * Update consent.
     *
     * Endpoint Action ID = 111
     */
    updateConsent(data: ConsentObj): Promise<UpdateConsent200Response | ErrorResponse>;
    /**
     * Return the list of regions available for clusters.
     *
     * Endpoint Action ID = 113
     */
    getRolesInteractionTree(): Promise<GetRolesInteractionTree200Response | ErrorResponse>;
    /**
     * Retrieve a user Prescription
     *
     * Endpoint Action ID = 114
     */
    getPrescription(prescriptionId: string): Promise<GetPrescription200Response | ErrorResponse>;
}

/**
 * License
 */
interface License {
    Created: number | null;
    ID: string | null;
    StatusID: string | null;
    Expiration: string | null;
    MaxDevices: number | null;
    OrganizationID: string | null;
    DeviceRegistrations: number | null;
    LicenseTypeID: string | null;
    LicenseType: string | null;
    SDKPlatforms: string[];
    Username: string | null;
    TotalCount?: number | null;
}
/** @noInheritDoc */
interface LicensesListLicenses200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: License[];
}
interface OrgLicenses {
    ID: string;
    LicenseType: string;
    StatusID: string;
    Expiration: number;
    Key: string;
    MaxDevices: number;
    Created: number;
    DeviceRegistrations: number;
    TotalCount: number;
}
/** @noInheritDoc */
interface LicensesListOrgLicenses200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * List of available licenses response
     */
    body: OrgLicenses[];
}
interface LicensesUpdateLicense {
    success: boolean;
}
/** @noInheritDoc */
interface LicensesUpdateLicense200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: LicensesUpdateLicense;
}
interface LicensesRemoveLicense {
    success: boolean;
}
/** @noInheritDoc */
interface LicensesRemoveLicense200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: LicensesRemoveLicense;
}
interface LicensesCreateLicense {
    ID: string;
}
/** @noInheritDoc */
interface LicensesCreateLicense200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: LicensesCreateLicense;
}
interface RetrieveOrgLicense {
    Created: number | null;
    ID: string | null;
    StatusID: string | null;
    Expiration: string | null;
    Key: string | null;
    MaxDevices: number | null;
    LicenseType: string | null;
    LicenseTypeID: string | null;
    DeviceRegistrations: number | null;
    SDKPlatforms: string[] | null;
}
/** @noInheritDoc */
interface LicensesRetrieveOrgLicense200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: RetrieveOrgLicense;
}
/** @noInheritDoc */
interface LicensesRetrieveLicense200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: License;
}

interface LicensesUpdateLicenseRequest {
    StatusID: string | null;
    LicenseTypeID: string | null;
    MaxDevices: number | null;
    Expiration: string | null;
    SDKPlatforms: string[] | null;
}
interface LicensesCreateLicenseRequest {
    OrganizationID: string | null;
    LicenseType: string | null;
    MaxDevices: number | null;
    Expiration: string | null;
    SDKPlatforms: string[] | null;
}
interface LicensesListOrgLicensesRequest {
    limit?: number;
    offset?: number;
    date?: string;
    endDate?: string;
    sortBy?: string;
    sortOrder?: 'ASC' | 'DESC';
    licenseType?: string;
    statusId?: string;
}
interface LicensesListRequest {
    date?: string;
    endDate?: string;
    licenseType?: string;
    limit?: number;
    offset?: number;
    orgId?: string;
    sortBy?: string;
    sortOrder?: 'ASC' | 'DESC';
    statusId?: string;
    userName?: string;
}

/**
 * Licenses end points
 *
 * These endpoints allow you to list the Licenses available to
 * your User/Organization.
 */
declare class Licenses extends Main {
    /**
     * Retrieve License
     *
     * Endpoint Action ID = 1404
     */
    retrieveLicense(id: string): Promise<LicensesRetrieveLicense200Response | ErrorResponse>;
    /**
     * List licenses
     *
     * Endpoint Action ID = 1405
     *
     */
    listLicenses(data?: LicensesListRequest): Promise<LicensesListLicenses200Response | ErrorResponse>;
    /**
     * List org licenses
     *
     * Endpoint Action ID = 1406
     *
     */
    listOrgLicenses(data?: LicensesListOrgLicensesRequest): Promise<LicensesListOrgLicenses200Response | ErrorResponse>;
    /**
     * Create License
     *
     * Endpoint Action ID = 1407
     */
    createLicense(data: LicensesCreateLicenseRequest): Promise<LicensesCreateLicense200Response | ErrorResponse>;
    /**
     * Update License
     *
     * Endpoint Action ID = 1408
     */
    updateLicense(licenseId: string, data: LicensesUpdateLicenseRequest): Promise<LicensesUpdateLicense200Response | ErrorResponse>;
    /**
     * Remove License
     *
     * Endpoint Action ID = 1409
     */
    removeLicense(licenseId: string): Promise<LicensesRemoveLicense200Response | ErrorResponse>;
    /**
     * Retrieve Org License
     *
     * Endpoint Action ID = 1411
     */
    retrieveOrgLicense(id: string): Promise<LicensesRetrieveOrgLicense200Response | ErrorResponse>;
}

/**
 * Measurement Created
 */
interface MeasurementCreated {
    ID: string;
}
/** @noInheritDoc */
interface MeasurementCreated200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Measurement Created response
     */
    body: MeasurementCreated;
}
/**
 * Measurement retrieve
 */
interface MeasurementRetrieve {
    Created: number;
    Updated: number;
    ID: string;
    OrganizationID: string;
    StatusID: string;
    UserID: string;
    UserProfileID: string;
    DeviceID: string;
    StudyID: string;
    Resolution: number;
    DeviceVersion: string;
    Comments: object;
    Mode: string;
    City: string;
    State: string;
    Country: string;
    Region: string;
    PartnerID: string;
    Results: object;
    SignalNames: object;
    SignalDescriptions: object;
    SignalConfig: object;
    SignalUnits: object;
    DataSizeBytes: number;
}
/** @noInheritDoc */
interface MeasurementRetrieved200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Measurement retrieved response
     */
    body: MeasurementRetrieve;
}
/**
 * Measurement list
 */
interface MeasurementList {
    ID: string;
    UserID: string;
    UserProfileID: string | null;
    UserProfileName: string | null;
    DeviceID: string | null;
    StudyID: string;
    StatusID: string;
    DeviceVersion: string | null;
    Mode: string;
    Created: number;
    Updated: number;
    TotalCount: number;
}
/** @noInheritDoc */
interface MeasurementList200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Measurement retrieved response
     */
    body: MeasurementList[];
}
/**
 * Measurement add data
 */
interface MeasurementAddData {
    ID: string;
    ChunkOrder: number;
}
/** @noInheritDoc */
interface MeasurementAddData200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Measurement add data response
     */
    body: MeasurementAddData;
}
/** @noInheritDoc */
interface MeasurementDelete200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}

/**
 * Measurement create request
 */
interface MeasurementCreateRequest {
    StudyID: string;
    Resolution: number;
    /** User Profile ID (optional) */
    UserProfileID?: string;
    /** Optional or mandatory depending on license policy */
    PartnerID?: string;
}
/**
 * Measurement add data request
 */
interface MeasurementAddDataRequest {
    Action: string;
    /** base64-encoded payload */
    Payload: string;
}
/**
 * Measurement list request
 */
interface MeasurementListRequest {
    statusId: string | null;
    userProfileId: string | null;
    userProfileName: string | null;
    studyId: string | null;
    partnerId: string | null;
    date: string | null;
    endDate: string | null;
    limit: string | null;
    offset: string | null;
    deviceID: string | null;
    userName?: string | null;
    sortBy: string | null;
    sortOrder: string | null;
    mode?: string | null;
}

/**
 * Measurements end points
 *
 * Measurements are individual one-time captures of blood flow data.
 * A single measurement record could represent multiple models of data analysis,
 * hence this data structure supports lookup parameters to filter them.
 *
 * Note: A valid License is required in order to create Measurements and submit
 * data chunks for processing. Please make sure to call Register License endpoint
 * first to receive a Device Token that grants access to these functions.
 * Next, in order to have your user information associated with the measurements,
 * you can use the User Login endpoint to obtain a User Token, which can be used to take
 * measurements as well.
 *
 * Important: If your License Type is SDK_DEVICE, you must login and obtain a User Token
 * as this License Type only allows you to perform a login operation.
 */
declare class Measurements extends Main {
    /**
     * Returns the results of a measurement request specified by
     * the UUID in the endpoint request. This payload will change
     * according to the different requested signals.
     *
     * Endpoint Action ID = 500
     */
    retrieve(id: string, tokenType: 'user' | 'device'): Promise<MeasurementRetrieved200Response | ErrorResponse>;
    /**
     * Provides a historical list of measurements captured by the API store. The results
     * of the measurements are captured and only displayed for the current application
     * providers token designator. Each record has a status representing its cycle in the system:
     *
     * Status Message	| Description
     * * CAPTURING    | A new record was created and results are being received.
     * * PROCESSING   | Capture is complete and the record is processing.
     * * COMPLETE     | The analysis is complete and ready for consumption.
     * * ERROR        | An error occurred during processing.
     * * INCOMPLETE   | Capturing process returned as incomplete/not enough data.
     *
     * Endpoint Action ID = 501
     */
    list(data?: MeasurementListRequest): Promise<MeasurementList200Response | ErrorResponse>;
    /**
     * Begins a new data capture session and returns a measurement ID
     * property, which should be referenced for adding data chunks and
     * retreiving results.
     *
     * Resolution: currently can be either 0 or 100. (default is 100)
     *
     * * 100 means the result set will have 100% of the original size
     *
     * * 0 returns 1 value per signal
     *
     * PartnerID is mandatory or optional (based on License policy).
     *
     * Endpoint Action ID = 504
     */
    create(data: MeasurementCreateRequest): Promise<MeasurementCreated200Response | ErrorResponse>;
    /**
     * Adds collected blood-flow data to a specific measurement. Upon submitting a
     * chunk of data, the API will return a MeasurementDataID value representing
     * the received chunk. Data must be sent to the server in the order produced by
     * the DFX SDK. If a chunk it sent out of order, the server will return an error.
     * Please ensure that new chunks are only sent after the server responds with a
     * MeasurementDataID.
     *
     * Submitting measurements has three stages:
     *
     * a) starting,
     *
     * b) measurement body,
     *
     * c) closing a measurement.
     *
     * Each of these phases have the same payload structure however a different Action
     * flag is to be sent with each request and must follow the CHUNK::ACTION format.
     *
     * Measurement Actions | Description
     *
     * FIRST::PROCESS      | Start a new measurement (drop any existing), Process results
     *
     * FIRST::IGNORE       | Start a new measurement (drop any existing), Do not process
     *
     * CHUNK::PROCESS      | Arbitrary block of TOI data and process results
     *
     * CHUNK::IGNORE       | Arbitrary block of TOI data and do not process results
     *
     * LAST::PROCESS       | Finish a measurement cycle and process results
     *
     * LAST::IGNORE        | Finish a measurement cycle and do not process
     *
     * `Payload` is binary data that can currently only be obtained by using our SDK.
     * The Payload (binary content) field must be `base64-encoded`.
     *
     * Note: This endpoint is a subject to request throttling, you must not submit more
     * data than can be obtained in real time. i.e., do not send more than five seconds
     * of chunk data over the course of five seconds of real time.
     *
     * Response Error Codes Explanation:
     *
     * * "RATE_LIMIT": You have sent too many chunks in a given time period. See the Note above.
     * * "MEASUREMENT_CLOSED": Requested Measurement is already finished. You need to create a new Measurement.
     * * "MISALIGNED_CHUNK": Chunk Order was mismatched. i.e., ChunkOrder 2 was sent before ChunkOrder 1.
     * * "INVALID_MEASUREMENT": Requested Measurement ID was not found.
     * * "UNPACKER_RPC_ERROR": Payload validation has been failed. Reason(s) will be provided in error message.
     *
     * Endpoint Action ID = 506
     */
    data(id: string, data: MeasurementAddDataRequest): Promise<MeasurementAddData200Response | ErrorResponse>;
    /**
     * Only DFX_ORG_ADMIN has permission to delete a specific measurment by
     * measurement ID for its own organization.
     *
     * Endpoint Action ID = 507
     */
    delete(id: string): Promise<MeasurementDelete200Response | ErrorResponse>;
}

/**
 * Organization retrieve information
 */
interface OrgRetrieveInformation {
    ID: string;
    Name: string;
    Identifier: string;
    StatusID: string;
    Contact: string;
    Email: string;
    PasswordMinLength: number;
    AdminPasswordMinLength: number;
    PasswordRequireCharacterClasses: number;
    PasswordRequireUppercase: boolean;
    PasswordRequireLowercase: boolean;
    PasswordRequireDigits: boolean;
    PasswordRequireSpecial: boolean;
    PasswordRotateDays: number;
    RequireUniquePasswordsCount: number;
    SessionMaxDurationSeconds: number;
    SessionIdleDurationSeconds: number;
    OrgAddresses: any[];
    LivenessConfig: {
        VisageLiveness: boolean;
        FakeDetection: boolean;
        SNRThresholding: boolean;
    };
    Created: number;
    Updated: number;
}
/** @noInheritDoc */
interface OrgRetrieveInformation200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization retrieve information response
     */
    body: OrgRetrieveInformation;
}
/**
 * Organization measurement info
 */
interface OrgMeasurementInfo {
    ID: string;
    OrganizationID: string;
    StatusID: string;
    UserID: string;
    UserProfileID: string | null;
    DeviceID: string;
    StudyID: string;
    Resolution: number;
    DeviceVersion: string | null;
    Comments: object;
    Mode: string;
    City: string;
    State: string;
    Country: string;
    Region: string;
    PartnerID: string | null;
    Results: object;
    SignalNames: object;
    SignalDescriptions: object;
    SignalConfig: object;
    SignalUnits: object;
    DataSizeBytes: number;
    Created: number;
    Updated: number;
}
/** @noInheritDoc */
interface OrgRetrieveMeasurement200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization retrieve measurement info response
     */
    body: OrgMeasurementInfo;
}
/**
 * Organization registered license
 */
interface OrgRegisteredLicense {
    DeviceID: string;
    Token: string;
    RefreshToken: string;
    /** Role associated with your License */
    RoleID: string;
    /** User account associated with your License */
    UserID: string;
}
/** @noInheritDoc */
interface OrgRegisterLicense200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization register license response
     */
    body: OrgRegisteredLicense;
}
/** @noInheritDoc */
interface OrgUnregisterLicense200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/**
 * Organization logo
 */
interface OrgLogo {
    data: string;
}
/** @noInheritDoc */
interface OrgLogo200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization logo
     */
    body: OrgLogo;
}
/**
 * Organization profile
 */
interface OrgProfile {
    ID: string;
    Name: string;
    Email: string;
    Status: string;
    MeasurementCount: string;
    OwnerUser: string | null;
    Created: number;
    Updated: number;
    TotalCount: number;
}
/** @noInheritDoc */
interface OrgListProfiles200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization list profiles
     */
    body: OrgProfile[];
}
/**
 * Organization user profile
 */
interface OrgUserProfile {
    ID: string;
    Name: string;
    Email: string;
    Status: string;
    MeasurementCount: number;
    Created: number;
    Updated: number;
}
/** @noInheritDoc */
interface OrgRetrieveProfile200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization retrieve user profile
     */
    body: OrgUserProfile;
}
/**
 * Organization user
 */
interface OrgUser {
    Gender: string;
    DateOfBirth: string | null;
    Created: number;
    Updated: number;
    ID: string;
    OrganizationID: string;
    RoleID: string;
    StatusID: string;
    Email: string;
    Password: string;
    FirstName: string | null;
    LastName: string | null;
    ResetToken: string | null;
    ResetTokenDate: string | null;
    AvatarURI: string | null;
    IsVerified: boolean;
    VerificationCode: string;
    PhoneNumber: string | null;
    DeviceID: string;
    HeightCm: number | null;
    WeightKg: number | null;
    LoginMethod: string;
    SSOID: string | null;
    Region: string;
}
/** @noInheritDoc */
interface OrgRetrieveUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization retrieve user
     */
    body: OrgUser;
}
/**
 * Organization create user
 */
interface OrgCreateUser {
    ID: string;
    ResetToken: string;
}
/** @noInheritDoc */
interface OrgCreateUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization create user response
     */
    body: OrgCreateUser;
}
/**
 * Organization update user
 */
interface OrgUpdateUser {
    success: boolean;
}
/** @noInheritDoc */
interface OrgUpdateUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization update user response
     */
    body: OrgUpdateUser;
}
/**
 * Organization delete user
 */
interface OrgDeleteUser {
    success: boolean;
}
/** @noInheritDoc */
interface OrgDeleteUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization delete user response
     */
    body: OrgDeleteUser;
}
/** @noInheritDoc */
interface OrgUpdateProfile200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
interface OrgLogin {
    Token: string;
    RefreshToken: string;
}
/** @noInheritDoc */
interface OrgLogin200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization login response
     */
    body: OrgLogin;
}
/** @noInheritDoc */
interface OrgDeleteSelfMeasurements200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/** @noInheritDoc */
interface OrgDeletePartnerMeasurements200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
interface OrgPasswordPolicy {
    PasswordMinLength: number;
    AdminPasswordMinLength: number;
    PasswordMaxLength: number;
    PasswordRequireUppercase: boolean;
    PasswordRequireLowercase: boolean;
    PasswordRequireDigits: boolean;
    PasswordRequireSpecial: boolean;
    PasswordSpecialCharacters: string;
    PasswordRotateDays: number;
    RequireUniquePasswordsCount: number;
    LimitLoginAttemptsCountPerWindow: number;
    LimitLoginAttemptsWindowDurationSeconds: number;
    LoginAttemptsLockoutDurationSeconds: number;
    SessionMaxDurationSeconds: number;
    SessionIdleDurationSeconds: number;
    LimitVerificationAttemptsCountPerWindow: number;
    LimitVerificationAttemptsWindowDurationSeconds: number;
}
/** @noInheritDoc */
interface OrgPasswordPolicy200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization password policy response
     */
    body: OrgPasswordPolicy;
}
interface OrgContactUser {
    success: boolean;
}
/** @noInheritDoc */
interface OrgContactUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organization contact user response
     */
    body: OrgContactUser;
}

/**
 * Organization end points
 *
 * This set of endpoints covers functions that allow to access
 * resources on the Organizational level. All endpoints require
 * Researcher, Lead or Admin access.
 */
declare class Organizations extends Main {
    /**
     * Retrieves information related to the current organization account.
     *
     * Endpoint Action ID = 700
     */
    retrieve(tokenType: 'device' | 'user'): Promise<OrgRetrieveInformation200Response | ErrorResponse>;
    /**
     * Retrieves a list of users in the current organization.
     *
     * This endpoint can filter by groups and account creation start
     * and end dates to make sorting and filtering easier.
     *
     * Endpoint Action ID = 702
     */
    users(data?: OrgUsersRequest): Promise<OrgRegisterLicense200Response | ErrorResponse>;
    /**
     * Similar to `measurements.list` endpoint but retrieves all
     * measurements across an Organization.
     *
     * Accessible by users with Researcher or Admin role.
     *
     * Endpoint Action ID = 703
     */
    listMeasurements(data?: OrgMeasurementsRequest): Promise<OrgRegisterLicense200Response | ErrorResponse>;
    /**
     * Similar to `measurements.retrieve` endpoint but retrieves a
     * measurement across the Organization.
     *
     * Accessible by users with Researcher or Admin role.
     *
     * Endpoint Action ID = 704
     */
    retrieveMeasurement(measurementId: string, expandResults?: boolean): Promise<OrgRetrieveMeasurement200Response | ErrorResponse>;
    /**
     * Allows consumers to exchange a license key for a device token.
     *
     * This endpoint is accessible publically to all consuming clients.
     * License keys are mapped against an organization. Upon submitting a registration key
     * and relevant information associated with the device to be registered, DFX API will
     * respond with a referencing DeviceID and a token for future device-specific API
     * requests. The resulting token is a Device Token.
     *
     * The longevity and allowed origins of the token can be controlled by TokenExpiresIn and
     * TokenSubject optional parameters.
     *
     * TokenExpiresIn specifies token validity duration in seconds. Effective duration will be
     * calculated as a minimum of TokenExpiresIn, license Expiration date and organization's
     * SessionMaxDurationseconds; i.e., this parameter can only be used to further reduce token's lifespan.
     *
     * TokenSubject locks the host which is allowed to use the token for its communication with DeepAffex.
     * When set, the server will compare the token value with HTTP request's Referer header and reject the
     * request if those don't match.
     *
     * Note: Please make sure to store the obtained token locally as most Licenses (e.g. Trial) allow for a
     * limited number of registered Devices. To unregister a Device and get back one license, call the
     * unregisterLicense method with your Device Token.
     *
     * Endpoint Action ID = 705
     */
    registerLicense(data: OrgRegisterLicenseRequest, enableSession: boolean): Promise<OrgRegisterLicense200Response | ErrorResponse>;
    /**
     * Send the Device Token as the Authorization header to decommission a registered device.
     *
     * Note that this does not delete the Device.
     *
     * Endpoint Action ID = 706
     */
    unregisterLicense(): Promise<OrgUnregisterLicense200Response | ErrorResponse>;
    /**
     * Retrieves an Organization logo. This endpoint will return a buffer containing a logo
     *
     * Endpoint Action ID = 708
     */
    retrieveLogo(orgId: string): Promise<OrgLogo200Response | ErrorResponse>;
    /**
     * Similar to `profiles.list` endpoint but retrieves profiles across the Organization.
     *
     * Accessible by users with Researcher or Admin role.
     *
     * Endpoint Action ID = 710
     */
    listProfiles(data?: OrgListProfileRequest): Promise<OrgListProfiles200Response | ErrorResponse>;
    /**
     * Similar to `profiles.retrieve` endpoint but retrieves a profile from the Organization
     *
     * Accessible by users with Researcher or Admin role.
     *
     * Endpoint Action ID = 711
     */
    retrieveProfile(profileId: string): Promise<OrgRetrieveProfile200Response | ErrorResponse>;
    /**
     * Similar to `users.retrieve` endpoint but retrieves a user from the Organization.
     *
     * Accessible only by users with Admin role.
     *
     * Endpoint Action ID = 712
     */
    retrieveUser(userId: string): Promise<OrgRetrieveUser200Response | ErrorResponse>;
    /**
     * Creates a user under the organization. Available only to an Administrator.
     *
     * An email will be sent to submitted Email address with a link to setup password
     * for the account. To create a user under your organization. You will need to be
     * logged in as a DFX_LEAD, DFX_ORG_ADMIN
     *
     * Endpoint Action ID = 713
     */
    createUser(data: OrgCreateUserRequest): Promise<OrgCreateUser200Response | ErrorResponse>;
    /**
     * Similar to `users.update` endpoint but updates a User from the Organization.
     *
     * Accessible only by users with Admin role.
     *
     * Endpoint Action ID = 714
     */
    updateUser(userId: string, data: OrgUpdateUserRequest): Promise<OrgUpdateUser200Response | ErrorResponse>;
    /**
     * Similar to `users.remove` endpoint but performed by an Organization's Admin.
     *
     * Accessible only by users with Admin role.
     *
     * Endpoint Action ID = 715
     */
    removeUser(userId: string): Promise<OrgDeleteUser200Response | ErrorResponse>;
    /**
     * Similar to `profiles.update` endpoint but updates a Profile from the Organization.
     *
     * Accessible by users with Researcher or Admin role.
     *
     * Endpoint Action ID = 716
     */
    updateProfile(profileId: string, data: OrgUpdateProfileRequest): Promise<OrgUpdateProfile200Response | ErrorResponse>;
    /**
     * Login and obtain User Token.
     *
     * Note: Token obtained from this endpoint does not allow you to
     * take Measurements and is intended for viewing purposes only.
     *
     * Note: MFAToken parameter is required only when 2FA authentication is enabled.
     *
     * Endpoint Action ID = 717
     */
    login(data: OrgLoginRequest, enableSession: boolean): Promise<OrgLogin200Response | ErrorResponse>;
    /**
     * Contact User
     *
     * Endpoint Actions ID = 719
     */
    contactUser(data: OrgContactUserRequest): Promise<OrgContactUser200Response | ErrorResponse>;
    /**
     * Only DFX_ORG_ADMIN has permission to delete all measurment for their own organization.
     *
     * Endpoint Action ID = 721
     */
    deleteOrgMeasurement(orgId: string): Promise<OrgDeleteSelfMeasurements200Response | ErrorResponse>;
    /**
     * Only DFX_ORG_ADMIN has permission to delete all measurements of
     * specific PartnerIDs for their own organization.
     *
     * Endpoint Action ID = 722
     */
    deletePartnerMeasurement(orgId: string, partnerId: string): Promise<OrgDeletePartnerMeasurements200Response | ErrorResponse>;
    /**
     *
     * Returns the password policy for an organization
     *
     * Endpoint Action ID = 723
     */
    getPasswordPolicy(): Promise<OrgPasswordPolicy200Response | ErrorResponse>;
}

/**
 * Organizations private list request
 */
interface OrganizationsPrivateListRequest {
    limit: number | null;
    offset: number | null;
    date: string | null;
    endDate: string | null;
    sortBy: string | null;
    sortOrder?: 'ASC' | 'DESC';
    name: string | null;
    statusId: string | null;
}
interface OrganizationsPrivateTemplateAddRequest {
    StudyTemplateID: string | null;
    SavePayloads: boolean | null;
    SavePayloadImages: boolean | null;
    SaveResults: boolean | null;
    RemainingMeasurement?: number | null;
    IsHardLimit?: boolean | null;
}
interface OrganizationsPrivateTemplateUpdateRequest {
    StudyTemplateID: string | null;
    SavePayloads?: boolean | null;
    SavePayloadImages?: boolean | null;
    SaveResults?: boolean | null;
    RemainingMeasurement?: number | null;
    IsHardLimit?: boolean | null;
}
interface OrganizationsPrivateCreateAdmin$1 {
    Email: string;
    OrgAdminRegion: string;
    Password: string;
}
interface OrganizationsPrivateUpdateLogoRequest {
    Logo: string;
}
interface OrgAddress {
    Line1: string | null;
    Line2: string | null;
    City: string | null;
    State: string | null;
    Country: string | null;
    PostalCode: string | null;
    Region: string | null;
}
interface LivenessConfig {
    VisageLiveness: boolean | null;
    FakeDetection: boolean | null;
    SNRThresholding: boolean | null;
}
interface OrganizationsPrivateUpdateRequest {
    Created: string | null;
    Updated: number | null;
    ID: string | null;
    Name: string | null;
    Identifier: string | null;
    StatusID: string | null;
    Logo: string | null;
    BrandID: string | null;
    Contact: string | null;
    Email: string | null;
    ConsentId: string | null;
    OrgAddresses: OrgAddress[];
    LivenessConfig: LivenessConfig;
    LogoURL?: string;
}
interface OrganizationsPrivateCreateRequest {
    OrgAddresses: OrgAddress[];
    OrgAdminRegion: string | null;
    Identifier: string | null;
    Name: string | null;
    Contact: string | null;
    Email: string | null;
    OrgAdminFirstName: string | null;
    OrgAdminLastName: string | null;
    OrgAdminEmail: string | null;
    NotifyAdmin?: boolean;
    Logo?: string;
    LivenessConfig?: LivenessConfig;
    LogoURL?: string;
}
interface IdentityProvidersUpdateRequest {
    cognitoName: string;
    cognitoType: 'SAML' | 'Facebook' | 'Google' | 'LoginWithAmazon' | 'SignInWithApple' | 'OIDC';
    displayName: string;
    details: object;
}

/**
 * Organizations private list users
 */
interface OrganizationsPrivateListUsers {
    Created: number;
    DateOfBirth: string | null;
    Email: string | null;
    FirstName: string | null;
    Gender: string | null;
    ID: string;
    LastName: string | null;
    MFAEnabled: boolean;
    PasswordSetDate: string;
    PhoneNumber: string | null;
    Region: string;
    RoleID: string;
    TotalCount: number;
}
/** @noInheritDoc */
interface OrganizationsPrivateListUsers200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private list users
     */
    body: OrganizationsPrivateListUsers;
}
/**
 * Organizations private list
 */
interface OrganizationsPrivateList {
    BrandID: string | null;
    ConsentId: string | null;
    Contact: string | null;
    Created: number;
    Email: string | null;
    ID: string;
    Identifier: string;
    LivenessConfig: LivenessConfig;
    Logo: string | null;
    Name: string | null;
    OrgAddresses: Array<{
        Address: OrgAddress;
        AddressID: string;
        ID: string;
        OrganizationID: string;
    }>;
    PublicKey: string | null;
    StatusID: string | null;
    TotalCount: number;
    Updated: number;
    LogoURL?: string;
}
/** @noInheritDoc */
interface OrganizationsPrivateList200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private list response
     */
    body: OrganizationsPrivateList;
}
/**
 * Organizations Private Template Add
 */
interface OrganizationsPrivateTemplateAdd {
    ID: string;
}
/** @noInheritDoc */
interface OrganizationsPrivateTemplateAdd200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private template add response
     */
    body: OrganizationsPrivateTemplateAdd;
}
/**
 * Organizations Private Template Remove
 */
interface OrganizationsPrivateTemplateRemove {
    success: boolean;
}
/** @noInheritDoc */
interface OrganizationsPrivateTemplateRemove200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private template add response
     */
    body: OrganizationsPrivateTemplateRemove;
}
/**
 * Organizations Private Template List
 */
type OrganizationsPrivateTemplateList = Array<{
    ID: string | null;
    OrganizationID: string | null;
    StudyTemplateID: string | null;
    SavePayloads: boolean | null;
    SavePayloadImages: boolean | null;
    SaveResults: boolean | null;
    RemainingMeasurement: number | null;
    NotificationSent: boolean | null;
    IsHardLimit: boolean | null;
    StartDate: string | null;
    EndDate: string | null;
}>;
/** @noInheritDoc */
interface OrganizationsPrivateTemplateList200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private template list response
     */
    body: OrganizationsPrivateTemplateList;
}
/**
 * Organizations Private List Admins
 */
type OrganizationsPrivateListAdmins = Array<{
    ID: string | null;
    Email: string | null;
    Created: string | null;
    RoleID: string | null;
}>;
/** @noInheritDoc */
interface OrganizationsPrivateListAdmins200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private template list response
     */
    body: OrganizationsPrivateListAdmins;
}
/**
 * Organizations Private Create Admin
 */
interface OrganizationsPrivateCreateAdmin {
    UserID: string | null;
}
/** @noInheritDoc */
interface OrganizationsPrivateCreateAdmin200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private template create admin
     */
    body: OrganizationsPrivateCreateAdmin;
}
/**
 * Organizations Private Remove Admin
 */
interface OrganizationsPrivateRemoveAdmin {
    success: boolean;
}
/** @noInheritDoc */
interface OrganizationsPrivateRemoveAdmin200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private template create admin response
     */
    body: OrganizationsPrivateRemoveAdmin;
}
/**
 * Organizations Private Update Logo
 */
interface OrganizationsPrivateUpdateLogo {
    success: boolean;
}
/** @noInheritDoc */
interface OrganizationsPrivateUpdateLogo200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private update logo response
     */
    body: OrganizationsPrivateUpdateLogo;
}
/**
 * Organizations Private Template Update
 */
interface OrganizationsPrivateTemplateUpdate {
    success: boolean;
}
/** @noInheritDoc */
interface OrganizationsPrivateTemplateUpdate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Organizations private template update response
     */
    body: OrganizationsPrivateTemplateUpdate;
}
interface OrganizationsPrivateUpdate {
    success: boolean;
}
/** @noInheritDoc */
interface OrganizationsPrivateUpdate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: OrganizationsPrivateUpdate;
}
interface OrganizationsPrivateRetrieve {
    Created: string | null;
    Updated: number | null;
    ID: string | null;
    Name: string | null;
    Identifier: string | null;
    StatusID: string | null;
    Logo: string | null;
    BrandID: string | null;
    Contact: string | null;
    Email: string | null;
    ConsentId: string | null;
    OrgAddresses: OrgAddress[];
    LivenessConfig: LivenessConfig;
    LogoURL?: string;
}
/** @noInheritDoc */
interface OrganizationsPrivateRetrieve200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: OrganizationsPrivateRetrieve;
}
interface Create {
    success: boolean;
    ID: string;
}
/** @noInheritDoc */
interface OrganizationsPrivateCreate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: Create;
}
interface IdentityProvidersUpdate {
    success: boolean;
}
/** @noInheritDoc */
interface IdentityProvidersUpdate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: IdentityProvidersUpdate;
}

/**
 * Organizations Private end points
 *
 */
declare class OrganizationsPrivate extends Main {
    /**
     * Organizations Private list
     *
     * Endpoint Action ID = 1200
     */
    list(data?: OrganizationsPrivateListRequest): Promise<OrganizationsPrivateList200Response | ErrorResponse>;
    /**
     * Organizations Private Create
     *
     * Endpoint Action ID = 1201
     */
    create(data: OrganizationsPrivateCreateRequest): Promise<OrganizationsPrivateCreate200Response | ErrorResponse>;
    /**
     * Organizations Private Update
     *
     * Endpoint Action ID = 1202
     */
    update(orgId: string, data: OrganizationsPrivateUpdateRequest): Promise<OrganizationsPrivateUpdate200Response | ErrorResponse>;
    /**
     * Organizations Private template add
     *
     * Endpoint Action ID = 1203
     */
    templateAdd(orgId: string, data: OrganizationsPrivateTemplateAddRequest): Promise<OrganizationsPrivateTemplateAdd200Response | ErrorResponse>;
    /**
     * Organizations Private template remove
     *
     * Endpoint Action ID = 1204
     */
    templateRemove(orgId: string, templateId: string): Promise<OrganizationsPrivateTemplateRemove200Response | ErrorResponse>;
    /**
     * Organizations Private
     *
     * Endpoint Action ID = 1205
     */
    retrieve(id: string): Promise<OrganizationsPrivateRetrieve200Response | ErrorResponse>;
    /**
     * Organizations Private template list
     *
     * Endpoint Action ID = 1206
     */
    templateList(orgId: string): Promise<OrganizationsPrivateTemplateList200Response | ErrorResponse>;
    /**
     * Organizations Private list admins
     *
     * Endpoint Action ID = 1207
     */
    listAdmins(orgId: string): Promise<OrganizationsPrivateListAdmins200Response | ErrorResponse>;
    /**
     * Organizations Private create admin
     *
     * Endpoint Action ID = 1208
     */
    createAdmin(orgId: string, data: OrganizationsPrivateCreateAdmin$1): Promise<OrganizationsPrivateCreateAdmin200Response | ErrorResponse>;
    /**
     * Organizations Private create admin
     *
     * Endpoint Action ID = 1209
     */
    removeAdmin(orgId: string, userId: string): Promise<OrganizationsPrivateRemoveAdmin200Response | ErrorResponse>;
    /**
     * Organizations Private list users
     *
     * Endpoint Action ID = 1210
     */
    listUsers(orgId: string): Promise<OrganizationsPrivateListUsers200Response | ErrorResponse>;
    /**
     * Organizations Private update logo
     *
     * Endpoint Action ID = 1212
     */
    updateLogo(orgId: string, data: OrganizationsPrivateUpdateLogoRequest): Promise<OrganizationsPrivateUpdateLogo200Response | ErrorResponse>;
    /**
     * Organizations Private template update
     *
     * Endpoint Action ID = 1213
     */
    templateUpdate(orgId: string, data: OrganizationsPrivateTemplateUpdateRequest): Promise<OrganizationsPrivateTemplateUpdate200Response | ErrorResponse>;
    /**
     * Update Identity Providers
     *
     * Endpoint Action ID = 1218
     */
    updateIdentityProviders(orgId: string, data: IdentityProvidersUpdateRequest): Promise<IdentityProvidersUpdate200Response | ErrorResponse>;
}

/**
 * Profile created
 */
interface ProfileCreated {
    ID: string;
}
/** @noInheritDoc */
interface ProfileCreate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Profile created response
     */
    body: ProfileCreated;
}
/**
 * Profile retrieve
 */
interface ProfileRetrieve {
    ID: string;
    Name: string;
    Email: string;
    Status: string;
    MeasurementCount: number;
    Created: number;
    Updated: number;
}
/** @noInheritDoc */
interface ProfileRetrieve200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Profile retrieve response
     */
    body: ProfileRetrieve;
}
/**
 * Profile list
 */
interface ProfileList {
    ID: string;
    OwnerUserEmail: string;
    Name: string;
    Email: string;
    Status: string;
    MeasurementCount: number;
    Created: number;
    Updated: number;
    TotalCount: string;
}
/** @noInheritDoc */
interface ProfileList200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Profile list response
     */
    body: ProfileList[];
}
/** @noInheritDoc */
interface ProfileListByUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Profile list by user response
     */
    body: ProfileRetrieve[];
}
/** @noInheritDoc */
interface ProfileRemove200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/** @noInheritDoc */
interface ProfileUpdate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}

/**
 * Profile create request
 */
interface ProfileCreateRequest {
    Name: string;
    Email: string;
}
/**
 * Profile list request
 */
interface ProfileListRequest {
    userProfileName: string;
    status: string;
    /** default 25 */
    limit: number;
    /** default 0 */
    offset: number;
    sortBy: string | null;
    sortOrder: string | null;
    date?: string | null;
    endDate?: string | null;
    ownerUser?: string | null;
}
/**
 * Profile list request
 */
interface ProfileListByUserRequest {
    userProfileName: string;
    status: string;
    /** default 25 */
    limit: number;
    /** default 0 */
    offset: number;
}
/**
 * Profile update request
 */
interface ProfileUpdateRequest {
    Name: string;
    Email: string;
    Status: string;
}

/**
 * Profiles end points
 *
 * Profiles are elements of user accounts. A single user account
 * may maintain a number of profiles to help segment different
 * types of users.
 */
declare class Profiles extends Main {
    /**
     * Creates a user profile under a main user account.
     * User profiles may be used to segment different accounts
     * for measurements.
     *
     * Endpoint Action ID = 400
     */
    create(data: ProfileCreateRequest): Promise<ProfileCreate200Response | ErrorResponse>;
    /**
     * Retrieves a single user Profile specified by ID.
     *
     * Endpoint Action ID = 401
     */
    retrieve(profileId: string): Promise<ProfileRetrieve200Response | ErrorResponse>;
    /**
     * Lists specific profiles managed under the current user account.
     *
     * Endpoint Action ID = 402
     */
    list(data?: ProfileListRequest): Promise<ProfileList200Response | ErrorResponse>;
    /**
     * Lists specific profiles managed under a single user account
     * specified by the ID in the request parameters.
     *
     * Endpoint Action ID = 403
     */
    listByUser(userId: string, data?: ProfileListByUserRequest): Promise<ProfileListByUser200Response | ErrorResponse>;
    /**
     * Removes the user profile entirely. It also deletes any related
     * meta fields associated with the profile.
     *
     * Endpoint Action ID = 404
     */
    remove(profileId: string): Promise<ProfileRemove200Response | ErrorResponse>;
    /**
     * Updates a specific user profile. To update status the valid
     * options are: ACTIVE and INACTIVE.
     *
     * Endpoint Action ID = 405
     */
    update(profileId: string, data: ProfileUpdateRequest): Promise<ProfileUpdate200Response | ErrorResponse>;
}

/**
 * Reports count
 */
interface ReportsCount {
    MeasurementCount: number;
}
/** @noInheritDoc */
interface ReportsCount200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Reports count response
     */
    body: ReportsCount;
}
/**
 * Reports make
 */
interface ReportsMake {
    url: string;
    resultsFound: boolean;
}
/** @noInheritDoc */
interface ReportsMake200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Reports make response
     */
    body: ReportsMake;
}

/**
 * Reports count request
 */
interface ReportsCountRequest {
    FileName?: string;
    StudyID?: string;
    UserID?: string;
    MeasurementID?: string;
    OrganizationID?: string;
    Email?: string;
    StartDate?: string;
    EndDate?: string;
    Page?: number;
    Format: 'csv' | 'hdf5';
}
/**
 * Reports Make request
 */
interface ReportsMakeRequest {
    FileName?: string;
    StudyID?: string;
    UserID?: string;
    MeasurementID?: string;
    OrganizationID?: string;
    Email?: string;
    StartDate?: string;
    EndDate?: string;
    Page?: number;
    Format: 'csv' | 'hdf5';
}

/**
 * Reports end points
 *
 */
declare class Reports extends Main {
    /**
     * Count reports
     *
     * Endpoint Action ID = 1301
     */
    reportCount(data: ReportsCountRequest): Promise<ReportsCount200Response | ErrorResponse>;
    /**
     * Make a report
     *
     * Endpoint Action ID = 1302
     */
    makeReport(data: ReportsMakeRequest): Promise<ReportsMake200Response | ErrorResponse>;
}

/**
 * Study Type
 */
interface StudyType {
    ID: string;
    StatusID: string;
    Name: string;
    Description: string;
}
/** @noInheritDoc */
interface StudyTypes200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Study Types response
     */
    body: StudyType[];
}
/**
 * Study template
 */
interface StudyTemplate {
    ID: string;
    StatusID: string;
    Name: string;
    Description: string;
    BundleID: string | null;
    Config: object;
    StudyTypeID: string;
    Signals: string[];
    Created: number;
}
/** @noInheritDoc */
interface StudyTemplates200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Study templates response
     */
    body: StudyTemplate[];
}
/**
 * Study retrieve
 */
interface StudyRetrieve {
    ID: string;
    Name: string;
    Description: string;
    StatusID: string;
    OrganizationID: string;
    StudyTemplateID: string;
    StudyTemplateName: string;
    Measurements: number;
    Participants: number;
    Signals: string[];
    Created: number;
    Updated: number;
}
/** @noInheritDoc */
interface StudyRetrieve200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Study retrieve response
     */
    body: StudyRetrieve;
}
/**
 * Study
 */
interface Study {
    ID: string;
    Name: string;
    Description: string;
    StudyTemplateID: string;
    Measurements: number;
    Participants: number;
    StatusID: string;
    Created: number;
    Updated: number;
    TotalCount: number;
}
/** @noInheritDoc */
interface StudyList200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Array of studies
     */
    body: Study[];
}
/**
 * Study SDK config data
 */
interface StudySdkConfigData {
    ConfigFile: string;
    MD5Hash: string;
}
/** @noInheritDoc */
interface StudySdkConfigData200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Study SDK config data
     */
    body: StudySdkConfigData;
}
/**
 * Study created
 */
interface StudyCreate {
    ID: string;
}
/** @noInheritDoc */
interface StudyCreate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Study created response
     */
    body: StudyCreate;
}
/**
 * Study updated
 */
interface StudyUpdate {
    success: boolean;
}
/** @noInheritDoc */
interface StudyUpdate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Study updated response
     */
    body: StudyUpdate;
}
/**
 * Study deleted
 */
interface StudyDelete {
    success: boolean;
}
/** @noInheritDoc */
interface StudyDelete200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * Study deleted response
     */
    body: StudyDelete;
}
/** @noInheritDoc */
interface StudyDeleteMeasurements200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}

/**
 * Study templates request
 */
interface StudyTemplatesRequest {
    status?: string;
    type?: string;
    limit?: number;
    offset?: number;
    sortBy?: string;
    sortOrder?: string;
}
/**
 * Study RetrieveSdkConfigData request
 */
interface StudyRetrieveSdkConfigDataRequest {
    StudyID: string;
    SDKID?: string;
    MD5Hash?: string;
}
/**
 * Study create request
 */
interface StudyCreateRequest {
    Name: string;
    Description: string;
    StudyTemplateID: string;
    Config: Record<string, string>;
}
/**
 * Study update request
 */
interface StudyUpdateRequest {
    Name: string;
    Description: string;
    StatusID: string;
    Config: Record<string, string>;
}
/**
 * Study list request
 */
interface StudyListRequest {
    statusId: string | null;
    limit: number | null;
    offset: number | null;
    sortBy: string | null;
    sortOrder: string | null;
    date: string | null;
    endDate: string | null;
    name: string | null;
}

/**
 * Studies end points
 *
 * Studies are organized segments of analyses that guide the measurement process.
 * Studies consist of Types, Templates and Assets. A study type is a general,
 * high-level grouping for studies. A template is a pre-built study standard
 * created and made available by the Nuralogix team. Templates are version
 * controlled and named for use with a study.
 */
declare class Studies extends Main {
    /**
     * Retrieves a list of studies that act as templates or base types.
     * Types can be filtered by the Status querystring value. This is useful
     * for looking up all studies and current.
     *
     * Endpoint Action ID = 800
     */
    types(statusId: string | null): Promise<StudyTypes200Response | ErrorResponse>;
    /**
     * Retrieves a list of study templates that exist in a particular organization.
     *
     * Endpoint Action ID = 801
     */
    templates(data?: StudyTemplatesRequest): Promise<StudyTemplates200Response | ErrorResponse>;
    /**
     * Retrieves a study record with it's definitions and values.
     * It also displays the amount of measurements captured in it to date.
     *
     * Endpoint Action ID = 804
     */
    retrieve(studyId: string): Promise<StudyRetrieve200Response | ErrorResponse>;
    /**
     * Lists all the studies created in an organization.
     *
     * Endpoint Action ID = 805
     */
    list(data?: StudyListRequest): Promise<StudyList200Response | ErrorResponse>;
    /**
     * Retrieves a study's binary config data that has to be used to initialize the DFX SDK Factory object.
     * Get the SDKID parameter by calling GetSDKId on the DFX SDK Factory object. A response of 304 means
     * that existing file in hand is up to date.
     *
     * Endpoint Action ID = 806
     */
    retrieveSdkConfigData(data: StudyRetrieveSdkConfigDataRequest): Promise<StudySdkConfigData200Response | ErrorResponse>;
    /**
     * Creates a new study within an organization. Studies must be based on a specific StudyTemplateID.
     * Passing in config will override values available in the StudyType definition template.
     *
     * Endpoint Action ID = 80x
     */
    create(data: StudyCreateRequest): Promise<StudyCreate200Response | ErrorResponse>;
    /**
     * Updates a particular study record with new information. Organizations can set the status of a
     * particular study as well to record their general activity and visibility. Study templates
     * cannot be revised after a study is created.
     *
     * Endpoint Action ID = 807
     */
    update(studyId: string, data: StudyUpdateRequest): Promise<StudyUpdate200Response | ErrorResponse>;
    /**
     * Deletes a study. However, if there are any measurements taken under that Study
     * already, it cannot be deleted.
     *
     * Endpoint Action ID = 808
     */
    remove(studyId: string): Promise<StudyDelete200Response | ErrorResponse>;
    /**
     * Only DFX_ORG_ADMIN has permission to delete all measuremenet of specific study
     * for its own organization.
     *
     * Endpoint Action ID = 811
     */
    deleteStudyMeasurement(studyId: string): Promise<StudyDeleteMeasurements200Response | ErrorResponse>;
}

interface Template {
    Config: object;
    Created: string;
    Description: string;
    ID: string;
    Name: string;
    StatusID: string;
    StudyTypeID: string;
    Updated: string;
    TotalCount?: number;
}
type ListTemplates = Template[];
/** @noInheritDoc */
interface TemplatesListTemplates200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: ListTemplates;
}
type RetrieveTemplate = Template;
/** @noInheritDoc */
interface TemplatesRetrieveTemplate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: RetrieveTemplate;
}
interface UpdateSignals {
    success: boolean;
}
/** @noInheritDoc */
interface TemplatesUpdateSignals200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UpdateSignals;
}
type ListSignals = Array<{
    CaptureTimeMinimum: number | null;
    Config: {
        category: string;
    };
    Created: string;
    DefaultUpdateRateSec: number | null;
    Description: string | null;
    ID: string;
    Name: string | null;
    ResultTimeMinimum: number | null;
    Unit: string | null;
    Version: string | null;
    id: string;
}>;
/** @noInheritDoc */
interface TemplatesListSignals200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: ListSignals;
}
interface CreateTemplate {
    ID: string;
}
/** @noInheritDoc */
interface TemplatesCreateTemplate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: CreateTemplate;
}
interface TemplatesCreateConfigFile {
    success: boolean;
}
/** @noInheritDoc */
interface TemplatesCreateConfigFile200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: TemplatesCreateConfigFile;
}
interface TemplatesDeleteConfigFile {
    success: boolean;
}
/** @noInheritDoc */
interface TemplatesDeleteConfigFile200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: TemplatesDeleteConfigFile;
}
type TemplatesListConfigFiles = Array<{
    StudyTemplateID: string | null;
    SDKID: string | null;
    Created: string | null;
    MD5Hash: string | null;
    TotalCount?: number | null;
}>;
/** @noInheritDoc */
interface TemplatesListConfigFiles200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: TemplatesListConfigFiles;
}
interface ListTypes {
    Description: string;
    ID: string;
    Name: string;
    StatusID: string;
}
/** @noInheritDoc */
interface TemplatesListTypes200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: ListTypes[];
}
interface DeleteTemplate {
    success: boolean;
}
/** @noInheritDoc */
interface TemplatesDeleteTemplate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: DeleteTemplate;
}
interface UpdateTemplate {
    success: boolean;
}
/** @noInheritDoc */
interface TemplatesUpdateTemplate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UpdateTemplate;
}

interface UpdateSignalsRequest {
    StudySignals: {
        SignalID: string;
        UpdateRateSec: number | null;
    };
}
interface TemplatesCreateTemplateRequest {
    StudyTypeID: string | null;
    Name: string | null;
    Description: string | null;
    Config?: object;
}
interface TemplatesCreateConfigFileRequest {
    StudyTemplateID: string;
    SDKID: string;
    File: string;
}
interface TemplatesListConfigFilesRequest {
    limit?: number;
    offset?: number;
    date?: string;
    endDate?: string;
    studyTemplateId?: string;
    sdkId?: string;
}
interface TemplatesUpdateTemplateRequest {
    ID: string | null;
    StatusID: string | null;
    StudyTypeID: string | null;
    Name: string | null;
    Description: string | null;
    Config: object;
    Created: string | null;
    Updated: string | null;
    StudySignals: Array<{
        SignalID: null;
        UpdateRateSec: null;
    }>;
}
interface TemplatesListRequest {
    limit: string | null;
    offset: string | null;
    sortBy: string | null;
    sortOrder: string | null;
    date: string | null;
    endDate: string | null;
    name: string | null;
    statusId: string | null;
    studyTypeId: string | null;
}

/**
 * Templates end points
 *
 */
declare class Templates extends Main {
    /**
     * List templates
     *
     * Endpoint Action ID = 1100
     */
    listTemplates(data?: TemplatesListRequest): Promise<TemplatesListTemplates200Response | ErrorResponse>;
    /**
     * List template types
     *
     * Endpoint Action ID = 1101
     */
    listTypes(): Promise<TemplatesListTypes200Response | ErrorResponse>;
    /**
     * List templates
     *
     * Endpoint Action ID = 1102
     */
    listSignals(): Promise<TemplatesListSignals200Response | ErrorResponse>;
    /**
     * List templates
     *
     * Endpoint Action ID = 1104
     */
    retrieveTemplate(templateId: string): Promise<TemplatesRetrieveTemplate200Response | ErrorResponse>;
    /**
     * Delete template
     *
     * Endpoint Action ID = 1106
     */
    deleteTemplate(templateId: string): Promise<TemplatesDeleteTemplate200Response | ErrorResponse>;
    /**
     * Update template
     *
     * Endpoint Action ID = 1107
     */
    updateTemplate(templateId: string, data: TemplatesUpdateTemplateRequest): Promise<TemplatesUpdateTemplate200Response | ErrorResponse>;
    /**
     * Create Template
     *
     * Endpoint Action ID 1105
     */
    createTemplate(data: TemplatesCreateTemplateRequest): Promise<TemplatesCreateTemplate200Response | ErrorResponse>;
    /**
     * List templates
     *
     * Endpoint Action ID = 1108
     */
    updateSignals(templateId: string, data: UpdateSignalsRequest): Promise<TemplatesUpdateSignals200Response | ErrorResponse>;
    /**
     * List config files
     *
     * Endpoint Action ID = 1110
     */
    listConfigFiles(data?: TemplatesListConfigFilesRequest): Promise<TemplatesListConfigFiles200Response | ErrorResponse>;
    /**
     * Create config file
     *
     * Endpoint Action ID = 1111
     */
    createConfigFile(data: TemplatesCreateConfigFileRequest): Promise<TemplatesCreateConfigFile200Response | ErrorResponse>;
    /**
     * Create config file
     *
     * Endpoint Action ID = 1112
     */
    deleteConfigFile(StudyTemplateID: string, SDKID: string): Promise<TemplatesDeleteConfigFile200Response | ErrorResponse>;
}

/**
 * User created
 */
interface UserCreated {
    /**
     * New user GUID
     */
    ID: string;
}
/** @noInheritDoc */
interface UserCreate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User create response
     */
    body: UserCreated;
}
/**
 * Authenticated user
 */
interface UserAuthenticated {
    Token: string;
    RefreshToken: string;
}
/** @noInheritDoc */
interface UserLogin200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User login response
     */
    body: UserAuthenticated;
}
/**
 * User account information
 */
interface UserAccountInformation {
    Gender: string;
    DateOfBirth: string;
    Created: number;
    Updated: number;
    ID: string;
    OrganizationID: string;
    RoleID: string;
    StatusID: string;
    Email: string;
    Password: string;
    FirstName: string;
    LastName: string;
    ResetToken: string | null;
    ResetTokenDate: string | null;
    AvatarURI: string | null;
    IsVerified: boolean;
    VerificationCode: string | null;
    PhoneNumber: string | null;
    DeviceID: string | null;
    HeightCm: string | null;
    WeightKg: string | null;
    LoginMethod: string;
    SSOID: string | null;
    Region: string;
    MFAEnabled: boolean;
}
/** @noInheritDoc */
interface UserAccountInfo200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User account information
     */
    body: UserAccountInformation;
}
/** @noInheritDoc */
interface UserRemove200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/** @noInheritDoc */
interface UserUpdate200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/**
 * User role
 */
interface UserRole {
    ID: string;
    Name: string;
    Description: string;
    Organization: string;
}
/** @noInheritDoc */
interface UserRetrieveRole200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User role response
     */
    body: UserRole;
}
/**
 * User verify
 */
interface UserVerify {
    success: boolean;
}
/** @noInheritDoc */
interface UserVerify200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User verify response
     */
    body: UserVerify;
}
/**
 * User verify
 */
interface UserAccountVerificationCode {
    success: boolean;
    Message: string;
}
/** @noInheritDoc */
interface UserAccountVerificationCode200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User account verification code
     */
    body: UserAccountVerificationCode;
}
/**
 * User login with phone code
 */
interface UserLoginWithPhoneCode {
    Token: string;
    RefreshToken: string;
}
/** @noInheritDoc */
interface UserLoginWithPhoneCode200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User login with phone code response
     */
    body: UserLoginWithPhoneCode;
}
/** @noInheritDoc */
interface UserDelete200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
}
/**
 * User change password
 */
interface UserChangePassword {
    success: boolean;
}
/** @noInheritDoc */
interface UserChangePassword200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User change password response
     */
    body: UserChangePassword;
}
/**
 * User create two-factor auth secret request
 */
interface UserCreateTwoFactorAuthSecretRequest {
    secretBase32Encoded: string;
    url: string;
    qrcode: string;
}
/** @noInheritDoc */
interface UserCreateTwoFactorAuthSecret200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User create two-factor auth secret response
     */
    body: UserCreateTwoFactorAuthSecretRequest;
}
/**
 * User enable two-factor auth for logged in user
 */
interface UserEnableTwoFactorAuthForLoggedInUser {
    success: boolean;
}
/** @noInheritDoc */
interface UserEnableTwoFactorAuthForLoggedInUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User enable two-factor auth for logged in user response
     */
    body: UserEnableTwoFactorAuthForLoggedInUser;
}
/**
 * User disable two-factor auth for logged in user
 */
interface UserDisableTwoFactorAuthForLoggedInUser {
    success: boolean;
}
/** @noInheritDoc */
interface UserDisableTwoFactorAuthForLoggedInUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User disable wo-factor auth for logged in user response
     */
    body: UserDisableTwoFactorAuthForLoggedInUser;
}
/**
 * User disable two-factor auth for specified user
 */
interface UserDisableTwoFactorAuthForSpecifiedUser {
    success: boolean;
}
/** @noInheritDoc */
interface UserDisableTwoFactorAuthForSpecifiedUser200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User disable wo-factor auth for specified user response
     */
    body: UserDisableTwoFactorAuthForSpecifiedUser;
}
/**
 * User logout
 */
interface UserLogout {
    success: boolean;
}
/** @noInheritDoc */
interface UserLogout200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User logout response
     */
    body: UserLogout;
}
/**
 * User recovery verification code
 */
interface UserRecoveryVerificationCode {
    success: boolean;
    message: string;
}
/** @noInheritDoc */
interface UserRecoveryVerificationCode200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    /**
     * User recovery verification code
     */
    body: UserRecoveryVerificationCode;
}
interface UserRecoveryVerificationCodeErrorResponse extends HttpErrorResponse {
    status: HttpClientResponseStatusCodes | HttpServerResponseStatusCodes;
    /**
     * User recovery verification code error response
     */
    body: {
        Code: string;
        Message: string;
        remainingLockoutDurationSec: number;
    };
}
interface UserVerifyErrorResponse extends HttpErrorResponse {
    status: HttpClientResponseStatusCodes | HttpServerResponseStatusCodes;
    /**
     * User verify error response
     */
    body: {
        Code: string;
        Message: string;
        remainingLockoutDurationSec: number;
    };
}
interface UserAccountVerificationCodeErrorResponse extends HttpErrorResponse {
    status: HttpClientResponseStatusCodes | HttpServerResponseStatusCodes;
    /**
     * User account verification code error response
     */
    body: {
        Code: string;
        Message: string;
        remainingLockoutDurationSec: number;
    };
}
interface UserResetPassword {
    success: boolean;
}
/** @noInheritDoc */
interface UserResetPassword200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UserResetPassword;
}
interface UserSendReset {
    success: boolean;
}
/** @noInheritDoc */
interface UserSendReset200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UserSendReset;
}
interface UserSignup {
    success: boolean;
}
/** @noInheritDoc */
interface UserSignup200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UserSignup;
}
interface UserRequestLoginCode {
    success: boolean;
}
/** @noInheritDoc */
interface UserRequestLoginCode200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UserRequestLoginCode;
}
interface UserPrescription {
    id: string;
    organizationConfigLinkID: string;
    studyName: string;
    studyID: string;
    creator: {
        firstName: string;
        lastName: string;
    };
    expireAt: string;
    deletedAt: string;
}
/** @noInheritDoc */
interface GetUserPrescription200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UserPrescription[];
}
interface DeletePrescription {
    success: boolean;
}
/** @noInheritDoc */
interface DeletePrescription200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: DeletePrescription;
}
interface CreatePrescription {
    Created: number;
    Updated: number;
    ID: string;
    UserID: string;
    OrganizationConfigLinkID: string;
    ExpireAt: string | null;
    DeletedAt: string | null;
}
/** @noInheritDoc */
interface CreatePrescription200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: CreatePrescription;
}
interface ResendPrescription {
    success: boolean;
}
/** @noInheritDoc */
interface ResendPrescription200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: ResendPrescription;
}
interface UpdatePrescription {
    Created: number;
    Updated: number;
    ID: string;
    UserID: string;
    OrganizationConfigLinkID: string;
    ExpireAt: string | null;
    DeletedAt: string | null;
}
/** @noInheritDoc */
interface UpdatePrescription200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: UpdatePrescription;
}
interface GetMyPrescription {
    id: string;
    organizationConfigLinkID: string;
    studyName: string;
    studyID: string;
    creator: {
        firstName: string;
        lastName: string;
    };
    expireAt: string;
    deletedAt: string;
}
/** @noInheritDoc */
interface GetMyPrescription200Response extends Response {
    status: HttpSuccessfulResponseStatusCodes | HttpRedirectionResponseStatusCodes;
    body: GetMyPrescription[];
}

/**
 * User create request
 */
interface UserCreateRequest {
    FirstName?: string;
    LastName?: string;
    Email?: string;
    Password: string;
    PhoneNumber?: string;
    Gender?: string;
    DateOfBirth?: string;
    HeightCm?: string;
    WeightKg?: string;
}
/**
 * User login request
 */
interface UserLoginRequest {
    Email: string;
    Password: string;
    MFAToken?: string;
    TokenExpiresIn?: string;
}
/**
 * User update request
 */
interface UserUpdateRequest {
    FirstName?: string;
    LastName?: string;
    Email: string;
    Password: string;
    PhoneNumber: string;
    Gender?: string;
    DateOfBirth?: string;
    HeightCm?: string;
    WeightKg?: string;
}
/**
 * User verify request
 */
interface UserVerifyRequest {
    VerificationCode: string;
    ID: string;
}
/**
 * User login with phone code request
 */
interface UserLoginWithPhoneCodeRequest {
    LoginCode: number;
    PhoneNumber: string;
    OrgKey: string;
    TokenExpiresIn?: number;
    RefreshTokenExpiresIn?: number;
}
/**
 * User change password request
 */
interface UserChangePasswordRequest {
    Identifier: string;
    Email: string;
    Password: string;
    NewPassword: string;
}
/**
 * User Enable Two-factor authentication for logged in user request
 */
interface UserTwoFactorAuthForLoggedInUserRequest {
    MFASecret: string;
    MFAToken: number;
}
/**
 * User Reset Password
 */
interface UserResetPasswordRequest {
    ResetToken: string;
    Password: string;
    OTP?: string;
}
interface UserSignupRequest {
    Email: string;
    FirstName: string;
    LastName: string;
    Password: string;
    Industry: string;
    Region: string;
}
interface UpdatePrescriptionRequest {
    organizationConfigLinkID: string;
    expireAt?: string;
}
interface CreatePrescriptionRequest {
    organizationConfigLinkID: string;
    expireAt?: string;
}

/**
 * Users end points
 */
declare class Users extends Main {
    /**
     * Creates a new user in the organization, checking for existing user
     * details against the user list. Email + Password OR PhoneNumber fields
     * are required. If both are provided, Email + Password will be used to
     * create User account. The rest of the fields are optional.
     * Endpoint Action ID = 200
     */
    create(data: UserCreateRequest, tokenType: 'device' | 'user'): Promise<UserCreate200Response | ErrorResponse>;
    /**
     * Logs a user into a new session using Email, Password and optionally an MFAToken and responds with a User Token.
     * The Token must be passed to every subsequent API call to the server.
     *
     * Note: you need to obtain a Device Token first to be able to login through this endpoint.
     *
     * Note: MFAToken token is mandatory when Multi-factor authentication is enabled for this user.
     *
     * Endpoint Action ID = 201
     */
    login(data: UserLoginRequest): Promise<UserLogin200Response | ErrorResponse>;
    /**
     * Retrieves User account information based on the provided User Token.
     *
     * Endpoint Action ID = 202
     */
    retrieve(): Promise<UserAccountInfo200Response | ErrorResponse>;
    /**
     * Removes the entire user account, profiles, and all measurement
     * data associated with it. The account to be deleted is derived
     * from the User Token.
     *
     * Endpoint Action ID = 206
     */
    remove(): Promise<UserRemove200Response | ErrorResponse>;
    /**
     * Updates a user's account information with new details. This
     * endpoint will only update fields supplied to it, hence sending
     * only First Name or Last Name will exclusively update those values.
     *
     * Endpoint Action ID = 208
     */
    update(data: UserUpdateRequest): Promise<UserUpdate200Response | ErrorResponse>;
    /**
     * Password reset, sends email to user
     *
     * Endpoint Action ID = 209
     */
    sendReset(email: string, identifier: string): Promise<UserSendReset200Response | ErrorResponse>;
    /**
     * Resets User's  password
     *
     * Endpoint Action ID = 210
     */
    resetPassword(data: UserResetPasswordRequest): Promise<UserResetPassword200Response | ErrorResponse>;
    /**
     * Retrieves User's Role.
     *
     * Endpoint Action ID = 211
     */
    retrieveUserRole(): Promise<UserRetrieveRole200Response | ErrorResponse>;
    /**
     * Verifies User's email address.
     *
     * Endpoint Action ID = 212
     */
    verifyUserAccount(data: UserVerifyRequest): Promise<UserVerify200Response | UserVerifyErrorResponse | ErrorResponse>;
    /**
     * Sends an account verification code to the user's
     * email address. The code is used to verify the account
     * through the account verification endpoint.
     *
     * Endpoint Action ID = 213
     */
    sendAccountActivationCode(userId: string, orgKey: string): Promise<UserAccountVerificationCode200Response | UserAccountVerificationCodeErrorResponse | ErrorResponse>;
    /**
     * Signup
     *
     * Endpoint Action ID = 215
     */
    signup(data: UserSignupRequest): Promise<UserSignup200Response | ErrorResponse>;
    /**
     * Signup
     * /users/auth/code/:OrgKey/:PhoneNumber
     * Endpoint Action ID = 216
     */
    requestLoginCode(orgKey: string, phoneNumber: string): Promise<UserRequestLoginCode200Response | ErrorResponse>;
    /**
     * Use previously requested 6-digit code to login
     * into a new session and obtain UserToken.
     *
     * Endpoint Action ID = 217
     */
    loginWithPhoneCode(data: UserLoginWithPhoneCodeRequest, enableSession: boolean): Promise<UserLoginWithPhoneCode200Response | ErrorResponse>;
    /**
     * Only DFX_ORG_ADMIN has permission to delete all
     * measurement of specific user for its own organization.
     *
     * Endpoint Action ID = 219
     */
    delete(userId: string): Promise<UserDelete200Response | ErrorResponse>;
    /**
     * This End Point allow user to change password for already verified user.
     *
     * Endpoint Action ID = 220
     */
    changePassword(data: UserChangePasswordRequest): Promise<UserChangePassword200Response | ErrorResponse>;
    /**
     * Creates a base32 secret, url and a QR code (both derived from the secret)
     * that are compatible with Google Authenticator or similar two-factor token
     * generation application. The secret can be used to enable 2FA for given
     * user, and QR code can be used to configure compatible application to
     * generate login tokens for it. This is the first of two API calls needed
     * to configure 2FA for a user.
     *
     * Endpoint Action ID = 221
     */
    createTwoFactorAuthSecret(): Promise<UserCreateTwoFactorAuthSecret200Response | ErrorResponse>;
    /**
     * Enables 2FA for logged in user using an MFASecret (created
     * by /users/mfa/secret endpoint) and MFAToken (derived from
     * MFASecret by scanning a QR code by Google Authenticator or
     * compatible app).
     *
     * This is the second of two API calls needed to configure 2FA for
     * a user.The complete workflow would be as follows:
     * * Logged in user calls /users/mfa/enable and stores
     * `secretBase32Encoded` and `qrcode` properties.
     * * User scans `qrcode` by 2FA token generation app.
     * * User POSTs `secretBase32Encoded` as `MFASecret` and 2FA app
     * temporary token as `MFAToken` to `/users/mfa/enable` endpoint.
     *
     * Endpoint Action ID = 222
     */
    enableTwoFactorAuthForLoggedInUser(data: UserTwoFactorAuthForLoggedInUserRequest): Promise<UserEnableTwoFactorAuthForLoggedInUser200Response | ErrorResponse>;
    /**
     * Disables 2FA for logged in user.
     *
     * Endpoint Action ID = 223
     */
    disableTwoFactorAuthForLoggedInUser(): Promise<UserDisableTwoFactorAuthForLoggedInUser200Response | ErrorResponse>;
    /**
     * Disables 2FA for user by its ID. This is a privileged
     * operation that requires ORG_ADMIN permissions.
     *
     * Endpoint Action ID = 224
     */
    disableTwoFactorAuthForSpecifiedUser(userId: string): Promise<UserDisableTwoFactorAuthForSpecifiedUser200Response | ErrorResponse>;
    /**
     * Logs user out from all its sessions at once.
     *
     * Endpoint Action ID = 226
     */
    logout(): Promise<UserLogout200Response | ErrorResponse>;
    /**
     * Recovery Verification Code
     *
     * Endpoint Action ID = 228
     */
    recoveryVerificationCode(userId: string): Promise<UserRecoveryVerificationCode200Response | UserRecoveryVerificationCodeErrorResponse | ErrorResponse>;
    /**
     * User Prescription
     *
     * Endpoint Action ID = 229
     */
    getUserPrescription(userId: string): Promise<GetUserPrescription200Response | ErrorResponse>;
    /**
     * Delete Prescription
     *
     * Endpoint Action ID = 230
     */
    deletePrescription(id: string): Promise<DeletePrescription200Response | ErrorResponse>;
    /**
     * Create Prescription
     *
     * Endpoint Action ID = 231
     */
    createPrescription(userId: string, data: CreatePrescriptionRequest): Promise<CreatePrescription200Response | ErrorResponse>;
    /**
     * Resend Prescription
     *
     * Endpoint Action ID = 231
     */
    resendPrescription(userId: string): Promise<ResendPrescription200Response | ErrorResponse>;
    /**
     * Update Prescription
     *
     * Endpoint Action ID = 232
     */
    updatePrescription(userId: string, data: UpdatePrescriptionRequest): Promise<UpdatePrescription200Response | ErrorResponse>;
    /**
     * Get My Prescription
     *
     * Endpoint Action ID = 233
     */
    getMyPrescription(): Promise<GetMyPrescription200Response | ErrorResponse>;
}

/**
 * WebSocket transport class
 */
declare class WS {
    #private;
    protected parent: IClient;
    onmessage: WsMsgFunction;
    onclose: WsCloseFunction;
    onerror: WsErrorFunction;
    constructor(parent: IClient);
    /**
     * Opens a socket connection
     */
    connect(token: string): void;
    /**
     * Closes the socket connection
     */
    disconnect(): void;
    protected onSocketOpen(e: Event): void;
    protected onSocketMessage(e: MessageEvent): void;
    /**
     * Sends a message
     *
     * @param actionId End point action ID
     * @param data message body
     * @returns message
     */
    sendMessage(actionId: ActionIdValues, data: any): void;
}

/**
 * HTTP(s) and WebSocket URLs
 */
interface IUrl {
    http: URL;
    wss: URL;
}
type EnumValues<T> = T[keyof T] extends string ? `${T[keyof T]}` : never;
type ActionIdValues = EnumValues<{
    [K in keyof typeof ActionId]: EnumValues<(typeof ActionId)[K]>;
}>;
type WsMsgFunction = (requestId: string, status: string, message: unknown, actionId: ActionIdValues) => void;
type WsCloseFunction = (event: CloseEvent) => void;
type WsErrorFunction = (event: Event) => void;
/**
 * Config
 */
interface IConfig {
    url?: IUrl;
}
/**
 * Session
 */
interface ISession {
    deviceToken?: string;
    deviceRefreshToken?: string;
    userToken?: string;
    userRefreshToken?: string;
    deviceId?: string;
    roleId?: string;
    userId?: string;
    selectedStudy?: string;
    lastMeasurementId?: string;
    studyCfgHash?: string;
    studyCfgData?: string;
}
interface IBaseClient {
    onBeforeRESTCall: () => Promise<void>;
    onAfterRESTCall: (status: string, error: unknown) => Promise<void>;
    http: {
        /**
         * General end points
         */
        general: General;
        /**
         * User end points
         */
        users: Users;
        /**
         * Profiles end points
         */
        profiles: Profiles;
        /**
         * Measurements end points
         */
        measurements: Measurements;
        /**
         * Organization end points
         */
        organizations: Organizations;
        /**
         * Studies end points
         */
        studies: Studies;
        /**
         * Devices end points
         */
        devices: Devices;
        /**
         * Licenses end points
         */
        licenses: Licenses;
        /**
         * Auths end points
         */
        auths: Auths;
        /**
         * Reports end points
         */
        reports: Reports;
        /**
         * Organizations private end points
         */
        organizationsPrivate: OrganizationsPrivate;
        /**
         * Templates end points
         */
        templates: Templates;
    };
    websocket: WS;
}
/**
 * Client
 */
interface IClient extends IBaseClient {
    getSession: () => ISession;
    setSession: (sessionInfo: ISession) => void;
    getUrl: () => string;
    setUrl: (http: string, wss: string) => void;
    version: () => string;
}
/**
 * Four-digit WebSocket Action IDs
 */
declare enum AUTHS {
    SEND_RESET = "2300"
}
declare enum DEVICES {
    TYPES = "0900"
}
declare enum GENERAL {
    STATUS = "0100",
    MIME_TYPES = "0101"
}
declare enum LICENSES {
    CREATE_LICENSE_ALLOWED_STUDY = "1400"
}
declare enum MEASUREMENTS {
    DATA = "0506",
    SUBSCRIBE_RESULTS = "0510"
}
declare enum ORGANIZATIONS {
    RETRIEVE = "0700",
    LOGIN_WITH_TOKEN = "0718"
}
declare enum ORGANIZATIONS_PRIVATE {
    LIST = "1200"
}
declare enum PROFILES {
    CREATE = "0400"
}
declare enum REPORTS {
    REPORT_READY = "1300"
}
declare enum STUDIES {
    TYPES = "0800"
}
declare enum TEMPLATES {
    LIST_TEMPLATES = "1100"
}
declare enum USERS {
    CREATE = "0200"
}
declare const ActionId: {
    AUTHS: typeof AUTHS;
    DEVICES: typeof DEVICES;
    GENERAL: typeof GENERAL;
    LICENSES: typeof LICENSES;
    MEASUREMENTS: typeof MEASUREMENTS;
    ORGANIZATIONS: typeof ORGANIZATIONS;
    ORGANIZATIONS_PRIVATE: typeof ORGANIZATIONS_PRIVATE;
    PROFILES: typeof PROFILES;
    REPORTS: typeof REPORTS;
    STUDIES: typeof STUDIES;
    TEMPLATES: typeof TEMPLATES;
    USERS: typeof USERS;
};
/**
 * Enum for Device Type IDs
 * @readonly
 * @enum {string}
 */
declare enum DeviceTypeID {
    IPHONE = "IPHONE",
    IPAD = "IPAD",
    DARWIN = "DARWIN",
    ANDROID_PHONE = "ANDROID_PHONE",
    WINDOWS = "WINDOWS",
    WIN32 = "WIN32",
    WINDOWS_TABLET = "WINDOWS_TABLET",
    LINUX = "LINUX",
    DEBIAN = "DEBIAN"
}

/**
 * Example usage:
 *
 * ```js
 * import client from '@nuralogix.ai/dfx-api-client';
 *
 * const apiClient = client();
 * // or
 * const api = 'api.deepaffex.ai';
 *
 * const apiClient = client({
     url: {
         http: new URL(`https://${api}`),
         wss: new URL(`wss://${api}`)
     },
     onBeforeRESTCall: async () => {},
     onAfterRESTCall: async (status: string, error: unknown) => {},
   });
 *
 * // You can also use the `new` keyword when initializing the client
 * const apiClient = new client();
 *
 * apiClient.websocket.onmessage = (requestId: string, status: string, message: any, actionId: ActionIdValues) => {
     console.log(requestId, status, message, messageType);
   }
 *
 * apiClient.websocket.onclose = (e: CloseEvent) => {
     console.log('connection closed!', e.code, e.reason, e.wasClean);
   }
 *
 * apiClient.websocket.onerror = (e: Event) => {
     console.log('error', e);
   }
 * ```
 *
 * @param {Object} [config] An optional config parameter.
 */
declare const client: (config?: IConfig) => IClient;

declare const enums: {
    ActionId: {
        AUTHS: typeof AUTHS;
        DEVICES: typeof DEVICES;
        GENERAL: typeof GENERAL;
        LICENSES: typeof LICENSES;
        MEASUREMENTS: typeof MEASUREMENTS;
        ORGANIZATIONS: typeof ORGANIZATIONS;
        ORGANIZATIONS_PRIVATE: typeof ORGANIZATIONS_PRIVATE;
        PROFILES: typeof PROFILES;
        REPORTS: typeof REPORTS;
        STUDIES: typeof STUDIES;
        TEMPLATES: typeof TEMPLATES;
        USERS: typeof USERS;
    };
    DeviceTypeID: typeof DeviceTypeID;
};

export { type ActionIdValues, client as default, enums };