evernote.d.ts

// Type definitions for evernote v 1.25.8
// Project: https://www.npmjs.com/package/evernote
// Definitions by: Zachary Collins <https://github.com/corps/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped

/// <reference path="../thrift/thrift.d.ts"/>

declare module "evernote" {
    import { Thrift } from "thrift";

    module Evernote {
        interface Callback<T> {
            (err: EDAMUserException|EDAMSystemException|EDAMNotFoundException, v: T): void
        }

        interface ClientConfig {
            consumerKey?: string
            consumerSecret?: string
            sandbox?: boolean
            token?: string
            serviceHost?: string
            additionalHeaders?: { [k: string]: string }
            secret?: string
        }

        class Client {
            static "new": (config: ClientConfig) => Client
            constructor(config: ClientConfig);
            getNoteStore(): NoteStoreClient;
            getUserStore(): UserStoreClient;
        }


        /**
         * Numeric codes indicating the type of error that occurred on the
         * service.
         * <dl>
         *     <dt>UNKNOWN</dt>
         *         <dd>No information available about the error</dd>
         *     <dt>BAD_DATA_FORMAT</dt>
         *         <dd>The format of the request data was incorrect</dd>
         *     <dt>PERMISSION_DENIED</dt>
         *         <dd>Not permitted to perform action</dd>
         *     <dt>INTERNAL_ERROR</dt>
         *         <dd>Unexpected problem with the service</dd>
         *     <dt>DATA_REQUIRED</dt>
         *         <dd>A required parameter/field was absent</dd>
         *     <dt>LIMIT_REACHED</dt>
         *         <dd>Operation denied due to data model limit</dd>
         *     <dt>QUOTA_REACHED</dt>
         *         <dd>Operation denied due to user storage limit</dd>
         *     <dt>INVALID_AUTH</dt>
         *         <dd>Username and/or password incorrect</dd>
         *     <dt>AUTH_EXPIRED</dt>
         *         <dd>Authentication token expired</dd>
         *     <dt>DATA_CONFLICT</dt>
         *         <dd>Change denied due to data model conflict</dd>
         *     <dt>ENML_VALIDATION</dt>
         *         <dd>Content of submitted note was malformed</dd>
         *     <dt>SHARD_UNAVAILABLE</dt>
         *         <dd>Service shard with account data is temporarily down</dd>
         *     <dt>LEN_TOO_SHORT</dt>
         *         <dd>Operation denied due to data model limit, where something such
         *                 as a string length was too short</dd>
         *     <dt>LEN_TOO_LONG</dt>
         *         <dd>Operation denied due to data model limit, where something such
         *                 as a string length was too long</dd>
         *     <dt>TOO_FEW</dt>
         *         <dd>Operation denied due to data model limit, where there were
         *                 too few of something.</dd>
         *     <dt>TOO_MANY</dt>
         *         <dd>Operation denied due to data model limit, where there were
         *                 too many of something.</dd>
         *     <dt>UNSUPPORTED_OPERATION</dt>
         *         <dd>Operation denied because it is currently unsupported.</dd>
         *     <dt>TAKEN_DOWN</dt>
         *         <dd>Operation denied because access to the corresponding object is
         *                 prohibited in response to a take-down notice.</dd>
         *     <dt>RATE_LIMIT_REACHED</dt>
         *         <dd>Operation denied because the calling application has reached
         *                 its hourly API call limit for this user.</dd>
         * </dl>
         */
        enum EDAMErrorCode {
            'UNKNOWN' = 1,
            'BAD_DATA_FORMAT' = 2,
            'PERMISSION_DENIED' = 3,
            'INTERNAL_ERROR' = 4,
            'DATA_REQUIRED' = 5,
            'LIMIT_REACHED' = 6,
            'QUOTA_REACHED' = 7,
            'INVALID_AUTH' = 8,
            'AUTH_EXPIRED' = 9,
            'DATA_CONFLICT' = 10,
            'ENML_VALIDATION' = 11,
            'SHARD_UNAVAILABLE' = 12,
            'LEN_TOO_SHORT' = 13,
            'LEN_TOO_LONG' = 14,
            'TOO_FEW' = 15,
            'TOO_MANY' = 16,
            'UNSUPPORTED_OPERATION' = 17,
            'TAKEN_DOWN' = 18,
            'RATE_LIMIT_REACHED' = 19,
        }

        /**
         * This exception is thrown by EDAM procedures when a call fails as a result of
         * a problem that a caller may be able to resolve.    For example, if the user
         * attempts to add a note to their account which would exceed their storage
         * quota, this type of exception may be thrown to indicate the source of the
         * error so that they can choose an alternate action.
         *
         * This exception would not be used for internal system errors that do not
         * reflect user actions, but rather reflect a problem within the service that
         * the user cannot resolve.
         *
         * errorCode:    The numeric code indicating the type of error that occurred.
         *     must be one of the values of EDAMErrorCode.
         *
         * parameter:    If the error applied to a particular input parameter, this will
         *     indicate which parameter.
         */
        class EDAMUserException extends Thrift.TException {
            errorCode: EDAMErrorCode;
            parameter: string;

            constructor(args?: { errorCode: EDAMErrorCode; parameter?: string; });
        }

        /**
         * This exception is thrown by EDAM procedures when a call fails as a result of
         * a problem in the service that could not be changed through caller action.
         *
         * errorCode:    The numeric code indicating the type of error that occurred.
         *     must be one of the values of EDAMErrorCode.
         *
         * message:    This may contain additional information about the error
         *
         * rateLimitDuration:    Indicates the minimum number of seconds that an application should
         *     expect subsequent API calls for this user to fail. The application should not retry
         *     API requests for the user until at least this many seconds have passed. Present only
         *     when errorCode is RATE_LIMIT_REACHED,
         */
        class EDAMSystemException extends Thrift.TException {
            errorCode: EDAMErrorCode;
            message: string;
            rateLimitDuration: number;

            constructor(args?: { errorCode: EDAMErrorCode; message?: string; rateLimitDuration?: number; });
        }

        /**
         * This exception is thrown by EDAM procedures when a caller asks to perform
         * an operation on an object that does not exist.    This may be thrown based on an invalid
         * primary identifier (e.g. a bad GUID), or when the caller refers to an object
         * by another unique identifier (e.g. a User's email address).
         *
         * identifier:    A description of the object that was not found on the server.
         *     For example, "Note.notebookGuid" when a caller attempts to create a note in a
         *     notebook that does not exist in the user's account.
         *
         * key:    The value passed from the client in the identifier, which was not
         *     found. For example, the GUID that was not found.
         */
        class EDAMNotFoundException extends Thrift.TException {
            identifier: string;
            key: string;

            constructor(args?: { identifier?: string; key?: string; });
        }
        /**
         * Minimum length of any string-based attribute, in Unicode chars
         */
        var EDAM_ATTRIBUTE_LEN_MIN: number;

        /**
         * Maximum length of any string-based attribute, in Unicode chars
         */
        var EDAM_ATTRIBUTE_LEN_MAX: number;

        /**
         * Any string-based attribute must match the provided regular expression.
         * This excludes all Unicode line endings and control characters.
         */
        var EDAM_ATTRIBUTE_REGEX: string;

        /**
         * The maximum number of values that can be stored in a list-based attribute
         * (e.g. see UserAttributes.recentMailedAddresses)
         */
        var EDAM_ATTRIBUTE_LIST_MAX: number;

        /**
         * The maximum number of entries that can be stored in a map-based attribute
         * such as applicationData fields in Resources and Notes.
         */
        var EDAM_ATTRIBUTE_MAP_MAX: number;

        /**
         * The minimum length of a GUID generated by the Evernote service
         */
        var EDAM_GUID_LEN_MIN: number;

        /**
         * The maximum length of a GUID generated by the Evernote service
         */
        var EDAM_GUID_LEN_MAX: number;

        /**
         * GUIDs generated by the Evernote service will match the provided pattern
         */
        var EDAM_GUID_REGEX: string;

        /**
         * The minimum length of any email address
         */
        var EDAM_EMAIL_LEN_MIN: number;

        /**
         * The maximum length of any email address
         */
        var EDAM_EMAIL_LEN_MAX: number;

        /**
         * A regular expression that matches the part of an email address before
         * the '@' symbol.
         */
        var EDAM_EMAIL_LOCAL_REGEX: string;

        /**
         * A regular expression that matches the part of an email address after
         * the '@' symbol.
         */
        var EDAM_EMAIL_DOMAIN_REGEX: string;

        /**
         * A regular expression that must match any email address given to Evernote.
         * Email addresses must comply with RFC 2821 and 2822.
         */
        var EDAM_EMAIL_REGEX: string;

        /**
         * A regular expression that must match any VAT ID given to Evernote.
         * ref http://en.wikipedia.org/wiki/VAT_identification_number
         * ref http://my.safaribooksonline.com/book/programming/regular-expressions/9780596802837/4dot-validation-and-formatting/id2995136
         */
        var EDAM_VAT_REGEX: string;

        /**
         * The minimum length of a timezone specification string
         */
        var EDAM_TIMEZONE_LEN_MIN: number;

        /**
         * The maximum length of a timezone specification string
         */
        var EDAM_TIMEZONE_LEN_MAX: number;

        /**
         * Any timezone string given to Evernote must match the provided pattern.
         * This permits either a locale-based standard timezone or a GMT offset.
         * E.g.:<ul>
         *        <li>America/Los_Angeles</li>
         *        <li>GMT+08:00</li>
         * </ul>
         */
        var EDAM_TIMEZONE_REGEX: string;

        /**
         * The minimum length of any MIME type string given to Evernote
         */
        var EDAM_MIME_LEN_MIN: number;

        /**
         * The maximum length of any MIME type string given to Evernote
         */
        var EDAM_MIME_LEN_MAX: number;

        /**
         * Any MIME type string given to Evernote must match the provided pattern.
         * E.g.:    image/gif
         */
        var EDAM_MIME_REGEX: string;

        /**
         * Canonical MIME type string for GIF image resources
         */
        var EDAM_MIME_TYPE_GIF: string;

        /**
         * Canonical MIME type string for JPEG image resources
         */
        var EDAM_MIME_TYPE_JPEG: string;

        /**
         * Canonical MIME type string for PNG image resources
         */
        var EDAM_MIME_TYPE_PNG: string;

        /**
         * Canonical MIME type string for WAV audio resources
         */
        var EDAM_MIME_TYPE_WAV: string;

        /**
         * Canonical MIME type string for MP3 audio resources
         */
        var EDAM_MIME_TYPE_MP3: string;

        /**
         * Canonical MIME type string for AMR audio resources
         */
        var EDAM_MIME_TYPE_AMR: string;

        /**
         * Canonical MIME type string for AAC audio resources
         */
        var EDAM_MIME_TYPE_AAC: string;

        /**
         * Canonical MIME type string for MP4 audio resources
         */
        var EDAM_MIME_TYPE_M4A: string;

        /**
         * Canonical MIME type string for MP4 video resources
         */
        var EDAM_MIME_TYPE_MP4_VIDEO: string;

        /**
         * Canonical MIME type string for Evernote Ink resources
         */
        var EDAM_MIME_TYPE_INK: string;

        /**
         * Canonical MIME type string for PDF resources
         */
        var EDAM_MIME_TYPE_PDF: string;

        /**
         * MIME type used for attachments of an unspecified type
         */
        var EDAM_MIME_TYPE_DEFAULT: string;

        /**
         * The set of resource MIME types that are expected to be handled
         * correctly by all of the major Evernote client applications.
         */
        var EDAM_MIME_TYPES: string[];

        /**
         * The set of MIME types that Evernote will parse and index for
         * searching. With exception of images, and PDFs, which are
         * handled in a different way.
         */
        var EDAM_INDEXABLE_RESOURCE_MIME_TYPES: string[];

        /**
         * The minimum length of a user search query string in Unicode chars
         */
        var EDAM_SEARCH_QUERY_LEN_MIN: number;

        /**
         * The maximum length of a user search query string in Unicode chars
         */
        var EDAM_SEARCH_QUERY_LEN_MAX: number;

        /**
         * Search queries must match the provided pattern.    This is used for
         * both ad-hoc queries and SavedSearch.query fields.
         * This excludes all control characters and line/paragraph separators.
         */
        var EDAM_SEARCH_QUERY_REGEX: string;

        /**
         * The exact length of a MD5 hash checksum, in binary bytes.
         * This is the exact length that must be matched for any binary hash
         * value.
         */
        var EDAM_HASH_LEN: number;

        /**
         * The minimum length of an Evernote username
         */
        var EDAM_USER_USERNAME_LEN_MIN: number;

        /**
         * The maximum length of an Evernote username
         */
        var EDAM_USER_USERNAME_LEN_MAX: number;

        /**
         * Any Evernote User.username field must match this pattern.    This
         * restricts usernames to a format that could permit use as a domain
         * name component.    E.g. "username.whatever.evernote.com"
         */
        var EDAM_USER_USERNAME_REGEX: string;

        /**
         * Minimum length of the User.name field
         */
        var EDAM_USER_NAME_LEN_MIN: number;

        /**
         * Maximum length of the User.name field
         */
        var EDAM_USER_NAME_LEN_MAX: number;

        /**
         * The User.name field must match this pattern, which excludes line
         * endings and control characters.
         */
        var EDAM_USER_NAME_REGEX: string;

        /**
         * The minimum length of a Tag.name, in Unicode characters
         */
        var EDAM_TAG_NAME_LEN_MIN: number;

        /**
         * The maximum length of a Tag.name, in Unicode characters
         */
        var EDAM_TAG_NAME_LEN_MAX: number;

        /**
         * All Tag.name fields must match this pattern.
         * This excludes control chars, commas or line/paragraph separators.
         * The string may not begin or end with whitespace.
         */
        var EDAM_TAG_NAME_REGEX: string;

        /**
         * The minimum length of a Note.title, in Unicode characters
         */
        var EDAM_NOTE_TITLE_LEN_MIN: number;

        /**
         * The maximum length of a Note.title, in Unicode characters
         */
        var EDAM_NOTE_TITLE_LEN_MAX: number;

        /**
         * All Note.title fields must match this pattern.
         * This excludes control chars or line/paragraph separators.
         * The string may not begin or end with whitespace.
         */
        var EDAM_NOTE_TITLE_REGEX: string;

        /**
         * Minimum length of a Note.content field.
         * Note.content fields must comply with the ENML DTD.
         */
        var EDAM_NOTE_CONTENT_LEN_MIN: number;

        /**
         * Maximum length of a Note.content field
         * Note.content fields must comply with the ENML DTD.
         */
        var EDAM_NOTE_CONTENT_LEN_MAX: number;

        /**
         * Minimum length of an application name, which is the key in an
         * applicationData LazyMap found in entities such as Resources and
         * Notes.
         */
        var EDAM_APPLICATIONDATA_NAME_LEN_MIN: number;

        /**
         * Maximum length of an application name, which is the key in an
         * applicationData LazyMap found in entities such as Resources and
         * Notes.
         */
        var EDAM_APPLICATIONDATA_NAME_LEN_MAX: number;

        /**
         * Minimum length of an applicationData value in a LazyMap, found
         * in entities such as Resources and Notes.
         */
        var EDAM_APPLICATIONDATA_VALUE_LEN_MIN: number;

        /**
         * Maximum length of an applicationData value in a LazyMap, found
         * in entities such as Resources and Notes.    Note, however, that
         * the sum of the size of hte key and value is constrained by
         * EDAM_APPLICATIONDATA_ENTRY_LEN_MAX, so the maximum length, in
         * practice, depends upon the key value being used.
         */
        var EDAM_APPLICATIONDATA_VALUE_LEN_MAX: number;

        /**
         * The total length of an entry in an applicationData LazyMap, which
         * is the sum of the length of the key and the value for the entry.
         */
        var EDAM_APPLICATIONDATA_ENTRY_LEN_MAX: number;

        /**
         * An application name must match this regex.    An application
         * name is the key portion of an entry in an applicationData
         * map as found in entities such as Resources and Notes.
         * Note that even if both the name and value regexes match,
         * it is still necessary to check the sum of the lengths
         * against EDAM_APPLICATIONDATA_ENTRY_LEN_MAX.
         */
        var EDAM_APPLICATIONDATA_NAME_REGEX: string;

        /**
         * An applicationData map value must match this regex.
         * Note that even if both the name and value regexes match,
         * it is still necessary to check the sum of the lengths
         * against EDAM_APPLICATIONDATA_ENTRY_LEN_MAX.
         */
        var EDAM_APPLICATIONDATA_VALUE_REGEX: string;

        /**
         * The minimum length of a Notebook.name, in Unicode characters
         */
        var EDAM_NOTEBOOK_NAME_LEN_MIN: number;

        /**
         * The maximum length of a Notebook.name, in Unicode characters
         */
        var EDAM_NOTEBOOK_NAME_LEN_MAX: number;

        /**
         * All Notebook.name fields must match this pattern.
         * This excludes control chars or line/paragraph separators.
         * The string may not begin or end with whitespace.
         */
        var EDAM_NOTEBOOK_NAME_REGEX: string;

        /**
         * The minimum length of a Notebook.stack, in Unicode characters
         */
        var EDAM_NOTEBOOK_STACK_LEN_MIN: number;

        /**
         * The maximum length of a Notebook.stack, in Unicode characters
         */
        var EDAM_NOTEBOOK_STACK_LEN_MAX: number;

        /**
         * All Notebook.stack fields must match this pattern.
         * This excludes control chars or line/paragraph separators.
         * The string may not begin or end with whitespace.
         */
        var EDAM_NOTEBOOK_STACK_REGEX: string;

        /**
         * The minimum length of a public notebook URI component
         */
        var EDAM_PUBLISHING_URI_LEN_MIN: number;

        /**
         * The maximum length of a public notebook URI component
         */
        var EDAM_PUBLISHING_URI_LEN_MAX: number;

        /**
         * A public notebook URI component must match the provided pattern
         */
        var EDAM_PUBLISHING_URI_REGEX: string;

        /**
         * The set of strings that may not be used as a publishing URI
         */
        var EDAM_PUBLISHING_URI_PROHIBITED: string[];

        /**
         * The minimum length of a Publishing.publicDescription field.
         */
        var EDAM_PUBLISHING_DESCRIPTION_LEN_MIN: number;

        /**
         * The maximum length of a Publishing.publicDescription field.
         */
        var EDAM_PUBLISHING_DESCRIPTION_LEN_MAX: number;

        /**
         * Any public notebook's Publishing.publicDescription field must match
         * this pattern.
         * No control chars or line/paragraph separators, and can't start or
         * end with whitespace.
         */
        var EDAM_PUBLISHING_DESCRIPTION_REGEX: string;

        /**
         * The minimum length of a SavedSearch.name field
         */
        var EDAM_SAVED_SEARCH_NAME_LEN_MIN: number;

        /**
         * The maximum length of a SavedSearch.name field
         */
        var EDAM_SAVED_SEARCH_NAME_LEN_MAX: number;

        /**
         * SavedSearch.name fields must match this pattern.
         * No control chars or line/paragraph separators, and can't start or
         * end with whitespace.
         */
        var EDAM_SAVED_SEARCH_NAME_REGEX: string;

        /**
         * The minimum length of an Evernote user password
         */
        var EDAM_USER_PASSWORD_LEN_MIN: number;

        /**
         * The maximum length of an Evernote user password
         */
        var EDAM_USER_PASSWORD_LEN_MAX: number;

        /**
         * Evernote user passwords must match this regular expression
         */
        var EDAM_USER_PASSWORD_REGEX: string;

        /**
         * The maximum length of an Evernote Business URI
         */
        var EDAM_BUSINESS_URI_LEN_MAX: number;

        /**
         * The maximum number of Tags per Note
         */
        var EDAM_NOTE_TAGS_MAX: number;

        /**
         * The maximum number of Resources per Note
         */
        var EDAM_NOTE_RESOURCES_MAX: number;

        /**
         * Maximum number of Tags per account
         */
        var EDAM_USER_TAGS_MAX: number;

        /**
         * Maximum number of Tags per business account.
         */
        var EDAM_BUSINESS_TAGS_MAX: number;

        /**
         * Maximum number of SavedSearches per account
         */
        var EDAM_USER_SAVED_SEARCHES_MAX: number;

        /**
         * Maximum number of Notes per user
         */
        var EDAM_USER_NOTES_MAX: number;

        /**
         * Maximum number of Notes per business account
         */
        var EDAM_BUSINESS_NOTES_MAX: number;

        /**
         * Maximum number of Notebooks per user
         */
        var EDAM_USER_NOTEBOOKS_MAX: number;

        /**
         * Maximum number of Notebooks in a business account
         */
        var EDAM_BUSINESS_NOTEBOOKS_MAX: number;

        /**
         * Maximum number of recent email addresses that are maintained
         * (see UserAttributes.recentMailedAddresses)
         */
        var EDAM_USER_RECENT_MAILED_ADDRESSES_MAX: number;

        /**
         * The number of emails of any type that can be sent by a user with a Free
         * account from the service per day.    If an email is sent to two different
         * recipients, this counts as two emails.
         */
        var EDAM_USER_MAIL_LIMIT_DAILY_FREE: number;

        /**
         * The number of emails of any type that can be sent by a user with a Premium
         * account from the service per day.    If an email is sent to two different
         * recipients, this counts as two emails.
         */
        var EDAM_USER_MAIL_LIMIT_DAILY_PREMIUM: number;

        /**
         * The number of bytes of new data that may be uploaded to a Free user's
         * account each month.
         */
        var EDAM_USER_UPLOAD_LIMIT_FREE: number;

        /**
         * The number of bytes of new data that may be uploaded to a Premium user's
         * account each month.
         */
        var EDAM_USER_UPLOAD_LIMIT_PREMIUM: number;

        /**
         * The number of bytes of new data that may be uploaded to a Business user's
         * personal account each month. Note that content uploaded into the Business
         * notebooks by the user does not count against this limit.
         */
        var EDAM_USER_UPLOAD_LIMIT_BUSINESS: number;

        /**
         * Maximum total size of a Note that can be added to a Free account.
         * The size of a note is calculated as:
         * ENML content length (in Unicode characters) plus the sum of all resource
         * sizes (in bytes).
         */
        var EDAM_NOTE_SIZE_MAX_FREE: number;

        /**
         * Maximum total size of a Note that can be added to a Premium account.
         * The size of a note is calculated as:
         * ENML content length (in Unicode characters) plus the sum of all resource
         * sizes (in bytes).
         */
        var EDAM_NOTE_SIZE_MAX_PREMIUM: number;

        /**
         * Maximum size of a resource, in bytes, for Free accounts
         */
        var EDAM_RESOURCE_SIZE_MAX_FREE: number;

        /**
         * Maximum size of a resource, in bytes, for Premium accounts
         */
        var EDAM_RESOURCE_SIZE_MAX_PREMIUM: number;

        /**
         * Maximum number of linked notebooks per account, for a free
         * account.
         */
        var EDAM_USER_LINKED_NOTEBOOK_MAX: number;

        /**
         * Maximum number of linked notebooks per account, for a premium
         * account.    Users who are part of an active business are also
         * covered under "premium".
         */
        var EDAM_USER_LINKED_NOTEBOOK_MAX_PREMIUM: number;

        /**
         * Maximum number of shared notebooks per notebook
         */
        var EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX: number;

        /**
         * The minimum length of the content class attribute of a note.
         */
        var EDAM_NOTE_CONTENT_CLASS_LEN_MIN: number;

        /**
         * The maximum length of the content class attribute of a note.
         */
        var EDAM_NOTE_CONTENT_CLASS_LEN_MAX: number;

        /**
         * The regular expression that the content class of a note must match
         * to be valid.
         */
        var EDAM_NOTE_CONTENT_CLASS_REGEX: string;

        /**
         * The content class prefix used for all notes created by Evernote Hello.
         * This prefix can be used to assemble individual content class strings,
         * or can be used to create a wildcard search to get all notes created by
         * Hello. When performing a wildcard search via filtered sync chunks or
         * search strings, the * character must be appended to this constant.
         */
        var EDAM_HELLO_APP_CONTENT_CLASS_PREFIX: string;

        /**
         * The content class prefix used for all notes created by Evernote Food.
         * This prefix can be used to assemble individual content class strings,
         * or can be used to create a wildcard search to get all notes created by
         * Food. When performing a wildcard search via filtered sync chunks or
         * search strings, the * character must be appended to this constant.
         */
        var EDAM_FOOD_APP_CONTENT_CLASS_PREFIX: string;

        /**
         * The content class prefix used for structured notes created by Evernote
         * Hello that represents an encounter with a person. When performing a
         * wildcard search via filtered sync chunks or search strings, the *
         * character must be appended to this constant.
         */
        var EDAM_CONTENT_CLASS_HELLO_ENCOUNTER: string;

        /**
         * The content class prefix used for structured notes created by Evernote
         * Hello that represents the user's profile. When performing a
         * wildcard search via filtered sync chunks or search strings, the *
         * character must be appended to this constant.
         */
        var EDAM_CONTENT_CLASS_HELLO_PROFILE: string;

        /**
         * The content class prefix used for structured notes created by
         * Evernote Food that captures the experience of a particular meal.
         * When performing a wildcard search via filtered sync chunks or search
         * strings, the * character must be appended to this constant.
         */
        var EDAM_CONTENT_CLASS_FOOD_MEAL: string;

        /**
         * The content class prefix used for structured notes created by Evernote
         * Skitch. When performing a wildcard search via filtered sync chunks
         * or search strings, the * character must be appended to this constant.
         */
        var EDAM_CONTENT_CLASS_SKITCH_PREFIX: string;

        /**
         * The content class value used for structured image notes created by Evernote
         * Skitch.
         */
        var EDAM_CONTENT_CLASS_SKITCH: string;

        /**
         * The content class value used for structured PDF notes created by Evernote
         * Skitch.
         */
        var EDAM_CONTENT_CLASS_SKITCH_PDF: string;

        /**
         * The content class prefix used for structured notes created by Evernote
         * Penultimate. When performing a wildcard search via filtered sync chunks
         * or search strings, the * character must be appended to this constant.
         */
        var EDAM_CONTENT_CLASS_PENULTIMATE_PREFIX: string;

        /**
         * The content class value used for structured notes created by Evernote
         * Penultimate that represents a Penultimate notebook.
         */
        var EDAM_CONTENT_CLASS_PENULTIMATE_NOTEBOOK: string;

        /**
         * The minimum length of the plain text in a findRelated query, assuming that
         * plaintext is being provided.
         */
        var EDAM_RELATED_PLAINTEXT_LEN_MIN: number;

        /**
         * The maximum length of the plain text in a findRelated query, assuming that
         * plaintext is being provided.
         */
        var EDAM_RELATED_PLAINTEXT_LEN_MAX: number;

        /**
         * The maximum number of notes that will be returned from a findRelated()
         * query.
         */
        var EDAM_RELATED_MAX_NOTES: number;

        /**
         * The maximum number of notebooks that will be returned from a findRelated()
         * query.
         */
        var EDAM_RELATED_MAX_NOTEBOOKS: number;

        /**
         * The maximum number of tags that will be returned from a findRelated() query.
         */
        var EDAM_RELATED_MAX_TAGS: number;

        /**
         * The minimum length, in Unicode characters, of a description for a business
         * notebook.
         */
        var EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MIN: number;

        /**
         * The maximum length, in Unicode characters, of a description for a business
         * notebook.
         */
        var EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MAX: number;

        /**
         * All business notebook descriptions must match this pattern.
         * This excludes control chars or line/paragraph separators.
         * The string may not begin or end with whitespace.
         */
        var EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_REGEX: string;

        /**
         * The maximum length of a business phone number.
         */
        var EDAM_BUSINESS_PHONE_NUMBER_LEN_MAX: number;

        /**
         * Minimum length of a preference name
         */
        var EDAM_PREFERENCE_NAME_LEN_MIN: number;

        /**
         * Maximum length of a preference name
         */
        var EDAM_PREFERENCE_NAME_LEN_MAX: number;

        /**
         * Minimum length of a preference value
         */
        var EDAM_PREFERENCE_VALUE_LEN_MIN: number;

        /**
         * Maximum length of a preference value
         */
        var EDAM_PREFERENCE_VALUE_LEN_MAX: number;

        /**
         * Maximum number of name/value pairs allowed
         */
        var EDAM_MAX_PREFERENCES: number;

        /**
         * Maximum number of values per preference name
         */
        var EDAM_MAX_VALUES_PER_PREFERENCE: number;

        /**
         * A preference name must match this regex.
         */
        var EDAM_PREFERENCE_NAME_REGEX: string;

        /**
         * A preference value must match this regex.
         */
        var EDAM_PREFERENCE_VALUE_REGEX: string;

        /**
         * The name of the preferences entry that contains shortcuts.
         */
        var EDAM_PREFERENCE_SHORTCUTS: string;

        /**
         * The maximum number of shortcuts that a user may have.
         */
        var EDAM_PREFERENCE_SHORTCUTS_MAX_VALUES: number;

        /**
         * Maximum length of the device identifier string associated with long sessions.
         */
        var EDAM_DEVICE_ID_LEN_MAX: number;

        /**
         * Regular expression for device identifier strings associated with long sessions.
         */
        var EDAM_DEVICE_ID_REGEX: string;

        /**
         * Maximum length of the device description string associated with long sessions.
         */
        var EDAM_DEVICE_DESCRIPTION_LEN_MAX: number;

        /**
         * Regular expression for device description strings associated with long sessions.
         */
        var EDAM_DEVICE_DESCRIPTION_REGEX: string;

        /**
         * Maximum number of search suggestions that can be returned
         */
        var EDAM_SEARCH_SUGGESTIONS_MAX: number;

        /**
         * Maximum length of the search suggestion prefix
         */
        var EDAM_SEARCH_SUGGESTIONS_PREFIX_LEN_MAX: number;

        /**
         * Minimum length of the search suggestion prefix
         */
        var EDAM_SEARCH_SUGGESTIONS_PREFIX_LEN_MIN: number;
        class NoteStoreClient {
            seqid: number;

            /**
             * Asks the NoteStore to provide information about the status of the user
             * account corresponding to the provided authentication token.
             */
            getSyncState(cb: Callback<SyncState>): void;

            /**
             * Asks the NoteStore to provide information about the status of the user
             * account corresponding to the provided authentication token.
             * This version of 'getSyncState' allows the client to upload coarse-
             * grained usage metrics to the service.
             *
             * @param clientMetrics    see the documentation of the ClientUsageMetrics
             *     structure for an explanation of the fields that clients can pass to
             *     the service.
             */
            getSyncStateWithMetrics(clientMetrics: ClientUsageMetrics, cb: Callback<SyncState>): void;

            /**
             * Asks the NoteStore to provide the state of the account in order of
             * last modification.    This request retrieves one block of the server's
             * state so that a client can make several small requests against a large
             * account rather than getting the entire state in one big message.
             * This call gives fine-grained control of the data that will
             * be received by a client by omitting data elements that a client doesn't
             * need. This may reduce network traffic and sync times.
             *
             * @param afterUSN
             *     The client can pass this value to ask only for objects that
             *     have been updated after a certain point.    This allows the client to
             *     receive updates after its last checkpoint rather than doing a full
             *     synchronization on every pass.    The default value of "0" indicates
             *     that the client wants to get objects from the start of the account.
             *
             * @param maxEntries
             *     The maximum number of modified objects that should be
             *     returned in the result SyncChunk.    This can be used to limit the size
             *     of each individual message to be friendly for network transfer.
             *
             * @param filter
             *     The caller must set some of the flags in this structure to specify which
             *     data types should be returned during the synchronization.    See
             *     the SyncChunkFilter structure for information on each flag.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "afterUSN" - if negative
             *     </li>
             *     <li> BAD_DATA_FORMAT "maxEntries" - if less than 1
             *     </li>
             * </ul>
             */
            getFilteredSyncChunk(afterUSN: number, maxEntries: number, filter: SyncChunkFilter, cb: Callback<SyncState>): void;

            /**
             * Asks the NoteStore to provide information about the status of a linked
             * notebook that has been shared with the caller, or that is public to the
             * world.
             * This will return a result that is similar to getSyncState, but may omit
             * SyncState.uploaded if the caller doesn't have permission to write to
             * the linked notebook.
             *
             * This function must be called on the shard that owns the referenced
             * notebook.    (I.e. the shardId in /shard/shardId/edam/note must be the
             * same as LinkedNotebook.shardId.)
             *
             * @param authenticationToken
             *     This should be an authenticationToken for the guest who has received
             *     the invitation to the share.    (I.e. this should not be the result of
             *     NoteStore.authenticateToSharedNotebook)
             *
             * @param linkedNotebook
             *     This structure should contain identifying information and permissions
             *     to access the notebook in question.
             */
            getLinkedNotebookSyncState(linkedNotebook: LinkedNotebook, cb: Callback<SyncState>): void;

            /**
             * Asks the NoteStore to provide information about the contents of a linked
             * notebook that has been shared with the caller, or that is public to the
             * world.
             * This will return a result that is similar to getSyncChunk, but will only
             * contain entries that are visible to the caller.    I.e. only that particular
             * Notebook will be visible, along with its Notes, and Tags on those Notes.
             *
             * This function must be called on the shard that owns the referenced
             * notebook.    (I.e. the shardId in /shard/shardId/edam/note must be the
             * same as LinkedNotebook.shardId.)
             *
             * @param authenticationToken
             *     This should be an authenticationToken for the guest who has received
             *     the invitation to the share.    (I.e. this should not be the result of
             *     NoteStore.authenticateToSharedNotebook)
             *
             * @param linkedNotebook
             *     This structure should contain identifying information and permissions
             *     to access the notebook in question.    This must contain the valid fields
             *     for either a shared notebook (e.g. shareKey)
             *     or a public notebook (e.g. username, uri)
             *
             * @param afterUSN
             *     The client can pass this value to ask only for objects that
             *     have been updated after a certain point.    This allows the client to
             *     receive updates after its last checkpoint rather than doing a full
             *     synchronization on every pass.    The default value of "0" indicates
             *     that the client wants to get objects from the start of the account.
             *
             * @param maxEntries
             *     The maximum number of modified objects that should be
             *     returned in the result SyncChunk.    This can be used to limit the size
             *     of each individual message to be friendly for network transfer.
             *     Applications should not request more than 256 objects at a time,
             *     and must handle the case where the service returns less than the
             *     requested number of objects in a given request even though more
             *     objects are available on the service.
             *
             * @param fullSyncOnly
             *     If true, then the client only wants initial data for a full sync.
             *     In this case, the service will not return any expunged objects,
             *     and will not return any Resources, since these are also provided
             *     in their corresponding Notes.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "afterUSN" - if negative
             *     </li>
             *     <li> BAD_DATA_FORMAT "maxEntries" - if less than 1
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "LinkedNotebook" - if the provided information doesn't match any
             *         valid notebook
             *     </li>
             *     <li> "LinkedNotebook.uri" - if the provided public URI doesn't match any
             *         valid notebook
             *     </li>
             *     <li> "SharedNotebook.id" - if the provided information indicates a
             *            shared notebook that no longer exists
             *     </li>
             * </ul>
             */
            getLinkedNotebookSyncChunk(linkedNotebook: LinkedNotebook, afterUSN: number, maxEntries: number, fullSyncOnly: boolean, cb: Callback<SyncChunk>): void;

            /**
             * Returns a list of all of the notebooks in the account.
             */
            listNotebooks(cb: Callback<Notebook[]>): void;

            /**
             * Returns the current state of the notebook with the provided GUID.
             * The notebook may be active or deleted (but not expunged).
             *
             * @param guid
             *     The GUID of the notebook to be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Notebook.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Notebook" - private notebook, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - tag not found, by GUID
             *     </li>
             * </ul>
             */
            getNotebook(guid: string, cb: Callback<Notebook>): void;

            /**
             * Returns the notebook that should be used to store new notes in the
             * user's account when no other notebooks are specified.
             */
            getDefaultNotebook(cb: Callback<Notebook>): void;

            /**
             * Asks the service to make a notebook with the provided name.
             *
             * @param notebook
             *     The desired fields for the notebook must be provided on this
             *     object.    The name of the notebook must be set, and either the 'active'
             *     or 'defaultNotebook' fields may be set by the client at creation.
             *     If a notebook exists in the account with the same name (via
             *     case-insensitive compare), this will throw an EDAMUserException.
             *
             * @return
             *     The newly created Notebook.    The server-side GUID will be
             *     saved in this object's 'guid' field.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Notebook.name" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Notebook.stack" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Publishing.uri" - if publishing set but bad uri
             *     </li>
             *     <li> BAD_DATA_FORMAT "Publishing.publicDescription" - if too long
             *     </li>
             *     <li> DATA_CONFLICT "Notebook.name" - name already in use
             *     </li>
             *     <li> DATA_CONFLICT "Publishing.uri" - if URI already in use
             *     </li>
             *     <li> DATA_REQUIRED "Publishing.uri" - if publishing set but uri missing
             *     </li>
             *     <li> LIMIT_REACHED "Notebook" - at max number of notebooks
             *     </li>
             * </ul>
             */
            createNotebook(notebook: Notebook, cb: Callback<Notebook>): void;

            /**
             * Submits notebook changes to the service.    The provided data must include
             * the notebook's guid field for identification.
             *
             * @param notebook
             *     The notebook object containing the requested changes.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Notebook.name" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Notebook.stack" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Publishing.uri" - if publishing set but bad uri
             *     </li>
             *     <li> BAD_DATA_FORMAT "Publishing.publicDescription" - if too long
             *     </li>
             *     <li> DATA_CONFLICT "Notebook.name" - name already in use
             *     </li>
             *     <li> DATA_CONFLICT "Publishing.uri" - if URI already in use
             *     </li>
             *     <li> DATA_REQUIRED "Publishing.uri" - if publishing set but uri missing
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            updateNotebook(notebook: Notebook, cb: Callback<number>): void;

            /**
             * Permanently removes the notebook from the user's account.
             * After this action, the notebook is no longer available for undeletion, etc.
             * If the notebook contains any Notes, they will be moved to the current
             * default notebook and moved into the trash (i.e. Note.active=false).
             * <p/>
             * NOTE: This function is generally not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param guid
             *     The GUID of the notebook to delete.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Notebook.guid" - if the parameter is missing
             *     </li>
             *     <li> LIMIT_REACHED "Notebook" - trying to expunge the last Notebook
             *     </li>
             *     <li> PERMISSION_DENIED "Notebook" - private notebook, user doesn't own
             *     </li>
             * </ul>
             */
            expungeNotebook(guid: string, cb: Callback<number>): void;

            /**
             * Returns a list of the tags in the account.    Evernote does not support
             * the undeletion of tags, so this will only include active tags.
             */
            listTags(cb: Callback<Tag[]>): void;

            /**
             * Returns a list of the tags that are applied to at least one note within
             * the provided notebook.    If the notebook is public, the authenticationToken
             * may be ignored.
             *
             * @param notebookGuid
             *        the GUID of the notebook to use to find tags
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - notebook not found by GUID
             *     </li>
             * </ul>
             */
            listTagsByNotebook(notebookGuid: string, cb: Callback<Tag[]>): void;

            /**
             * Returns the current state of the Tag with the provided GUID.
             *
             * @param guid
             *     The GUID of the tag to be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Tag.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Tag" - private Tag, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Tag.guid" - tag not found, by GUID
             *     </li>
             * </ul>
             */
            getTag(guid: string, cb: Callback<Tag>): void;

            /**
             * Asks the service to make a tag with a set of information.
             *
             * @param tag
             *     The desired list of fields for the tag are specified in this
             *     object.    The caller must specify the tag name, and may provide
             *     the parentGUID.
             *
             * @return
             *     The newly created Tag.    The server-side GUID will be
             *     saved in this object.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Tag.name" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Tag.parentGuid" - malformed GUID
             *     </li>
             *     <li> DATA_CONFLICT "Tag.name" - name already in use
             *     </li>
             *     <li> LIMIT_REACHED "Tag" - at max number of tags
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Tag.parentGuid" - not found, by GUID
             *     </li>
             * </ul>
             */
            createTag(tag: Tag, cb: Callback<Tag>): void;

            /**
             * Submits tag changes to the service.    The provided data must include
             * the tag's guid field for identification.    The service will apply
             * updates to the following tag fields:    name, parentGuid
             *
             * @param tag
             *     The tag object containing the requested changes.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Tag.name" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Tag.parentGuid" - malformed GUID
             *     </li>
             *     <li> DATA_CONFLICT "Tag.name" - name already in use
             *     </li>
             *     <li> DATA_CONFLICT "Tag.parentGuid" - can't set parent: circular
             *     </li>
             *     <li> PERMISSION_DENIED "Tag" - user doesn't own tag
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Tag.guid" - tag not found, by GUID
             *     </li>
             *     <li> "Tag.parentGuid" - parent not found, by GUID
             *     </li>
             * </ul>
             */
            updateTag(tag: Tag, cb: Callback<number>): void;

            /**
             * Removes the provided tag from every note that is currently tagged with
             * this tag.    If this operation is successful, the tag will still be in
             * the account, but it will not be tagged on any notes.
             *
             * This function is not indended for use by full synchronizing clients, since
             * it does not provide enough result information to the client to reconcile
             * the local state without performing a follow-up sync from the service.    This
             * is intended for "thin clients" that need to efficiently support this as
             * a UI operation.
             *
             * @param guid
             *     The GUID of the tag to remove from all notes.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Tag.guid" - if the guid parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Tag" - user doesn't own tag
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Tag.guid" - tag not found, by GUID
             *     </li>
             * </ul>
             */
            untagAll(guid: string, cb: Callback<void>): void;

            /**
             * Permanently deletes the tag with the provided GUID, if present.
             * <p/>
             * NOTE: This function is generally not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param guid
             *     The GUID of the tag to delete.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Tag.guid" - if the guid parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Tag" - user doesn't own tag
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Tag.guid" - tag not found, by GUID
             *     </li>
             * </ul>
             */
            expungeTag(guid: string, cb: Callback<number>): void;

            /**
             * Returns a list of the searches in the account.    Evernote does not support
             * the undeletion of searches, so this will only include active searches.
             */
            listSearches(cb: Callback<SavedSearch[]>): void;

            /**
             * Returns the current state of the search with the provided GUID.
             *
             * @param guid
             *     The GUID of the search to be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "SavedSearch.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "SavedSearch" - private Tag, user doesn't own
             *     </li>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "SavedSearch.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getSearch(guid: string, cb: Callback<SavedSearch>): void;

            /**
             * Asks the service to make a saved search with a set of information.
             *
             * @param search
             *     The desired list of fields for the search are specified in this
             *     object. The caller must specify the name and query for the
             *     search, and may optionally specify a search scope.
             *     The SavedSearch.format field is ignored by the service.
             *
             * @return
             *     The newly created SavedSearch.    The server-side GUID will be
             *     saved in this object.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "SavedSearch.name" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "SavedSearch.query" - invalid length
             *     </li>
             *     <li> DATA_CONFLICT "SavedSearch.name" - name already in use
             *     </li>
             *     <li> LIMIT_REACHED "SavedSearch" - at max number of searches
             *     </li>
             * </ul>
             */
            createSearch(search: SavedSearch, cb: Callback<SavedSearch>): void;

            /**
             * Submits search changes to the service. The provided data must include
             * the search's guid field for identification. The service will apply
             * updates to the following search fields: name, query, and scope.
             *
             * @param search
             *     The search object containing the requested changes.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "SavedSearch.name" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "SavedSearch.query" - invalid length
             *     </li>
             *     <li> DATA_CONFLICT "SavedSearch.name" - name already in use
             *     </li>
             *     <li> PERMISSION_DENIED "SavedSearch" - user doesn't own tag
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "SavedSearch.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            updateSearch(search: SavedSearch, cb: Callback<number>): number;

            /**
             * Permanently deletes the saved search with the provided GUID, if present.
             * <p/>
             * NOTE: This function is generally not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param guid
             *     The GUID of the search to delete.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "SavedSearch.guid" - if the guid parameter is empty
             *     </li>
             *     <li> PERMISSION_DENIED "SavedSearch" - user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "SavedSearch.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            expungeSearch(guid: string, cb: Callback<number>): void;

            /**
             * DEPRECATED. Use findNotesMetadata.
             */
            findNotes(filter: NoteFilter, offset: number, maxNotes: number, cb: Callback<NoteList>): void;

            /**
             * Finds the position of a note within a sorted subset of all of the user's
             * notes. This may be useful for thin clients that are displaying a paginated
             * listing of a large account, which need to know where a particular note
             * sits in the list without retrieving all notes first.
             *
             * @param authenticationToken
             *     Must be a valid token for the user's account unless the NoteFilter
             *     'notebookGuid' is the GUID of a public notebook.
             *
             * @param filter
             *     The list of criteria that will constrain the notes to be returned.
             *
             * @param guid
             *     The GUID of the note to be retrieved.
             *
             * @return
             *     If the note with the provided GUID is found within the matching note
             *     list, this will return the offset of that note within that list (where
             *     the first offset is 0).    If the note is not found within the set of
             *     notes, this will return -1.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "offset" - not between 0 and EDAM_USER_NOTES_MAX
             *     </li>
             *     <li> BAD_DATA_FORMAT "maxNotes" - not between 0 and EDAM_USER_NOTES_MAX
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.words" - if search string too long
             *     </li>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - not found, by GUID
             *     </li>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            findNoteOffset(filter: NoteFilter, guid: string, cb: Callback<number>): void;

            /**
             * Used to find the high-level information about a set of the notes from a
             * user's account based on various criteria specified via a NoteFilter object.
             * <p/>
             * Web applications that wish to periodically check for new content in a user's
             * Evernote account should consider using webhooks instead of polling this API.
             * See http://dev.evernote.com/documentation/cloud/chapters/polling_notification.php
             * for more information.
             *
             * @param authenticationToken
             *     Must be a valid token for the user's account unless the NoteFilter
             *     'notebookGuid' is the GUID of a public notebook.
             *
             * @param filter
             *     The list of criteria that will constrain the notes to be returned.
             *
             * @param offset
             *     The numeric index of the first note to show within the sorted
             *     results.    The numbering scheme starts with "0".    This can be used for
             *     pagination.
             *
             * @param maxNotes
             *     The mximum notes to return in this query.    The service will return a set
             *     of notes that is no larger than this number, but may return fewer notes
             *     if needed.    The NoteList.totalNotes field in the return value will
             *     indicate whether there are more values available after the returned set.
             *
             * @param resultSpec
             *     This specifies which information should be returned for each matching
             *     Note. The fields on this structure can be used to eliminate data that
             *     the client doesn't need, which will reduce the time and bandwidth
             *     to receive and process the reply.
             *
             * @return
             *     The list of notes that match the criteria.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "offset" - not between 0 and EDAM_USER_NOTES_MAX
             *     </li>
             *     <li> BAD_DATA_FORMAT "maxNotes" - not between 0 and EDAM_USER_NOTES_MAX
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.words" - if search string too long
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            findNotesMetadata(filter: NoteFilter, offset: number, maxNotes: number, resultSpec: NotesMetadataResultSpec, cb: Callback<NotesMetadataList>): void;

            /**
             * This function is used to determine how many notes are found for each
             * notebook and tag in the user's account, given a current set of filter
             * parameters that determine the current selection.    This function will
             * return a structure that gives the note count for each notebook and tag
             * that has at least one note under the requested filter.    Any notebook or
             * tag that has zero notes in the filtered set will not be listed in the
             * reply to this function (so they can be assumed to be 0).
             *
             * @param authenticationToken
             *     Must be a valid token for the user's account unless the NoteFilter
             *     'notebookGuid' is the GUID of a public notebook.
             *
             * @param filter
             *     The note selection filter that is currently being applied.    The note
             *     counts are to be calculated with this filter applied to the total set
             *     of notes in the user's account.
             *
             * @param withTrash
             *     If true, then the NoteCollectionCounts.trashCount will be calculated
             *     and supplied in the reply. Otherwise, the trash value will be omitted.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.notebookGuids" - if any are malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.words" - if search string too long
             *     </li>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            findNoteCounts(filter: NoteFilter, withTrash: boolean, cb: Callback<NoteCollectionCounts>): void;

            /**
             * Returns the current state of the note in the service with the provided
             * GUID.    The ENML contents of the note will only be provided if the
             * 'withContent' parameter is true.    The service will include the meta-data
             * for each resource in the note, but the binary contents of the resources
             * and their recognition data will be omitted.
             * If the Note is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).    The applicationData
             * fields are returned as keysOnly.
             *
             * @param guid
             *     The GUID of the note to be retrieved.
             *
             * @param withContent
             *     If true, the note will include the ENML contents of its
             *     'content' field.
             *
             * @param withResourcesData
             *     If true, any Resource elements in this Note will include the binary
             *     contents of their 'data' field's body.
             *
             * @param withResourcesRecognition
             *     If true, any Resource elements will include the binary contents of the
             *     'recognition' field's body if recognition data is present.
             *
             * @param withResourcesAlternateData
             *     If true, any Resource elements in this Note will include the binary
             *     contents of their 'alternateData' fields' body, if an alternate form
             *     is present.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getNote(guid: string, withContent: boolean, withResourcesData: boolean, withResourcesRecognition: boolean, withResourcesAlternateData: boolean, cb: Callback<Note>): void;

            /**
             * Get all of the application data for the note identified by GUID,
             * with values returned within the LazyMap fullMap field.
             * If there are no applicationData entries, then a LazyMap
             * with an empty fullMap will be returned. If your application
             * only needs to fetch its own applicationData entry, use
             * getNoteApplicationDataEntry instead.
             */
            getNoteApplicationData(guid: string, cb: Callback<LazyMap>): void;

            /**
             * Get the value of a single entry in the applicationData map
             * for the note identified by GUID.
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - note not found, by GUID</li>
             *     <li> "NoteAttributes.applicationData.key" - note not found, by key</li>
             * </ul>
             */
            getNoteApplicationDataEntry(guid: string, key: string, cb: Callback<string>): void;

            /**
             * Update, or create, an entry in the applicationData map for
             * the note identified by guid.
             */
            setNoteApplicationDataEntry(guid: string, key: string, value: string, cb: Callback<number>): void;

            /**
             * Remove an entry identified by 'key' from the applicationData map for
             * the note identified by 'guid'. Silently ignores an unset of a
             * non-existing key.
             */
            unsetNoteApplicationDataEntry(guid: string, key: string, cb: Callback<number>): void;

            /**
             * Returns XHTML contents of the note with the provided GUID.
             * If the Note is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).
             *
             * @param guid
             *     The GUID of the note to be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getNoteContent(guid: string, cb: Callback<string>): void;

            /**
             * Returns a block of the extracted plain text contents of the note with the
             * provided GUID.    This text can be indexed for search purposes by a light
             * client that doesn't have capabilities to extract all of the searchable
             * text content from the note and its resources.
             *
             * If the Note is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).
             *
             * @param guid
             *     The GUID of the note to be retrieved.
             *
             * @param noteOnly
             *     If true, this will only return the text extracted from the ENML contents
             *     of the note itself.    If false, this will also include the extracted text
             *     from any text-bearing resources (PDF, recognized images)
             *
             * @param tokenizeForIndexing
             *     If true, this will break the text into cleanly separated and sanitized
             *     tokens.    If false, this will return the more raw text extraction, with
             *     its original punctuation, capitalization, spacing, etc.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getNoteSearchText(guid: string, noteOnly: boolean, tokenizeForIndexing: boolean, cb: Callback<string>): void;

            /**
             * Returns a block of the extracted plain text contents of the resource with
             * the provided GUID.    This text can be indexed for search purposes by a light
             * client that doesn't have capability to extract all of the searchable
             * text content from a resource.
             *
             * If the Resource is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).
             *
             * @param guid
             *     The GUID of the resource to be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getResourceSearchText(guid: string, cb: Callback<string>): void;

            /**
             * Returns a list of the names of the tags for the note with the provided
             * guid.    This can be used with authentication to get the tags for a
             * user's own note, or can be used without valid authentication to retrieve
             * the names of the tags for a note in a public notebook.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getNoteTagNames(guid: string, cb: Callback<string[]>): void;

            /**
             * Asks the service to make a note with the provided set of information.
             *
             * @param note
             *     A Note object containing the desired fields to be populated on
             *     the service.
             *
             * @return
             *     The newly created Note from the service.    The server-side
             *     GUIDs for the Note and any Resources will be saved in this object.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.title" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Note.content" - invalid length for ENML content
             *     </li>
             *     <li> BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteAttributes.*" - bad resource string
             *     </li>
             *     <li> BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
             *     </li>
             *     <li> DATA_CONFLICT "Note.deleted" - deleted time set on active note
             *     </li>
             *     <li> DATA_REQUIRED "Resource.data" - resource data body missing
             *     </li>
             *     <li> ENML_VALIDATION "*" - note content doesn't validate against DTD
             *     </li>
             *     <li> LIMIT_REACHED "Note" - at max number per account
             *     </li>
             *     <li> LIMIT_REACHED "Note.size" - total note size too large
             *     </li>
             *     <li> LIMIT_REACHED "Note.resources" - too many resources on Note
             *     </li>
             *     <li> LIMIT_REACHED "Note.tagGuids" - too many Tags on Note
             *     </li>
             *     <li> LIMIT_REACHED "Resource.data.size" - resource too large
             *     </li>
             *     <li> LIMIT_REACHED "NoteAttribute.*" - attribute string too long
             *     </li>
             *     <li> LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
             *     </li>
             *     <li> PERMISSION_DENIED "Note.notebookGuid" - NB not owned by user
             *     </li>
             *     <li> QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
             *     </li>
             *     <li> BAD_DATA_FORMAT "Tag.name" - Note.tagNames was provided, and one
             *         of the specified tags had an invalid length or pattern
             *     </li>
             *     <li> LIMIT_REACHED "Tag" - Note.tagNames was provided, and the required
             *         new tags would exceed the maximum number per account
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.notebookGuid" - not found, by GUID
             *     </li>
             * </ul>
             */
            createNote(note: Note, cb: Callback<Note>): void;

            /**
             * Submit a set of changes to a note to the service.    The provided data
             * must include the note's guid field for identification. The note's
             * title must also be set.
             *
             * @param note
             *     A Note object containing the desired fields to be populated on
             *     the service. With the exception of the note's title and guid, fields
             *     that are not being changed do not need to be set. If the content is not
             *     being modified, note.content should be left unset. If the list of
             *     resources is not being modified, note.resources should be left unset.
             *
             * @return
             *     The metadata (no contents) for the Note on the server after the update
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.title" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "Note.content" - invalid length for ENML body
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteAttributes.*" - bad resource string
             *     </li>
             *     <li> BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
             *     </li>
             *     <li> BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
             *     </li>
             *     <li> DATA_CONFLICT "Note.deleted" - deleted time set on active note
             *     </li>
             *     <li> DATA_REQUIRED "Resource.data" - resource data body missing
             *     </li>
             *     <li> ENML_VALIDATION "*" - note content doesn't validate against DTD
             *     </li>
             *     <li> LIMIT_REACHED "Note.tagGuids" - too many Tags on Note
             *     </li>
             *     <li> LIMIT_REACHED "Note.resources" - too many resources on Note
             *     </li>
             *     <li> LIMIT_REACHED "Note.size" - total note size too large
             *     </li>
             *     <li> LIMIT_REACHED "Resource.data.size" - resource too large
             *     </li>
             *     <li> LIMIT_REACHED "NoteAttribute.*" - attribute string too long
             *     </li>
             *     <li> LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - user doesn't own
             *     </li>
             *     <li> PERMISSION_DENIED "Note.notebookGuid" - user doesn't own destination
             *     </li>
             *     <li> QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
             *     </li>
             *     <li> BAD_DATA_FORMAT "Tag.name" - Note.tagNames was provided, and one
             *         of the specified tags had an invalid length or pattern
             *     </li>
             *     <li> LIMIT_REACHED "Tag" - Note.tagNames was provided, and the required
             *         new tags would exceed the maximum number per account
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - note not found, by GUID
             *     </li>
             *     <li> "Note.notebookGuid" - if notebookGuid provided, but not found
             *     </li>
             * </ul>
             */
            updateNote(note: Note, cb: Callback<Note>): void;

            /**
             * Moves the note into the trash. The note may still be undeleted, unless it
             * is expunged.    This is equivalent to calling updateNote() after setting
             * Note.active = false
             *
             * @param guid
             *     The GUID of the note to delete.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> PERMISSION_DENIED "Note" - user doesn't have permission to
             *                    update the note.
             *     </li>
             * </ul>
             *
             * @throws EDAMUserException <ul>
             *     <li> DATA_CONFLICT "Note.guid" - the note is already deleted
             *     </li>
             * </ul>
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            deleteNote(guid: string, cb: Callback<number>): void;

            /**
             * Permanently removes a Note, and all of its Resources,
             * from the service.
             * <p/>
             * NOTE: This function is not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param guid
             *     The GUID of the note to delete.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> PERMISSION_DENIED "Note" - user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            expungeNote(guid: string, cb: Callback<number>): void;

            /**
             * Permanently removes a list of Notes, and all of their Resources, from
             * the service.    This should be invoked with a small number of Note GUIDs
             * (e.g. 100 or less) on each call.    To expunge a larger number of notes,
             * call this method multiple times.    This should also be used to reduce the
             * number of Notes in a notebook before calling expungeNotebook() or
             * in the trash before calling expungeInactiveNotes(), since these calls may
             * be prohibitively slow if there are more than a few hundred notes.
             * If an exception is thrown for any of the GUIDs, then none of the notes
             * will be deleted.    I.e. this call can be treated as an atomic transaction.
             * <p/>
             * NOTE: This function is not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param noteGuids
             *     The list of GUIDs for the Notes to remove.
             *
             * @return
             *     The account's updateCount at the end of this operation
             *
             * @throws EDAMUserException <ul>
             *     <li> PERMISSION_DENIED "Note" - user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            expungeNotes(noteGuids: string[], cb: Callback<number>): void;

            /**
             * Permanently removes all of the Notes that are currently marked as
             * inactive.    This is equivalent to "emptying the trash", and these Notes
             * will be gone permanently.
             * <p/>
             * This operation may be relatively slow if the account contains a large
             * number of inactive Notes.
             * <p/>
             * NOTE: This function is not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @return
             *        The number of notes that were expunged.
             */
            expungeInactiveNotes(cb: Callback<number>): void;

            /**
             * Performs a deep copy of the Note with the provided GUID 'noteGuid' into
             * the Notebook with the provided GUID 'toNotebookGuid'.
             * The caller must be the owner of both the Note and the Notebook.
             * This creates a new Note in the destination Notebook with new content and
             * Resources that match all of the content and Resources from the original
             * Note, but with new GUID identifiers.
             * The original Note is not modified by this operation.
             * The copied note is considered as an "upload" for the purpose of upload
             * transfer limit calculation, so its size is added to the upload count for
             * the owner.
             *
             * @param noteGuid
             *     The GUID of the Note to copy.
             *
             * @param toNotebookGuid
             *     The GUID of the Notebook that should receive the new Note.
             *
             * @return
             *     The metadata for the new Note that was created.    This will include the
             *     new GUID for this Note (and any copied Resources), but will not include
             *     the content body or the binary bodies of any Resources.
             *
             * @throws EDAMUserException <ul>
             *     <li> LIMIT_REACHED "Note" - at max number per account
             *     </li>
             *     <li> PERMISSION_DENIED "Notebook.guid" - destination not owned by user
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - user doesn't own
             *     </li>
             *     <li> QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            copyNote(noteGuid: string, toNotebookGuid: string, cb: Callback<Note>): void;

            /**
             * Returns a list of the prior versions of a particular note that are
             * saved within the service.    These prior versions are stored to provide a
             * recovery from unintentional removal of content from a note. The identifiers
             * that are returned by this call can be used with getNoteVersion to retrieve
             * the previous note.
             * The identifiers will be listed from the most recent versions to the oldest.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            listNoteVersions(noteGuid: string, cb: Callback<NoteVersionId[]>): void;

            /**
             * This can be used to retrieve a previous version of a Note after it has been
             * updated within the service.    The caller must identify the note (via its
             * guid) and the version (via the updateSequenceNumber of that version).
             * to find a listing of the stored version USNs for a note, call
             * listNoteVersions.
             * This call is only available for notes in Premium accounts.    (I.e. access
             * to past versions of Notes is a Premium-only feature.)
             *
             * @param noteGuid
             *     The GUID of the note to be retrieved.
             *
             * @param updateSequenceNum
             *     The USN of the version of the note that is being retrieved
             *
             * @param withResourcesData
             *     If true, any Resource elements in this Note will include the binary
             *     contents of their 'data' field's body.
             *
             * @param withResourcesRecognition
             *     If true, any Resource elements will include the binary contents of the
             *     'recognition' field's body if recognition data is present.
             *
             * @param withResourcesAlternateData
             *     If true, any Resource elements in this Note will include the binary
             *     contents of their 'alternateData' fields' body, if an alternate form
             *     is present.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             *     <li> PERMISSION_DENIED "updateSequenceNum" -
             *         The account isn't permitted to access previous versions of notes.
             *         (i.e. this is a Free account.)
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             *     <li> "Note.updateSequenceNumber" - the Note doesn't have a version with
             *            the corresponding USN.
             *     </li>
             * </ul>
             */
            getNoteVersion(noteGuid: string, updateSequenceNum: number, withResourcesData: boolean, withResourcesRecognition: boolean, withResourcesAlternateData: boolean, cb: Callback<Note>): void;

            /**
             * Returns the current state of the resource in the service with the
             * provided GUID.
             * If the Resource is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).    Only the
             * keys for the applicationData will be returned.
             *
             * @param guid
             *     The GUID of the resource to be retrieved.
             *
             * @param withData
             *     If true, the Resource will include the binary contents of the
             *     'data' field's body.
             *
             * @param withRecognition
             *     If true, the Resource will include the binary contents of the
             *     'recognition' field's body if recognition data is present.
             *
             * @param withAttributes
             *     If true, the Resource will include the attributes
             *
             * @param withAlternateData
             *     If true, the Resource will include the binary contents of the
             *     'alternateData' field's body, if an alternate form is present.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getResource(guid: string, withData: boolean, withRecognition: boolean, withAttributes: boolean, withAlternateData: boolean, cb: Callback<Resource>): void;

            /**
             * Get all of the application data for the Resource identified by GUID,
             * with values returned within the LazyMap fullMap field.
             * If there are no applicationData entries, then a LazyMap
             * with an empty fullMap will be returned. If your application
             * only needs to fetch its own applicationData entry, use
             * getResourceApplicationDataEntry instead.
             */
            getResourceApplicationData(guid: string, cb: Callback<LazyMap>): void;

            /**
             * Get the value of a single entry in the applicationData map
             * for the Resource identified by GUID.
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - Resource not found, by GUID</li>
             *     <li> "ResourceAttributes.applicationData.key" - Resource not found, by key</li>
             * </ul>
             */
            getResourceApplicationDataEntry(guid: string, key: string, cb: Callback<string>): void;

            /**
             * Update, or create, an entry in the applicationData map for
             * the Resource identified by guid.
             */
            setResourceApplicationDataEntry(guid: string, key: string, value: string, cb: Callback<number>): void;

            /**
             * Remove an entry identified by 'key' from the applicationData map for
             * the Resource identified by 'guid'.
             */
            unsetResourceApplicationDataEntry(guid: string, key: string, cb: Callback<number>): void;

            /**
             * Submit a set of changes to a resource to the service.    This can be used
             * to update the meta-data about the resource, but cannot be used to change
             * the binary contents of the resource (including the length and hash).    These
             * cannot be changed directly without creating a new resource and removing the
             * old one via updateNote.
             *
             * @param resource
             *     A Resource object containing the desired fields to be populated on
             *     the service.    The service will attempt to update the resource with the
             *     following fields from the client:
             *     <ul>
             *            <li>guid:    must be provided to identify the resource
             *            </li>
             *            <li>mime
             *            </li>
             *            <li>width
             *            </li>
             *            <li>height
             *            </li>
             *            <li>duration
             *            </li>
             *            <li>attributes:    optional.    if present, the set of attributes will
             *                     be replaced.
             *            </li>
             *     </ul>
             *
             * @return
             *     The Update Sequence Number of the resource after the changes have been
             *     applied.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
             *     </li>
             *     <li> BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
             *     </li>
             *     <li> BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
             *     </li>
             *     <li> LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            updateResource(resource: Resource, cb: Callback<number>): void;

            /**
             * Returns binary data of the resource with the provided GUID.    For
             * example, if this were an image resource, this would contain the
             * raw bits of the image.
             * If the Resource is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).
             *
             * @param guid
             *     The GUID of the resource to be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getResourceData(guid: string, cb: Callback<string>): void;

            /**
             * Returns the current state of a resource, referenced by containing
             * note GUID and resource content hash.
             *
             * @param noteGuid
             *     The GUID of the note that holds the resource to be retrieved.
             *
             * @param contentHash
             *     The MD5 checksum of the resource within that note. Note that
             *     this is the binary checksum, for example from Resource.data.bodyHash,
             *     and not the hex-encoded checksum that is used within an en-media
             *     tag in a note body.
             *
             * @param withData
             *     If true, the Resource will include the binary contents of the
             *     'data' field's body.
             *
             * @param withRecognition
             *     If true, the Resource will include the binary contents of the
             *     'recognition' field's body.
             *
             * @param withAlternateData
             *     If true, the Resource will include the binary contents of the
             *     'alternateData' field's body, if an alternate form is present.
             *
             * @throws EDAMUserException <ul>
             *     <li> DATA_REQUIRED "Note.guid" - noteGuid param missing
             *     </li>
             *     <li> DATA_REQUIRED "Note.contentHash" - contentHash param missing
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note" - not found, by guid
             *     </li>
             *     <li> "Resource" - not found, by hash
             *     </li>
             * </ul>
             */
            getResourceByHash(noteGuid: string, contentHash: string, withData: boolean, withRecognition: boolean, withAlternateData: boolean, cb: Callback<Resource>): void;

            /**
             * Returns the binary contents of the recognition index for the resource
             * with the provided GUID.    If the caller asks about a resource that has
             * no recognition data, this will throw EDAMNotFoundException.
             * If the Resource is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).
             *
             * @param guid
             *     The GUID of the resource whose recognition data should be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - not found, by GUID
             *     </li>
             *     <li> "Resource.recognition" - resource has no recognition
             *     </li>
             * </ul>
             */
            getResourceRecognition(guid: string, cb: Callback<string>): void;

            /**
             * If the Resource with the provided GUID has an alternate data representation
             * (indicated via the Resource.alternateData field), then this request can
             * be used to retrieve the binary contents of that alternate data file.
             * If the caller asks about a resource that has no alternate data form, this
             * will throw EDAMNotFoundException.
             *
             * @param guid
             *        The GUID of the resource whose recognition data should be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - not found, by GUID
             *     </li>
             *     <li> "Resource.alternateData" - resource has no recognition
             *     </li>
             * </ul>
             */
            getResourceAlternateData(guid: string, cb: Callback<string>): void;

            /**
             * Returns the set of attributes for the Resource with the provided GUID.
             * If the Resource is found in a public notebook, the authenticationToken
             * will be ignored (so it could be an empty string).
             *
             * @param guid
             *     The GUID of the resource whose attributes should be retrieved.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Resource" - private resource, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Resource.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            getResourceAttributes(guid: string, cb: Callback<ResourceAttributes>): void;

            /**
             * <p>
             * Looks for a user account with the provided userId on this NoteStore
             * shard and determines whether that account contains a public notebook
             * with the given URI.    If the account is not found, or no public notebook
             * exists with this URI, this will throw an EDAMNotFoundException,
             * otherwise this will return the information for that Notebook.
             * </p>
             * <p>
             * If a notebook is visible on the web with a full URL like
             * http://www.evernote.com/pub/sethdemo/api
             * Then 'sethdemo' is the username that can be used to look up the userId,
             * and 'api' is the publicUri.
             * </p>
             *
             * @param userId
             *        The numeric identifier for the user who owns the public notebook.
             *        To find this value based on a username string, you can invoke
             *        UserStore.getPublicUserInfo
             *
             * @param publicUri
             *        The uri string for the public notebook, from Notebook.publishing.uri.
             *
             * @throws EDAMNotFoundException <ul>
             *     <li>"Publishing.uri" - not found, by URI</li>
             * </ul>
             *
             * @throws EDAMSystemException <ul>
             *     <li> TAKEN_DOWN "PublicNotebook" - The specified public notebook is
             *         taken down (for all requesters).</li>
             *     <li> TAKEN_DOWN "Country" - The specified public notebook is taken
             *         down for the requester because of an IP-based country lookup.</li>
             * </ul>
             */
            getPublicNotebook(userId: number, publicUri: string, cb: Callback<Notebook>): void;

            /**
             * Used to construct a shared notebook object. The constructed notebook will
             * contain a "share key" which serve as a unique identifer and access token
             * for a user to access the notebook of the shared notebook owner.
             *
             * @param sharedNotebook
             *     A shared notebook object populated with the email address of the share
             *     recipient, the notebook guid and the access permissions. All other
             *     attributes of the shared object are ignored. The SharedNotebook.allowPreview
             *     field must be explicitly set with either a true or false value.
             *
             * @return
             *     The fully populated SharedNotebook object including the server assigned
             *     share id and shareKey which can both be used to uniquely identify the
             *     SharedNotebook.
             *
             * @throws EDAMUserException <ul>
             *     <li>BAD_DATA_FORMAT "SharedNotebook.email" - if the email was not valid</li>
             *     <li>BAD_DATA_FORMAT "requireLogin" - if the SharedNotebook.allowPreview field was
             *             not set, and the SharedNotebook.requireLogin was also not set or was set to
             *             false.</li>
             *     <li>PERMISSION_DENIED "SharedNotebook.recipientSettings" - if
             *             recipientSettings is set in the sharedNotebook.    Only the recipient
             *             can set these values via the setSharedNotebookRecipientSettings
             *             method.
             *     </li>
             *     </ul>
             * @throws EDAMNotFoundException <ul>
             *     <li>Notebook.guid - if the notebookGuid is not a valid GUID for the user.
             *     </li>
             *     </ul>
             */
            createSharedNotebook(sharedNotebook: SharedNotebook, cb: Callback<SharedNotebook>): void;

            /**
             * Update a SharedNotebook object.
             *
             * @param authenticationToken
             *     Must be an authentication token from the owner or a shared notebook
             *     authentication token or business authentication token with sufficient
             *     permissions to change invitations for a notebook.
             *
             * @param sharedNotebook
             *    The SharedNotebook object containing the requested changes.
             *    The "id" of the shared notebook must be set to allow the service
             *    to identify the SharedNotebook to be updated. In addition, you MUST set
             *    the email, permission, and allowPreview fields to the desired values.
             *    All other fields will be ignored if set.
             *
             * @return
             *    The Update Serial Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li>UNSUPPORTED_OPERATION "updateSharedNotebook" - if this service instance does not support shared notebooks.</li>
             *     <li>BAD_DATA_FORMAT "SharedNotebook.email" - if the email was not valid.</li>
             *     <li>DATA_REQUIRED "SharedNotebook.id" - if the id field was not set.</li>
             *     <li>DATA_REQUIRED "SharedNotebook.privilege" - if the privilege field was not set.</li>
             *     <li>DATA_REQUIRED "SharedNotebook.allowPreview" - if the allowPreview field was not set.</li>
             *     </ul>
             * @throws EDAMNotFoundException <ul>
             *     <li>SharedNotebook.id - if no shared notebook with the specified ID was found.
             *     </ul>
             */
            updateSharedNotebook(sharedNotebook: SharedNotebook, cb: Callback<number>): void;

            /**
             * Set values for the recipient settings associated with a shared notebook.    Having
             * update rights to the shared notebook record itself has no effect on this call;
             * only the recipient of the shared notebook can can the recipient settings.
             *
             * If you do <i>not</i> wish to, or cannot, change one of the reminderNotifyEmail or
             * reminderNotifyInApp fields, you must leave that field unset in recipientSettings.
             * This method will skip that field for updates and leave the existing state as
             * it is.
             *
             * @return The update sequence number of the account to which the shared notebook
             *     belongs, which is the account from which we are sharing a notebook.
             *
             * @throws EDAMNotFoundException "sharedNotebookId" - Thrown if the service does not
             *     have a shared notebook record for the sharedNotebookId on the given shard.    If you
             *     receive this exception, it is probable that the shared notebook record has
             *     been revoked or expired, or that you accessed the wrong shard.
             *
             * @throws EDAMUserException <ul>
             *     <li>PEMISSION_DENIED "authenticationToken" - If you do not have permission to set
             *             the recipient settings for the shared notebook.    Only the recipient has
             *             permission to do this.
             *     <li>DATA_CONFLICT "recipientSettings.reminderNotifyEmail" - Setting whether
             *             or not you want to receive reminder e-mail notifications is possible on
             *             a business notebook in the business to which the user belongs.    All
             *             others can safely unset the reminderNotifyEmail field from the
             *             recipientSettings parameter.
             * </ul>
             */
            setSharedNotebookRecipientSettings(sharedNotebookId: number, recipientSettings: SharedNotebookRecipientSettings, cb: Callback<number>): void;

            /**
             * Send a reminder message to some or all of the email addresses that a notebook has been
             * shared with. The message includes the current link to view the notebook.
             * @param authenticationToken
             *     The auth token of the user with permissions to share the notebook
             * @param notebookGuid
             *     The guid of the shared notebook
             * @param messageText
             *    User provided text to include in the email
             * @param recipients
             *    The email addresses of the recipients. If this list is empty then all of the
             *    users that the notebook has been shared with are emailed.
             *    If an email address doesn't correspond to share invite members then that address
             *    is ignored.
             * @return
             *    The number of messages sent
             * @throws EDAMUserException <ul>
             *     <li> LIMIT_REACHED "(recipients)" -
             *         The email can't be sent because this would exceed the user's daily
             *         email limit.
             *     </li>
             *     <li> PERMISSION_DENIED "Notebook.guid" - The user doesn't have permission to
             *         send a message for the specified notebook.
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Notebook.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            sendMessageToSharedNotebookMembers(notebookGuid: string, messageText: string, recipients: string[], cb: Callback<number>): void;

            /**
             * Lists the collection of shared notebooks for all notebooks in the
             * users account.
             *
             * @return
             *    The list of all SharedNotebooks for the user
             */
            listSharedNotebooks(cb: Callback<SharedNotebook[]>): void;

            /**
             * Expunges the SharedNotebooks in the user's account using the
             * SharedNotebook.id as the identifier.
             * <p/>
             * NOTE: This function is generally not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param
             *     sharedNotebookIds - a list of ShardNotebook.id longs identifying the
             *             objects to delete permanently.
             *
             * @return
             *     The account's update sequence number.
             */
            expungeSharedNotebooks(sharedNotebookIds: number[], cb: Callback<number>): void;

            /**
             * Asks the service to make a linked notebook with the provided name, username
             * of the owner and identifiers provided. A linked notebook can be either a
             * link to a public notebook or to a private shared notebook.
             *
             * @param linkedNotebook
             *     The desired fields for the linked notebook must be provided on this
             *     object.    The name of the linked notebook must be set. Either a username
             *     uri or a shard id and share key must be provided otherwise a
             *     EDAMUserException is thrown.
             *
             * @return
             *     The newly created LinkedNotebook.    The server-side id will be
             *     saved in this object's 'id' field.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "LinkedNotebook.name" - invalid length or pattern
             *     </li>
             *     <li> BAD_DATA_FORMAT "LinkedNotebook.username" - bad username format
             *     </li>
             *     <li> BAD_DATA_FORMAT "LinkedNotebook.uri" -
             *         if public notebook set but bad uri
             *     </li>
             *     <li> BAD_DATA_FORMAT "LinkedNotebook.shareKey" -
             *         if private notebook set but bad shareKey
             *     </li>
             *     <li> DATA_REQUIRED "LinkedNotebook.shardId" -
             *         if private notebook but shard id not provided
             *     </li>
             * </ul>
             */
            createLinkedNotebook(linkedNotebook: LinkedNotebook, cb: Callback<LinkedNotebook>): void;

            /**
             * @param linkedNotebook
             *     Updates the name of a linked notebook.
             *
             * @return
             *     The Update Sequence Number for this change within the account.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "LinkedNotebook.name" - invalid length or pattern
             *     </li>
             * </ul>
             */
            updateLinkedNotebook(linkedNotebook: LinkedNotebook, cb: Callback<number>): void;

            /**
             * Returns a list of linked notebooks
             */
            listLinkedNotebooks(cb: Callback<LinkedNotebook[]>): void;

            /**
             * Permanently expunges the linked notebook from the account.
             * <p/>
             * NOTE: This function is generally not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param guid
             *     The LinkedNotebook.guid field of the LinkedNotebook to permanently remove
             *     from the account.
             */
            expungeLinkedNotebook(guid: string, cb: Callback<number>): void;

            /**
             * Asks the service to produce an authentication token that can be used to
             * access the contents of a shared notebook from someone else's account.
             * This authenticationToken can be used with the various other NoteStore
             * calls to find and retrieve notes, and if the permissions in the shared
             * notebook are sufficient, to make changes to the contents of the notebook.
             *
             * @param shareKey
             *     The 'shareKey' identifier from the SharedNotebook that was granted to
             *     some recipient.    This string internally encodes the notebook identifier
             *     and a security signature.
             *
             * @param authenticationToken
             *     If a non-empty string is provided, this is the full user-based
             *     authentication token that identifies the user who is currently logged in
             *     and trying to access the shared notebook.    This may be required if the
             *     notebook was created with 'requireLogin'.
             *     If this string is empty, the service will attempt to authenticate to the
             *     shared notebook without any logged in user.
             *
             * @throws EDAMSystemException <ul>
             *     <li> BAD_DATA_FORMAT "shareKey" - invalid shareKey string
             *     </li>
             *     <li> INVALID_AUTH "shareKey" - bad signature on shareKey string
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "SharedNotebook.id" - the shared notebook no longer exists
             *     </li>
             * </ul>
             *
             * @throws EDAMUserException <ul>
             *     <li> DATA_REQUIRED "authenticationToken" - the share requires login, and
             *                    no valid authentication token was provided.
             *     </li>
             *     <li> PERMISSION_DENIED "SharedNotebook.username" - share requires login,
             *                    and another username has already been bound to this notebook.
             *     </li>
             * </ul>
             */
            authenticateToSharedNotebook(shareKey: string, cb: Callback<AuthenticationResult>): void;

            /**
             * This function is used to retrieve extended information about a shared
             * notebook by a guest who has already authenticated to access that notebook.
             * This requires an 'authenticationToken' parameter which should be the
             * resut of a call to authenticateToSharedNotebook(...).
             * I.e. this is the token that gives access to the particular shared notebook
             * in someone else's account -- it's not the authenticationToken for the
             * owner of the notebook itself.
             *
             * @param authenticationToken
             *     Should be the authentication token retrieved from the reply of
             *     authenticateToSharedNotebook(), proving access to a particular shared
             *     notebook.
             *
             * @throws EDAMUserException <ul>
             *     <li> PERMISSION_DENIED "authenticationToken" -
             *                    authentication token doesn't correspond to a valid shared notebook
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "SharedNotebook.id" - the shared notebook no longer exists
             *     </li>
             * </ul>
             */
            getSharedNotebookByAuth(cb: Callback<SharedNotebook>): void;

            /**
             * Attempts to send a single note to one or more email recipients.
             * <p/>
             * NOTE: This function is generally not available to third party applications.
             * Calls will result in an EDAMUserException with the error code
             * PERMISSION_DENIED.
             *
             * @param authenticationToken
             *        The note will be sent as the user logged in via this token, using that
             *        user's registered email address.    If the authenticated user doesn't
             *        have permission to read that note, the emailing will fail.
             *
             * @param parameters
             *        The note must be specified either by GUID (in which case it will be
             *        sent using the existing data in the service), or else the full Note
             *        must be passed to this call.    This also specifies the additional
             *        email fields that will be used in the email.
             *
             * @throws EDAMUserException <ul>
             *     <li> LIMIT_REACHED "NoteEmailParameters.toAddresses" -
             *         The email can't be sent because this would exceed the user's daily
             *         email limit.
             *     </li>
             *     <li> BAD_DATA_FORMAT "(email address)" -
             *         email address malformed
             *     </li>
             *     <li> DATA_REQUIRED "NoteEmailParameters.toAddresses" -
             *         if there are no To: or Cc: addresses provided.
             *     </li>
             *     <li> DATA_REQUIRED "Note.title" -
             *         if the caller provides a Note parameter with no title
             *     </li>
             *     <li> DATA_REQUIRED "Note.content" -
             *         if the caller provides a Note parameter with no content
             *     </li>
             *     <li> ENML_VALIDATION "*" - note content doesn't validate against DTD
             *     </li>
             *     <li> DATA_REQUIRED "NoteEmailParameters.note" -
             *         if no guid or note provided
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            emailNote(parameters: NoteEmailParameters, cb: Callback<void>): void;

            /**
             * If this note is not already shared (via its own direct URL), then this
             * will start sharing that note.
             * This will return the secret "Note Key" for this note that
             * can currently be used in conjunction with the Note's GUID to gain direct
             * read-only access to the Note.
             * If the note is already shared, then this won't make any changes to the
             * note, and the existing "Note Key" will be returned.    The only way to change
             * the Note Key for an existing note is to stopSharingNote first, and then
             * call this function.
             *
             * @param guid
             *     The GUID of the note to be shared.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            shareNote(guid: string, cb: Callback<string>): void;

            /**
             * If this note is not already shared then this will stop sharing that note
             * and invalidate its "Note Key", so any existing URLs to access that Note
             * will stop working.
             * If the Note is not shared, then this function will do nothing.
             *
             * @param guid
             *     The GUID of the note to be un-shared.
             *
             * @throws EDAMUserException <ul>
             *     <li> BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
             *     </li>
             *     <li> PERMISSION_DENIED "Note" - private note, user doesn't own
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "Note.guid" - not found, by GUID
             *     </li>
             * </ul>
             */
            stopSharingNote(guid: string, cb: Callback<void>): void;

            /**
             * Asks the service to produce an authentication token that can be used to
             * access the contents of a single Note which was individually shared
             * from someone's account.
             * This authenticationToken can be used with the various other NoteStore
             * calls to find and retrieve the Note and its directly-referenced children.
             *
             * @param guid
             *     The GUID identifying this Note on this shard.
             *
             * @param noteKey
             *     The 'noteKey' identifier from the Note that was originally created via
             *     a call to shareNote() and then given to a recipient to access.
             *
             * @param authenticationToken
             *     An optional authenticationToken that identifies the user accessing the
             *     shared note. This parameter may be required to access some shared notes.
             *
             * @throws EDAMUserException <ul>
             *     <li> PERMISSION_DENIED "Note" - the Note with that GUID is either not
             *         shared, or the noteKey doesn't match the current key for this note
             *     </li>
             *     <li> PERMISSION_DENIED "authenticationToken" - an authentication token is
             *         required to access this Note, but either no authentication token or a
             *         "non-owner" authentication token was provided.
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li> "guid" - the note with that GUID is not found
             *     </li>
             * </ul>
             *
             * @throws EDAMSystemException <ul>
             *     <li> TAKEN_DOWN "Note" - The specified shared note is taken down (for
             *         all requesters).
             *     </li>
             *     <li> TAKEN_DOWN "Country" - The specified shared note is taken down
             *         for the requester because of an IP-based country lookup.
             *     </ul>
             * </ul>
             */
            authenticateToSharedNote(guid: string, noteKey: string, cb: Callback<AuthenticationResult>): void;

            /**
             * Identify related entities on the service, such as notes,
             * notebooks, and tags related to notes or content.
             *
             * @param query
             *     The information about which we are finding related entities.
             *
             * @param resultSpec
             *     Allows the client to indicate the type and quantity of
             *     information to be returned, allowing a saving of time and
             *     bandwidth.
             *
             * @return
             *     The result of the query, with information considered
             *     to likely be relevantly related to the information
             *     described by the query.
             *
             * @throws EDAMUserException <ul>
             *     <li>BAD_DATA_FORMAT "RelatedQuery.plainText" - If you provided a
             *         a zero-length plain text value.
             *     </li>
             *     <li>BAD_DATA_FORMAT "RelatedQuery.noteGuid" - If you provided an
             *         invalid Note GUID, that is, one that does not match the constraints
             *         defined by EDAM_GUID_LEN_MIN, EDAM_GUID_LEN_MAX, EDAM_GUID_REGEX.
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
             *     </li>
             *     <li> BAD_DATA_FORMAT "NoteFilter.words" - if search string too long
             *     </li>
             *     <li>PERMISSION_DENIED "Note" - If the caller does not have access to
             *         the note identified by RelatedQuery.noteGuid.
             *     </li>
             *     <li>DATA_REQUIRED "RelatedResultSpec" - If you did not not set any values
             *         in the result spec.
             *     </li>
             * </ul>
             *
             * @throws EDAMNotFoundException <ul>
             *     <li>"RelatedQuery.noteGuid" - the note with that GUID is not
             *         found, if that field has been set in the query.
             *     </li>
             * </ul>
             */
            findRelated(query: RelatedQuery, resultSpec: RelatedResultSpec, cb: Callback<RelatedResult>): void;
        }
        /**
         *    This structure encapsulates the information about the state of the
         *    user's account for the purpose of "state based" synchronization.
         * <dl>
         *    <dt>currentTime</dt>
         *        <dd>
         *        The server's current date and time.
         *        </dd>
         *
         *    <dt>fullSyncBefore</dt>
         *        <dd>
         *        The cutoff date and time for client caches to be
         *        updated via incremental synchronization.    Any clients that were last
         *        synched with the server before this date/time must do a full resync of all
         *        objects.    This cutoff point will change over time as archival data is
         *        deleted or special circumstances on the service require resynchronization.
         *        </dd>
         *
         *    <dt>updateCount</dt>
         *        <dd>
         *        Indicates the total number of transactions that have
         *        been committed within the account.    This reflects (for example) the
         *        number of discrete additions or modifications that have been made to
         *        the data in this account (tags, notes, resources, etc.).
         *        This number is the "high water mark" for Update Sequence Numbers (USN)
         *        within the account.
         *        </dd>
         *
         *    <dt>uploaded</dt>
         *        <dd>
         *        The total number of bytes that have been uploaded to
         *        this account in the current monthly period.    This can be compared against
         *        Accounting.uploadLimit (from the UserStore) to determine how close the user
         *        is to their monthly upload limit.
         *        This value may not be present if the SyncState has been retrieved by
         *        a caller that only has read access to the account.
         *        </dd>
         *    </dl>
         */
        class SyncState {
            currentTime: number;
            fullSyncBefore: number;
            updateCount: number;
            uploaded: number;

            constructor(args?: { currentTime: number; fullSyncBefore: number; updateCount: number; uploaded?: number; });
        }

        /**
         *    This structure is given out by the NoteStore when a client asks to
         *    receive the current state of an account.    The client asks for the server's
         *    state one chunk at a time in order to allow clients to retrieve the state
         *    of a large account without needing to transfer the entire account in
         *    a single message.
         *
         *    The server always gives SyncChunks using an ascending series of Update
         *    Sequence Numbers (USNs).
         *
         * <dl>
         *    <dt>currentTime</dt>
         *        <dd>
         *        The server's current date and time.
         *        </dd>
         *
         *    <dt>chunkHighUSN</dt>
         *        <dd>
         *        The highest USN for any of the data objects represented
         *        in this sync chunk.    If there are no objects in the chunk, this will not be
         *        set.
         *        </dd>
         *
         *    <dt>updateCount</dt>
         *        <dd>
         *        The total number of updates that have been performed in
         *        the service for this account.    This is equal to the highest USN within the
         *        account at the point that this SyncChunk was generated.    If updateCount
         *        and chunkHighUSN are identical, that means that this is the last chunk
         *        in the account ... there is no more recent information.
         *        </dd>
         *
         *    <dt>notes</dt>
         *        <dd>
         *        If present, this is a list of non-expunged notes that
         *        have a USN in this chunk.    This will include notes that are "deleted"
         *        but not expunged (i.e. in the trash).    The notes will include their list
         *        of tags and resources, but the note content, resource content, resource
         *        recognition data and resource alternate data will not be supplied.
         *        </dd>
         *
         *    <dt>notebooks</dt>
         *        <dd>
         *        If present, this is a list of non-expunged notebooks that
         *        have a USN in this chunk.    This will include notebooks that are "deleted"
         *        but not expunged (i.e. in the trash).
         *        </dd>
         *
         *    <dt>tags</dt>
         *        <dd>
         *        If present, this is a list of the non-expunged tags that have a
         *        USN in this chunk.
         *        </dd>
         *
         *    <dt>searches</dt>
         *        <dd>
         *        If present, this is a list of non-expunged searches that
         *        have a USN in this chunk.
         *        </dd>
         *
         *    <dt>resources</dt>
         *        <dd>
         *        If present, this is a list of the non-expunged resources
         *        that have a USN in this chunk.    This will include the metadata for each
         *        resource, but not its binary contents or recognition data, which must be
         *        retrieved separately.
         *        </dd>
         *
         *    <dt>expungedNotes</dt>
         *        <dd>
         *        If present, the GUIDs of all of the notes that were
         *        permanently expunged in this chunk.
         *        </dd>
         *
         *    <dt>expungedNotebooks</dt>
         *        <dd>
         *        If present, the GUIDs of all of the notebooks that
         *        were permanently expunged in this chunk.    When a notebook is expunged,
         *        this implies that all of its child notes (and their resources) were
         *        also expunged.
         *        </dd>
         *
         *    <dt>expungedTags</dt>
         *        <dd>
         *        If present, the GUIDs of all of the tags that were
         *        permanently expunged in this chunk.
         *        </dd>
         *
         *    <dt>expungedSearches</dt>
         *        <dd>
         *        If present, the GUIDs of all of the saved searches
         *        that were permanently expunged in this chunk.
         *        </dd>
         *
         *    <dt>linkedNotebooks</dt>
         *        <dd>
         *        If present, this is a list of non-expunged LinkedNotebooks that
         *        have a USN in this chunk.
         *        </dd>
         *
         *    <dt>expungedLinkedNotebooks</dt>
         *        <dd>
         *        If present, the GUIDs of all of the LinkedNotebooks
         *        that were permanently expunged in this chunk.
         *        </dd>
         *    </dl>
         */
        class SyncChunk {
            currentTime: number;
            chunkHighUSN: number;
            updateCount: number;
            notes: Note[];
            notebooks: Notebook[];
            tags: Tag[];
            searches: SavedSearch[];
            resources: Resource[];
            expungedNotes: string[];
            expungedNotebooks: string[];
            expungedTags: string[];
            expungedSearches: string[];
            linkedNotebooks: LinkedNotebook[];
            expungedLinkedNotebooks: string[];

            constructor(args?: { currentTime: number; chunkHighUSN?: number; updateCount: number; notes?: Note[]; notebooks?: Notebook[]; tags?: Tag[]; searches?: SavedSearch[]; resources?: Resource[]; expungedNotes?: string[]; expungedNotebooks?: string[]; expungedTags?: string[]; expungedSearches?: string[]; linkedNotebooks?: LinkedNotebook[]; expungedLinkedNotebooks?: string[]; });
        }

        /**
         *    This structure is used with the 'getFilteredSyncChunk' call to provide
         *    fine-grained control over the data that's returned when a client needs
         *    to synchronize with the service. Each flag in this structure specifies
         *    whether to include one class of data in the results of that call.
         *
         * <dl>
         *    <dt>includeNotes</dt>
         *        <dd>
         *        If true, then the server will include the SyncChunks.notes field
         *        </dd>
         *
         *    <dt>includeNoteResources</dt>
         *        <dd>
         *        If true, then the server will include the 'resources' field on all of
         *        the Notes that are in SyncChunk.notes.
         *        If 'includeNotes' is false, then this will have no effect.
         *        </dd>
         *
         *    <dt>includeNoteAttributes</dt>
         *        <dd>
         *        If true, then the server will include the 'attributes' field on all of
         *        the Notes that are in SyncChunks.notes.
         *        If 'includeNotes' is false, then this will have no effect.
         *        </dd>
         *
         *    <dt>includeNotebooks</dt>
         *        <dd>
         *        If true, then the server will include the SyncChunks.notebooks field
         *        </dd>
         *
         *    <dt>includeTags</dt>
         *        <dd>
         *        If true, then the server will include the SyncChunks.tags field
         *        </dd>
         *
         *    <dt>includeSearches</dt>
         *        <dd>
         *        If true, then the server will include the SyncChunks.searches field
         *        </dd>
         *
         *    <dt>includeResources</dt>
         *        <dd>
         *        If true, then the server will include the SyncChunks.resources field.
         *        Since the Resources are also provided with their Note
         *        (in the Notes.resources list), this is primarily useful for clients that
         *        want to watch for changes to individual Resources due to recognition data
         *        being added.
         *        </dd>
         *
         *    <dt>includeLinkedNotebooks</dt>
         *        <dd>
         *        If true, then the server will include the SyncChunks.linkedNotebooks field.
         *        </dd>
         *
         *    <dt>includeExpunged</dt>
         *        <dd>
         *        If true, then the server will include the 'expunged' data for any type
         *        of included data.    For example, if 'includeTags' and 'includeExpunged'
         *        are both true, then the SyncChunks.expungedTags field will be set with
         *        the GUIDs of tags that have been expunged from the server.
         *        </dd>
         *
         *    <dt>includeNoteApplicationDataFullMap</dt>
         *        <dd>
         *        If true, then the values for the applicationData map will be filled
         *        in, assuming notes and note attributes are being returned.    Otherwise,
         *        only the keysOnly field will be filled in.
         *        </dd>
         *
         *    <dt>includeResourceApplicationDataFullMap</dt>
         *        <dd>
         *        If true, then the fullMap values for the applicationData map will be
         *        filled in, assuming resources and resource attributes are being returned
         *        (includeResources is true).    Otherwise, only the keysOnly field will be
         *        filled in.
         *        </dd>
         *
         *    <dt>includeNoteResourceApplicationDataFullMap</dt>
         *        <dd>
         *        If true, then the fullMap values for the applicationData map will be
         *        filled in for resources found inside of notes, assuming resources are
         *        being returned in notes (includeNoteResources is true).    Otherwise,
         *        only the keysOnly field will be filled in.
         *        </dd>
         *
         *    <dt>requireNoteContentClass</dt>
         *        <dd>
         *        If set, then only send notes whose content class matches this value.
         *        The value can be a literal match or, if the last character is an
         *        asterisk, a prefix match.
         *        </dd>
         *    </dl>
         */
        class SyncChunkFilter {
            includeNotes: boolean;
            includeNoteResources: boolean;
            includeNoteAttributes: boolean;
            includeNotebooks: boolean;
            includeTags: boolean;
            includeSearches: boolean;
            includeResources: boolean;
            includeLinkedNotebooks: boolean;
            includeExpunged: boolean;
            includeNoteApplicationDataFullMap: boolean;
            includeResourceApplicationDataFullMap: boolean;
            includeNoteResourceApplicationDataFullMap: boolean;
            requireNoteContentClass: string;

            constructor(args?: { includeNotes?: boolean; includeNoteResources?: boolean; includeNoteAttributes?: boolean; includeNotebooks?: boolean; includeTags?: boolean; includeSearches?: boolean; includeResources?: boolean; includeLinkedNotebooks?: boolean; includeExpunged?: boolean; includeNoteApplicationDataFullMap?: boolean; includeResourceApplicationDataFullMap?: boolean; includeNoteResourceApplicationDataFullMap?: boolean; requireNoteContentClass?: string; });
        }

        /**
         *    A list of criteria that are used to indicate which notes are desired from
         *    the account.    This is used in queries to the NoteStore to determine
         *    which notes should be retrieved.
         *
         * <dl>
         *    <dt>order</dt>
         *        <dd>
         *        The NoteSortOrder value indicating what criterion should be
         *        used to sort the results of the filter.
         *        </dd>
         *
         *    <dt>ascending</dt>
         *        <dd>
         *        If true, the results will be ascending in the requested
         *        sort order.    If false, the results will be descending.
         *        </dd>
         *
         *    <dt>words</dt>
         *        <dd>
         *        If present, a search query string that will filter the set of notes to be returned.
         *        Accepts the full search grammar documented in the Evernote API Overview.
         *        </dd>
         *
         *    <dt>notebookGuid</dt>
         *        <dd>
         *        If present, the Guid of the notebook that must contain
         *        the notes.
         *        </dd>
         *
         *    <dt>tagGuids</dt>
         *        <dd>
         *        If present, the list of tags (by GUID) that must be present
         *        on the notes.
         *        </dd>
         *
         *    <dt>timeZone</dt>
         *        <dd>
         *        The zone ID for the user, which will be used to interpret
         *        any dates or times in the queries that do not include their desired zone
         *        information.
         *        For example, if a query requests notes created "yesterday", this
         *        will be evaluated from the provided time zone, if provided.
         *        The format must be encoded as a standard zone ID such as
         *        "America/Los_Angeles".
         *        </dd>
         *
         *    <dt>inactive</dt>
         *        <dd>
         *        If true, then only notes that are not active (i.e. notes in
         *        the Trash) will be returned. Otherwise, only active notes will be returned.
         *        There is no way to find both active and inactive notes in a single query.
         *        </dd>
         *
         *    <dt>emphasized</dt>
         *        <dd>
         *        If present, a search query string that may or may not influence the notes
         *        to be returned, both in terms of coverage as well as of order. Think of it
         *        as a wish list, not a requirement.
         *        Accepts the full search grammar documented in the Evernote API Overview.
         *        </dd>
         *    </dl>
         */
        class NoteFilter {
            order: number;
            ascending: boolean;
            words: string;
            notebookGuid: string;
            tagGuids: string[];
            timeZone: string;
            inactive: boolean;
            emphasized: string;

            constructor(args?: { order?: number; ascending?: boolean; words?: string; notebookGuid?: string; tagGuids?: string[]; timeZone?: string; inactive?: boolean; emphasized?: string; });
        }

        /**
         *    A small structure for returning a list of notes out of a larger set.
         *
         * <dl>
         *    <dt>startIndex</dt>
         *        <dd>
         *        The starting index within the overall set of notes.    This
         *        is also the number of notes that are "before" this list in the set.
         *        </dd>
         *
         *    <dt>totalNotes</dt>
         *        <dd>
         *        The number of notes in the larger set.    This can be used
         *        to calculate how many notes are "after" this note in the set.
         *        (I.e.    remaining = totalNotes - (startIndex + notes.length)    )
         *        </dd>
         *
         *    <dt>notes</dt>
         *        <dd>
         *        The list of notes from this range.    The Notes will include all
         *        metadata (attributes, resources, etc.), but will not include the ENML
         *        content of the note or the binary contents of any resources.
         *        </dd>
         *
         *    <dt>stoppedWords</dt>
         *        <dd>
         *        If the NoteList was produced using a text based search
         *        query that included words that are not indexed or searched by the service,
         *        this will include a list of those ignored words.
         *        </dd>
         *
         *    <dt>searchedWords</dt>
         *        <dd>
         *        If the NoteList was produced using a text based search
         *        query that included viable search words or quoted expressions, this will
         *        include a list of those words.    Any stopped words will not be included
         *        in this list.
         *        </dd>
         *
         *    <dt>updateCount</dt>
         *        <dd>
         *        Indicates the total number of transactions that have
         *        been committed within the account.    This reflects (for example) the
         *        number of discrete additions or modifications that have been made to
         *        the data in this account (tags, notes, resources, etc.).
         *        This number is the "high water mark" for Update Sequence Numbers (USN)
         *        within the account.
         *        </dd>
         *    </dl>
         */
        class NoteList {
            startIndex: number;
            totalNotes: number;
            notes: Note[];
            stoppedWords: string[];
            searchedWords: string[];
            updateCount: number;

            constructor(args?: { startIndex: number; totalNotes: number; notes: Note[]; stoppedWords?: string[]; searchedWords?: string[]; updateCount?: number; });
        }

        /**
         * This structure is used in the set of results returned by the
         * findNotesMetadata function.    It represents the high-level information about
         * a single Note, without some of the larger deep structure.    This allows
         * for the information about a list of Notes to be returned relatively quickly
         * with less marshalling and data transfer to remote clients.
         * Most fields in this structure are identical to the corresponding field in
         * the Note structure, with the exception of:
         *
         * <dl>
         * <dt>largestResourceMime</dt>
         *     <dd>If set, then this will contain the MIME type of the largest Resource
         *     (in bytes) within the Note.    This may be useful, for example, to choose
         *     an appropriate icon or thumbnail to represent the Note.
         *     </dd>
         *
         * <dt>largestResourceSize</dt>
         *    <dd>If set, this will contain the size of the largest Resource file, in
         *    bytes, within the Note.    This may be useful, for example, to decide whether
         *    to ask the server for a thumbnail to represent the Note.
         *    </dd>
         * </dl>
         */
        class NoteMetadata {
            guid: string;
            title: string;
            contentLength: number;
            created: number;
            updated: number;
            deleted: number;
            updateSequenceNum: number;
            notebookGuid: string;
            tagGuids: string[];
            attributes: NoteAttributes;
            largestResourceMime: string;
            largestResourceSize: number;

            constructor(args?: { guid: string; title?: string; contentLength?: number; created?: number; updated?: number; deleted?: number; updateSequenceNum?: number; notebookGuid?: string; tagGuids?: string[]; attributes?: NoteAttributes; largestResourceMime?: string; largestResourceSize?: number; });
        }

        /**
         *    This structure is returned from calls to the findNotesMetadata function to
         *    give the high-level metadata about a subset of Notes that are found to
         *    match a specified NoteFilter in a search.
         *
         * <dl>
         *    <dt>startIndex</dt>
         *        <dd>
         *        The starting index within the overall set of notes.    This
         *        is also the number of notes that are "before" this list in the set.
         *        </dd>
         *
         *    <dt>totalNotes</dt>
         *        <dd>
         *        The number of notes in the larger set.    This can be used
         *        to calculate how many notes are "after" this note in the set.
         *        (I.e.    remaining = totalNotes - (startIndex + notes.length)    )
         *        </dd>
         *
         *    <dt>notes</dt>
         *        <dd>
         *        The list of metadata for Notes in this range.    The set of optional fields
         *        that are set in each metadata structure will depend on the
         *        NotesMetadataResultSpec provided by the caller when the search was
         *        performed.    Only the 'guid' field will be guaranteed to be set in each
         *        Note.
         *        </dd>
         *
         *    <dt>stoppedWords</dt>
         *        <dd>
         *        If the NoteList was produced using a text based search
         *        query that included words that are not indexed or searched by the service,
         *        this will include a list of those ignored words.
         *        </dd>
         *
         *    <dt>searchedWords</dt>
         *        <dd>
         *        If the NoteList was produced using a text based search
         *        query that included viable search words or quoted expressions, this will
         *        include a list of those words.    Any stopped words will not be included
         *        in this list.
         *        </dd>
         *
         *    <dt>updateCount</dt>
         *        <dd>
         *        Indicates the total number of transactions that have
         *        been committed within the account.    This reflects (for example) the
         *        number of discrete additions or modifications that have been made to
         *        the data in this account (tags, notes, resources, etc.).
         *        This number is the "high water mark" for Update Sequence Numbers (USN)
         *        within the account.
         *        </dd>
         *    </dl>
         */
        class NotesMetadataList {
            startIndex: number;
            totalNotes: number;
            notes: NoteMetadata[];
            stoppedWords: string[];
            searchedWords: string[];
            updateCount: number;

            constructor(args?: { startIndex: number; totalNotes: number; notes: NoteMetadata[]; stoppedWords?: string[]; searchedWords?: string[]; updateCount?: number; });
        }

        /**
         * This structure is provided to the findNotesMetadata function to specify
         * the subset of fields that should be included in each NoteMetadata element
         * that is returned in the NotesMetadataList.
         * Each field on this structure is a boolean flag that indicates whether the
         * corresponding field should be included in the NoteMetadata structure when
         * it is returned.    For example, if the 'includeTitle' field is set on this
         * structure when calling findNotesMetadata, then each NoteMetadata in the
         * list should have its 'title' field set.
         * If one of the fields in this spec is not set, then it will be treated as
         * 'false' by the server, so the default behavior is to include nothing in
         * replies (but the mandatory GUID)
         */
        class NotesMetadataResultSpec {
            includeTitle: boolean;
            includeContentLength: boolean;
            includeCreated: boolean;
            includeUpdated: boolean;
            includeDeleted: boolean;
            includeUpdateSequenceNum: boolean;
            includeNotebookGuid: boolean;
            includeTagGuids: boolean;
            includeAttributes: boolean;
            includeLargestResourceMime: boolean;
            includeLargestResourceSize: boolean;

            constructor(args?: { includeTitle?: boolean; includeContentLength?: boolean; includeCreated?: boolean; includeUpdated?: boolean; includeDeleted?: boolean; includeUpdateSequenceNum?: boolean; includeNotebookGuid?: boolean; includeTagGuids?: boolean; includeAttributes?: boolean; includeLargestResourceMime?: boolean; includeLargestResourceSize?: boolean; });
        }

        /**
         *    A data structure representing the number of notes for each notebook
         *    and tag with a non-zero set of applicable notes.
         *
         * <dl>
         *    <dt>notebookCounts</dt>
         *        <dd>
         *        A mapping from the Notebook GUID to the number of
         *        notes (from some selection) that are in the corresponding notebook.
         *        </dd>
         *
         *    <dt>tagCounts</dt>
         *        <dd>
         *        A mapping from the Tag GUID to the number of notes (from some
         *        selection) that have the corresponding tag.
         *        </dd>
         *
         *    <dt>trashCount</dt>
         *        <dd>
         *        If this is set, then this is the number of notes that are in the trash.
         *        If this is not set, then the number of notes in the trash hasn't been
         *        reported.    (I.e. if there are no notes in the trash, this will be set
         *        to 0.)
         *        </dd>
         *    </dl>
         */
        class NoteCollectionCounts {
            notebookCounts: { [k: string]: number; };
            tagCounts: { [k: string]: number; };
            trashCount: number;

            constructor(args?: { notebookCounts?: { [k: string]: number; }; tagCounts?: { [k: string]: number; }; trashCount?: number; });
        }

        /**
         * Parameters that must be given to the NoteStore emailNote call. These allow
         * the caller to specify the note to send, the recipient addresses, etc.
         *
         * <dl>
         *    <dt>guid</dt>
         *        <dd>
         *            If set, this must be the GUID of a note within the user's account that
         *            should be retrieved from the service and sent as email.    If not set,
         *            the 'note' field must be provided instead.
         *        </dd>
         *
         *    <dt>note</dt>
         *        <dd>
         *            If the 'guid' field is not set, this field must be provided, including
         *            the full contents of the note note (and all of its Resources) to send.
         *            This can be used for a Note that as not been created in the service,
         *            for example by a local client with local notes.
         *        </dd>
         *
         *    <dt>toAddresses</dt>
         *        <dd>
         *            If provided, this should contain a list of the SMTP email addresses
         *            that should be included in the "To:" line of the email.
         *            Callers must specify at least one "to" or "cc" email address.
         *        </dd>
         *
         *    <dt>ccAddresses</dt>
         *        <dd>
         *            If provided, this should contain a list of the SMTP email addresses
         *            that should be included in the "Cc:" line of the email.
         *            Callers must specify at least one "to" or "cc" email address.
         *        </dd>
         *
         *    <dt>subject</dt>
         *        <dd>
         *            If provided, this should contain the subject line of the email that
         *            will be sent.    If not provided, the title of the note will be used
         *            as the subject of the email.
         *        </dd>
         *
         *    <dt>message</dt>
         *        <dd>
         *            If provided, this is additional personal text that should be included
         *            into the email as a message from the owner to the recipient(s).
         *        </dd>
         * </dl>
         */
        class NoteEmailParameters {
            guid: string;
            note: Note;
            toAddresses: string[];
            ccAddresses: string[];
            subject: string;
            message: string;

            constructor(args?: { guid?: string; note?: Note; toAddresses?: string[]; ccAddresses?: string[]; subject?: string; message?: string; });
        }

        /**
         * Identifying information about previous versions of a note that are backed up
         * within Evernote's servers.    Used in the return value of the listNoteVersions
         * call.
         *
         * <dl>
         *    <dt>updateSequenceNum</dt>
         *    <dd>
         *        The update sequence number for the Note when it last had this content.
         *        This serves to uniquely identify each version of the note, since USN
         *        values are unique within an account for each update.
         *    </dd>
         *    <dt>updated</dt>
         *    <dd>
         *        The 'updated' time that was set on the Note when it had this version
         *        of the content.    This is the user-modifiable modification time on the
         *        note, so it's not reliable for guaranteeing the order of various
         *        versions.    (E.g. if someone modifies the note, then changes this time
         *        manually into the past and then updates the note again.)
         *    </dd>
         *    <dt>saved</dt>
         *    <dd>
         *        A timestamp that holds the date and time when this version of the note
         *        was backed up by Evernote's servers.    This
         *    </dd>
         *    <dt>title</dt>
         *    <dd>
         *        The title of the note when this particular version was saved.    (The
         *        current title of the note may differ from this value.)
         *    </dd>
         * </dl>
         */
        class NoteVersionId {
            updateSequenceNum: number;
            updated: number;
            saved: number;
            title: string;

            constructor(args?: { updateSequenceNum: number; updated: number; saved: number; title: string; });
        }

        /**
         * This structure is passed from clients to the Evernote service when they wish
         * to relay coarse-grained usage metrics to the service to help improve
         * products.
         *
         * <dl>
         *    <dt>sessions</dt>
         *    <dd>
         *        This field contains a count of the number of usage "sessions" that have
         *        occurred with this client which have not previously been reported to
         *        the service.
         *        A "session" is defined as one of the 96 fifteen-minute intervals of the
         *        day when someone used Evernote's interface at least once.
         *        So if a user interacts with an Evernote client at 12:18, 12:24, and 12:36,
         *        and then the client synchronizes at 12:39, it would report that there were
         *        two previously-unreported sessions (one session for the 12:15-12:30 time
         *        period, and one for the 12:30-12:45 period).
         *        If the user used Evernote again at 12:41 and synchronized at 12:43, it
         *        would not report any new sessions, because the 12:30-12:45 session had
         *        already been reported.
         *    </dd>
         * </dl>
         */
        class ClientUsageMetrics {
            sessions: number;

            constructor(args?: { sessions?: number; });
        }

        /**
         * A description of the thing for which we are searching for related
         * entities.
         *
         * You must specify either <em>noteGuid</em> or <em>plainText</em>, but
         * not both. <em>filter</em> and <em>referenceUri</em> are optional.
         *
         * <dl>
         * <dt>noteGuid</dt>
         * <dd>The GUID of an existing note in your account for which related
         *         entities will be found.</dd>
         *
         * <dt>plainText</dt>
         * <dd>A string of plain text for which to find related entities.
         *         You should provide a text block with a number of characters between
         *         EDAM_RELATED_PLAINTEXT_LEN_MIN and EDAM_RELATED_PLAINTEXT_LEN_MAX.
         *         </dd>
         *
         * <dt>filter</dt>
         * <dd>The list of criteria that will constrain the notes being considered
         *         related.
         *         Please note that some of the parameters may be ignored, such as
         *         <em>order</em> and <em>ascending</em>.
         * </dd>
         *
         * <dt>referenceUri</dt>
         * <dd>A URI string specifying a reference entity, around which "relatedness"
         *         should be based. This can be an URL pointing to a web page, for example.
         * </dd>
         * </dl>
         */
        class RelatedQuery {
            noteGuid: string;
            plainText: string;
            filter: NoteFilter;
            referenceUri: string;

            constructor(args?: { noteGuid?: string; plainText?: string; filter?: NoteFilter; referenceUri?: string; });
        }

        /**
         * The result of calling findRelated().    The contents of the notes,
         * notebooks, and tags fields will be in decreasing order of expected
         * relevance.    It is possible that fewer results than requested will be
         * returned even if there are enough distinct entities in the account
         * in cases where the relevance is estimated to be low.
         *
         * <dl>
         * <dt>notes</dt>
         * <dd>If notes have been requested to be included, this will be the
         *         list of notes.</dd>
         *
         * <dt>notebooks</dt>
         * <dd>If notebooks have been requested to be included, this will be the
         *         list of notebooks.</dd>
         *
         * <dt>tags</dt>
         * <dd>If tags have been requested to be included, this will be the list
         *         of tags.</dd>
         * </dl>
         *
         * <dt>containingNotebooks</dt>
         * <dd>If <code>includeContainingNotebooks</code> is set to <code>true</code>
         *         in the RelatedResultSpec, return the list of notebooks to
         *         to which the returned related notes belong. The notebooks in this
         *         list will occur once per notebook GUID and are represented as
         *         NotebookDescriptor objects.</dd>
         * </dl>
         * </dl>
         */
        class RelatedResult {
            notes: Note[];
            notebooks: Notebook[];
            tags: Tag[];
            containingNotebooks: NotebookDescriptor[];

            constructor(args?: { notes?: Note[]; notebooks?: Notebook[]; tags?: Tag[]; containingNotebooks?: NotebookDescriptor[]; });
        }

        /**
         * A description of the thing for which the service will find related
         * entities, via findRelated(), together with a description of what
         * type of entities and how many you are seeking in the
         * RelatedResult.
         *
         * <dl>
         * <dt>maxNotes</dt>
         * <dd>Return notes that are related to the query, but no more than
         *         this many.    Any value greater than EDAM_RELATED_MAX_NOTES
         *         will be silently capped.    If you do not set this field, then
         *         no notes will be returned.</dd>
         *
         * <dt>maxNotebooks</dt>
         * <dd>Return notebooks that are related to the query, but no more than
         *         this many.    Any value greater than EDAM_RELATED_MAX_NOTEBOOKS
         *         will be silently capped.    If you do not set this field, then
         *         no notebooks will be returned.</dd>
         *
         * <dt>maxTags</dt>
         * <dd>Return tags that are related to the query, but no more than
         *         this many.    Any value greater than EDAM_RELATED_MAX_TAGS
         *         will be silently capped.    If you do not set this field, then
         *         no tags will be returned.</dd>
         * </dl>
         *
         * <dt>writableNotebooksOnly</dt>
         * <dd>Require that all returned related notebooks are writable.
         *         The user will be able to create notes in all returned notebooks.
         *         However, individual notes returned may still belong to notebooks
         *         in which the user lacks the ability to create notes.</dd>
         * </dl>
         *
         * <dt>includeContainingNotebooks</dt>
         * <dd>If set to <code>true</code>, return the containingNotebooks field
         *         in the RelatedResult, which will contain the list of notebooks to
         *         to which the returned related notes belong.</dd>
         * </dl>
         * </dl>
         */
        class RelatedResultSpec {
            maxNotes: number;
            maxNotebooks: number;
            maxTags: number;
            writableNotebooksOnly: boolean;
            includeContainingNotebooks: boolean;

            constructor(args?: { maxNotes?: number; maxNotebooks?: number; maxTags?: number; writableNotebooksOnly?: boolean; includeContainingNotebooks?: boolean; });
        }
        /**
         * This enumeration defines the possible permission levels for a user.
         * Free accounts will have a level of NORMAL and paid Premium accounts
         * will have a level of PREMIUM.
         */
        enum PrivilegeLevel {
            'NORMAL' = 1,
            'PREMIUM' = 3,
            'VIP' = 5,
            'MANAGER' = 7,
            'SUPPORT' = 8,
            'ADMIN' = 9,
        }

        /**
         * Every search query is specified as a sequence of characters.
         * Currently, only the USER query format is supported.
         */
        enum QueryFormat {
            'USER' = 1,
            'SEXP' = 2,
        }

        /**
         * This enumeration defines the possible sort ordering for notes when
         * they are returned from a search result.
         */
        enum NoteSortOrder {
            'CREATED' = 1,
            'UPDATED' = 2,
            'RELEVANCE' = 3,
            'UPDATE_SEQUENCE_NUMBER' = 4,
            'TITLE' = 5,
        }

        /**
         * This enumeration defines the possible states of a premium account
         *
         * NONE:        the user has never attempted to become a premium subscriber
         *
         * PENDING: the user has requested a premium account but their charge has not
         *     been confirmed
         *
         * ACTIVE:    the user has been charged and their premium account is in good
         *    standing
         *
         * FAILED:    the system attempted to charge the was denied. Their premium
         *     privileges have been revoked. We will periodically attempt to re-validate
         *     their order.
         *
         * CANCELLATION_PENDING: the user has requested that no further charges be made
         *     but the current account is still active.
         *
         * CANCELED: the premium account was canceled either because of failure to pay
         *     or user cancelation. No more attempts will be made to activate the account.
         */
        enum PremiumOrderStatus {
            'NONE' = 0,
            'PENDING' = 1,
            'ACTIVE' = 2,
            'FAILED' = 3,
            'CANCELLATION_PENDING' = 4,
            'CANCELED' = 5,
        }

        /**
         * Privilege levels for accessing shared notebooks.
         *
         * READ_NOTEBOOK: Recipient is able to read the contents of the shared notebook
         *     but does to have access to information about other recipients of the
         *     notebook or the activity stream information.
         *
         * MODIFY_NOTEBOOK_PLUS_ACTIVITY: Recipient has rights to read and modify the contents
         *     of the shared notebook, including the right to move notes to the trash and to create
         *     notes in the notebook.    The recipient can also access information about other
         *     recipients and the activity stream.
         *
         * READ_NOTEBOOK_PLUS_ACTIVITY: Recipient has READ_NOTEBOOK rights and can also
         *     access information about other recipients and the activity stream.
         *
         * GROUP: If the user belongs to a group, such as a Business, that has a defined
         *     privilege level, use the privilege level of the group as the privilege for
         *     the individual.
         *
         * FULL_ACCESS: Recipient has full rights to the shared notebook and recipient lists,
         *     including privilege to revoke and create invitations and to change privilege
         *     levels on invitations for individuals.    This privilege level is primarily intended
         *     for use by individual shares.
         *
         * BUSINESS_FULL_ACCESS: Intended for use with Business Notebooks, a
         * BUSINESS_FULL_ACCESS level is FULL_ACCESS with the additional rights to
         * change how the notebook will appear in the business library, including the
         * rights to publish and unpublish the notebook from the library.
         */
        enum SharedNotebookPrivilegeLevel {
            'READ_NOTEBOOK' = 0,
            'MODIFY_NOTEBOOK_PLUS_ACTIVITY' = 1,
            'READ_NOTEBOOK_PLUS_ACTIVITY' = 2,
            'GROUP' = 3,
            'FULL_ACCESS' = 4,
            'BUSINESS_FULL_ACCESS' = 5,
        }

        /**
         * Enumeration of the roles that a User can have within a sponsored group.
         *
         * GROUP_MEMBER: The user is a member of the group with no special privileges.
         *
         * GROUP_ADMIN: The user is an administrator within the group.
         *
         * GROUP_OWNER: The user is the owner of the group.
         */
        enum SponsoredGroupRole {
            'GROUP_MEMBER' = 1,
            'GROUP_ADMIN' = 2,
            'GROUP_OWNER' = 3,
        }

        /**
         * Enumeration of the roles that a User can have within an Evernote Business account.
         *
         * ADMIN: The user is an administrator of the Evernote Business account.
         *
         * NORMAL: The user is a regular user within the Evernote Business account.
         */
        enum BusinessUserRole {
            'ADMIN' = 1,
            'NORMAL' = 2,
        }

        /**
         * An enumeration describing restrictions on the domain of shared notebook
         * instances that are valid for a given operation, as used, for example, in
         * NotebookRestrictions.
         *
         * ONLY_JOINED_OR_PREVIEW: The domain consists of shared notebooks that
         *     "belong" to the recipient or still available for preview by any recipient.
         *     Shared notebooks that the recipient has joined (the username has already been
         *     assigned to our user) are in the domain.    Additionally, shared notebooks
         *     that allow preview and have not yet been joined are in the domain.
         *
         * NO_SHARED_NOTEBOOKS: No shared notebooks are applicable to the operation.
         */
        enum SharedNotebookInstanceRestrictions {
            'ONLY_JOINED_OR_PREVIEW' = 1,
            'NO_SHARED_NOTEBOOKS' = 2,
        }

        /**
         * An enumeration describing the configuration state related to receiving
         * reminder e-mails from the service.    Reminder e-mails summarize notes
         * based on their Note.attributes.reminderTime values.
         *
         * DO_NOT_SEND: The user has selected to not receive reminder e-mail.
         *
         * SEND_DAILY_EMAIL: The user has selected to receive reminder e-mail for those
         *     days when there is a reminder.
         */
        enum ReminderEmailConfig {
            'DO_NOT_SEND' = 1,
            'SEND_DAILY_EMAIL' = 2,
        }

        /**
         *    In several places, EDAM exchanges blocks of bytes of data for a component
         *    which may be relatively large.    For example:    the contents of a clipped
         *    HTML note, the bytes of an embedded image, or the recognition XML for
         *    a large image.    This structure is used in the protocol to represent
         *    any of those large blocks of data when they are transmitted or when
         *    they are only referenced their metadata.
         *
         * <dl>
         *    <dt>bodyHash</dt>
         *        <dd>This field carries a one-way hash of the contents of the
         *        data body, in binary form.    The hash function is MD5<br/>
         *        Length:    EDAM_HASH_LEN (exactly)
         *        </dd>
         *
         *    <dt>size</dt>
         *        <dd>The length, in bytes, of the data body.
         *        </dd>
         *
         *    <dt>body</dt>
         *        <dd>This field is set to contain the binary contents of the data
         *        whenever the resource is being transferred.    If only metadata is
         *        being exchanged, this field will be empty.    For example, a client could
         *        notify the service about the change to an attribute for a resource
         *        without transmitting the binary resource contents.
         *        </dd>
         *    </dl>
         */
        class Data {
            bodyHash: string;
            size: number;
            body: string;

            constructor(args?: { bodyHash?: string; size?: number; body?: string; });
        }

        /**
         *    A structure holding the optional attributes that can be stored
         *    on a User.    These are generally less critical than the core User fields.
         *
         * <dl>
         *    <dt>defaultLocationName</dt>
         *        <dd>the location string that should be associated
         *        with the user in order to determine where notes are taken if not otherwise
         *        specified.<br/>
         *        Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *        </dd>
         *
         *    <dt>defaultLatitude</dt>
         *        <dd>if set, this is the latitude that should be
         *        assigned to any notes that have no other latitude information.
         *        </dd>
         *
         *    <dt>defaultLongitude</dt>
         *        <dd>if set, this is the longitude that should be
         *        assigned to any notes that have no other longitude information.
         *        </dd>
         *
         *    <dt>preactivation</dt>
         *        <dd>if set, the user account is not yet confirmed for
         *        login.    I.e. the account has been created, but we are still waiting for
         *        the user to complete the activation step.
         *        </dd>
         *
         *    <dt>viewedPromotions</dt>
         *        <dd>a list of promotions the user has seen.
         *         This list may occasionally be modified by the system when promotions are
         *         no longer available.<br/>
         *         Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *        </dd>
         *
         *    <dt>incomingEmailAddress</dt>
         *        <dd>if set, this is the email address that the
         *         user may send email to in order to add an email note directly into the
         *         account via the SMTP email gateway.    This is the part of the email
         *         address before the '@' symbol ... our domain is not included.
         *         If this is not set, the user may not add notes via the gateway.<br/>
         *         Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *        </dd>
         *
         *    <dt>recentMailedAddresses</dt>
         *        <dd>if set, this will contain a list of email
         *         addresses that have recently been used as recipients
         *         of outbound emails by the user.    This can be used to pre-populate a
         *         list of possible destinations when a user wishes to send a note via
         *         email.<br/>
         *         Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX each<br/>
         *         Max:    EDAM_USER_RECENT_MAILED_ADDRESSES_MAX entries
         *        </dd>
         *
         *    <dt>comments</dt>
         *        <dd>Free-form text field that may hold general support
         *         information, etc.<br/>
         *         Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *        </dd>
         *
         *    <dt>dateAgreedToTermsOfService</dt>
         *        <dd>The date/time when the user agreed to
         *         the terms of service.    This can be used as the effective "start date"
         *         for the account.
         *        </dd>
         *
         *    <dt>maxReferrals</dt>
         *        <dd>The number of referrals that the user is permitted
         *         to make.
         *        </dd>
         *
         *    <dt>referralCount</dt>
         *        <dd>The number of referrals sent from this account.
         *        </dd>
         *
         *    <dt>refererCode</dt>
         *        <dd>A code indicating where the user was sent from. AKA
         *         promotion code
         *        </dd>
         *
         *    <dt>sentEmailDate</dt>
         *        <dd>The most recent date when the user sent outbound
         *         emails from the service.    Used with sentEmailCount to limit the number
         *         of emails that can be sent per day.
         *        </dd>
         *
         *    <dt>sentEmailCount</dt>
         *        <dd>The number of emails that were sent from the user
         *         via the service on sentEmailDate.    Used to enforce a limit on the number
         *         of emails per user per day to prevent spamming.
         *        </dd>
         *
         *    <dt>dailyEmailLimit</dt>
         *        <dd>If set, this is the maximum number of emails that
         *         may be sent in a given day from this account.    If unset, the server will
         *         use the configured default limit.
         *        </dd>
         *
         *    <dt>emailOptOutDate</dt>
         *        <dd>If set, this is the date when the user asked
         *         to be excluded from offers and promotions sent by Evernote.    If not set,
         *         then the user currently agrees to receive these messages.
         *        </dd>
         *
         *    <dt>partnerEmailOptInDate</dt>
         *        <dd>If set, this is the date when the user asked
         *         to be included in offers and promotions sent by Evernote's partners.
         *         If not sent, then the user currently does not agree to receive these
         *         emails.
         *        </dd>
         *
         *    <dt>preferredLanguage</dt>
         *        <dd>a 2 character language codes based on:
         *                http://ftp.ics.uci.edu/pub/ietf/http/related/iso639.txt used for
         *             localization purposes to determine what language to use for the web
         *             interface and for other direct communication (e.g. emails).
         *        </dd>
         *
         *    <dt>preferredCountry</dt>
         *        <dd>Preferred country code based on ISO 3166-1-alpha-2 indicating the
         *        users preferred country</dd>
         *
         *    <dt>clipFullPage</dt>
         *        <dd>Boolean flag set to true if the user wants to clip full pages by
         *        default when they use the web clipper without a selection.</dd>
         *
         *    <dt>twitterUserName</dt>
         *        <dd>The username of the account of someone who has chosen to enable
         *        Twittering into Evernote.    This value is subject to change, since users
         *        may change their Twitter user name.</dd>
         *
         *    <dt>twitterId</dt>
         *        <dd>The unique identifier of the user's Twitter account if that user
         *        has chosen to enable Twittering into Evernote.</dd>
         *
         *    <dt>groupName</dt>
         *        <dd>A name identifier used to identify a particular set of branding and
         *         light customization.</dd>
         *
         *    <dt>recognitionLanguage</dt>
         *        <dd>a 2 character language codes based on:
         *                http://ftp.ics.uci.edu/pub/ietf/http/related/iso639.txt
         *                If set, this is used to determine the language that should be used
         *                when processing images and PDF files to find text.
         *                If not set, then the 'preferredLanguage' will be used.
         *        </dd>
         *
         *    <dt>educationalInstitution</dt>
         *        <dd>a flag indicating that the user is part of an educational institution which
         *        makes them eligible for discounts on bulk purchases
         *        </dd>
         *
         *    <dt>businessAddress</dt>
         *        <dd>A string recording the business address of a Sponsored Account user who has requested invoicing.
         *        </dd>
         *
         *    <dt>hideSponsorBilling</dt>
         *        <dd>A flag indicating whether to hide the billing information on a sponsored
         *                account owner's settings page
         *        </dd>
         *
         *    <dt>taxExempt</dt>
         *        <dd>A flag indicating the user's sponsored group is exempt from sale tax
         *        </dd>
         *
         *    <dt>useEmailAutoFiling</dt>
         *        <dd>A flag indicating whether the user chooses to allow Evernote to automatically
         *                file and tag emailed notes
         *        </dd>
         *
         *    <dt>reminderEmailConfig</dt>
         *        <dd>Configuration state for whether or not the user wishes to receive
         *                reminder e-mail.    This setting applies to both the reminder e-mail sent
         *                for personal reminder notes and for the reminder e-mail sent for reminder
         *                notes in the user's business notebooks that the user has configured for
         *                e-mail notifications.
         *        </dd>
         *    </dl>
         */
        class UserAttributes {
            defaultLocationName: string;
            defaultLatitude: number;
            defaultLongitude: number;
            preactivation: boolean;
            viewedPromotions: string[];
            incomingEmailAddress: string;
            recentMailedAddresses: string[];
            comments: string;
            dateAgreedToTermsOfService: number;
            maxReferrals: number;
            referralCount: number;
            refererCode: string;
            sentEmailDate: number;
            sentEmailCount: number;
            dailyEmailLimit: number;
            emailOptOutDate: number;
            partnerEmailOptInDate: number;
            preferredLanguage: string;
            preferredCountry: string;
            clipFullPage: boolean;
            twitterUserName: string;
            twitterId: string;
            groupName: string;
            recognitionLanguage: string;
            referralProof: string;
            educationalDiscount: boolean;
            businessAddress: string;
            hideSponsorBilling: boolean;
            taxExempt: boolean;
            useEmailAutoFiling: boolean;
            reminderEmailConfig: ReminderEmailConfig;

            constructor(args?: { defaultLocationName?: string; defaultLatitude?: number; defaultLongitude?: number; preactivation?: boolean; viewedPromotions?: string[]; incomingEmailAddress?: string; recentMailedAddresses?: string[]; comments?: string; dateAgreedToTermsOfService?: number; maxReferrals?: number; referralCount?: number; refererCode?: string; sentEmailDate?: number; sentEmailCount?: number; dailyEmailLimit?: number; emailOptOutDate?: number; partnerEmailOptInDate?: number; preferredLanguage?: string; preferredCountry?: string; clipFullPage?: boolean; twitterUserName?: string; twitterId?: string; groupName?: string; recognitionLanguage?: string; referralProof?: string; educationalDiscount?: boolean; businessAddress?: string; hideSponsorBilling?: boolean; taxExempt?: boolean; useEmailAutoFiling?: boolean; reminderEmailConfig?: ReminderEmailConfig; });
        }

        /**
         *    This represents the bookkeeping information for the user's subscription.
         *
         * <dl>
         *    <dt>uploadLimit</dt>
         *        <dd>The number of bytes that can be uploaded to the account
         *        in the current month.    For new notes that are created, this is the length
         *        of the note content (in Unicode characters) plus the size of each resource
         *        (in bytes).    For edited notes, this is the the difference between the old
         *        length and the new length (if this is greater than 0) plus the size of
         *        each new resource.
         *        </dd>
         *    <dt>uploadLimitEnd</dt>
         *        <dd>The date and time when the current upload limit
         *        expires.    At this time, the monthly upload count reverts to 0 and a new
         *        limit is imposed.    This date and time is exclusive, so this is effectively
         *        the start of the new month.
         *        </dd>
         *    <dt>uploadLimitNextMonth</dt>
         *        <dd> When uploadLimitEnd is reached, the service
         *        will change uploadLimit to uploadLimitNextMonth. If a premium account is
         *        canceled, this mechanism will reset the quota appropriately.
         *        </dd>
         *    <dt>premiumServiceStatus</dt>
         *        <dd>Indicates the phases of a premium account
         *        during the billing process.
         *        </dd>
         *    <dt>premiumOrderNumber</dt>
         *        <dd>The order number used by the commerce system to
         *        process recurring payments
         *        </dd>
         *    <dt>premiumServiceStart</dt>
         *        <dd>The start date when this premium promotion
         *        began (this number will get overwritten if a premium service is canceled
         *        and then re-activated).
         *        </dd>
         *    <dt>premiumCommerceService</dt>
         *        <dd>The commerce system used (paypal, Google
         *        checkout, etc)
         *        </dd>
         *    <dt>premiumServiceSKU</dt>
         *        <dd>The code associated with the purchase eg. monthly
         *        or annual purchase. Clients should interpret this value and localize it.
         *        </dd>
         *    <dt>lastSuccessfulCharge</dt>
         *        <dd>Date the last time the user was charged.
         *        Null if never charged.
         *        </dd>
         *    <dt>lastFailedCharge</dt>
         *        <dd>Date the last time a charge was attempted and
         *        failed.
         *        </dd>
         *    <dt>lastFailedChargeReason</dt>
         *        <dd>Reason provided for the charge failure
         *        </dd>
         *    <dt>nextPaymentDue</dt>
         *        <dd>The end of the billing cycle. This could be in the
         *        past if there are failed charges.
         *        </dd>
         *    <dt>premiumLockUntil</dt>
         *        <dd>An internal variable to manage locking operations
         *        on the commerce variables.
         *        </dd>
         *    <dt>updated</dt>
         *        <dd>The date any modification where made to this record.
         *        </dd>
         *    <dt>premiumSubscriptionNumber</dt>
         *        <dd>The number number identifying the
         *        recurring subscription used to make the recurring charges.
         *        </dd>
         *    <dt>lastRequestedCharge</dt>
         *        <dd>Date charge last attempted</dd>
         *    <dt>currency</dt>
         *        <dd>ISO 4217 currency code</dd>
         *    <dt>unitPrice</dt>
         *        <dd>charge in the smallest unit of the currency (e.g. cents for USD)</dd>
         *    <dt>businessId</dt>
         *        <dd><i>DEPRECATED:</i>See BusinessUserInfo.</dd>
         *    <dt>businessName</dt>
         *        <dd><i>DEPRECATED:</i>See BusinessUserInfo.</dd>
         *    <dt>businessRole</dt>
         *        <dd><i>DEPRECATED:</i>See BusinessUserInfo.</dd>
         *    <dt>unitDiscount</dt>
         *        <dd>discount per seat in negative amount and smallest unit of the currency (e.g. cents for USD)</dd>
         *    <dt>nextChargeDate</dt>
         *        <dd>The next time the user will be charged, may or may not be the same as nextPaymentDue</dd>
         *    </dl>
         */
        class Accounting {
            uploadLimit: number;
            uploadLimitEnd: number;
            uploadLimitNextMonth: number;
            premiumServiceStatus: PremiumOrderStatus;
            premiumOrderNumber: string;
            premiumCommerceService: string;
            premiumServiceStart: number;
            premiumServiceSKU: string;
            lastSuccessfulCharge: number;
            lastFailedCharge: number;
            lastFailedChargeReason: string;
            nextPaymentDue: number;
            premiumLockUntil: number;
            updated: number;
            premiumSubscriptionNumber: string;
            lastRequestedCharge: number;
            currency: string;
            unitPrice: number;
            businessId: number;
            businessName: string;
            businessRole: BusinessUserRole;
            unitDiscount: number;
            nextChargeDate: number;

            constructor(args?: { uploadLimit?: number; uploadLimitEnd?: number; uploadLimitNextMonth?: number; premiumServiceStatus?: PremiumOrderStatus; premiumOrderNumber?: string; premiumCommerceService?: string; premiumServiceStart?: number; premiumServiceSKU?: string; lastSuccessfulCharge?: number; lastFailedCharge?: number; lastFailedChargeReason?: string; nextPaymentDue?: number; premiumLockUntil?: number; updated?: number; premiumSubscriptionNumber?: string; lastRequestedCharge?: number; currency?: string; unitPrice?: number; businessId?: number; businessName?: string; businessRole?: BusinessUserRole; unitDiscount?: number; nextChargeDate?: number; });
        }

        /**
         * This structure is used to provide information about an Evernote Business
         * membership, for members who are part of a business.
         *
         * <dl>
         * <dt>businessId</dt>
         *     <dd>The ID of the Evernote Business account that the user is a member of.
         * <dt>businessName</dt>
         *     <dd>The human-readable name of the Evernote Business account that the user
         *             is a member of.</dd>
         * <dt>role</dt>
         *     <dd>The role of the user within the Evernote Business account that
         *             they are a member of.</dd>
         * <dt>email</dt>
         *     <dd>An e-mail address that will be used by the service in the context of your
         *             Evernote Business activities.    For example, this e-mail address will be used
         *             when you e-mail a business note, when you update notes in the account of
         *             your business, etc.    The business e-mail cannot be used for identification
         *             purposes such as for logging into the service.
         *     </dd>
         * </dl>
         */
        class BusinessUserInfo {
            businessId: number;
            businessName: string;
            role: BusinessUserRole;
            email: string;

            constructor(args?: { businessId?: number; businessName?: string; role?: BusinessUserRole; email?: string; });
        }

        /**
         *    This structure is used to provide information about a user's Premium account.
         * <dl>
         *    <dt>currentTime</dt>
         *        <dd>
         *        The server-side date and time when this data was generated.
         *        </dd>
         *    <dt>premium</dt>
         *        <dd>
         *        True if the user's account is Premium.
         *        </dd>
         *    <dt>premiumRecurring</dt>
         *        <dd>
         *        True if the user's account is Premium and has a recurring payment method.
         *        </dd>
         *    <dt>premiumExpirationDate</dt>
         *        <dd>
         *        The date when the user's Premium account expires, or the date when the
         *        user's account is due for payment if it has a recurring payment method.
         *        </dd>
         *    <dt>premiumExtendable</dt>
         *        <dd>
         *        True if the user is eligible for purchasing Premium account extensions.
         *        </dd>
         *    <dt>premiumPending</dt>
         *        <dd>
         *        True if the user's Premium account is pending payment confirmation
         *        </dd>
         *    <dt>premiumCancellationPending</dt>
         *        <dd>
         *        True if the user has requested that no further charges to be made; the
         *        Premium account will remain active until it expires.
         *        </dd>
         *    <dt>canPurchaseUploadAllowance</dt>
         *        <dd>
         *        True if the user is eligible for purchasing additional upload allowance.
         *        </dd>
         *    <dt>sponsoredGroupName</dt>
         *        <dd>
         *        The name of the sponsored group that the user is part of.
         *        </dd>
         *    <dt>sponsoredGroupRole</dt>
         *        <dd>
         *        DEPRECATED - will be removed in a future update.
         *        </dd>
         *    <dt>premiumUpgradable</dt>
         *        <dd>
         *        True if the user is eligible for purchasing Premium account upgrade.
         *        </dd>
         *    </dl>
         */
        class PremiumInfo {
            currentTime: number;
            premium: boolean;
            premiumRecurring: boolean;
            premiumExpirationDate: number;
            premiumExtendable: boolean;
            premiumPending: boolean;
            premiumCancellationPending: boolean;
            canPurchaseUploadAllowance: boolean;
            sponsoredGroupName: string;
            sponsoredGroupRole: SponsoredGroupRole;
            premiumUpgradable: boolean;

            constructor(args?: { currentTime: number; premium: boolean; premiumRecurring: boolean; premiumExpirationDate?: number; premiumExtendable: boolean; premiumPending: boolean; premiumCancellationPending: boolean; canPurchaseUploadAllowance: boolean; sponsoredGroupName?: string; sponsoredGroupRole?: SponsoredGroupRole; premiumUpgradable?: boolean; });
        }

        /**
         *    This represents the information about a single user account.
         * <dl>
         *    <dt>id</dt>
         *        <dd>The unique numeric identifier for the account, which will not
         *        change for the lifetime of the account.
         *        </dd>
         *
         *    <dt>username</dt>
         *        <dd>The name that uniquely identifies a single user account. This name
         *        may be presented by the user, along with their password, to log into
         *        their account.
         *        May only contain a-z, 0-9, or '-', and may not start or end with the '-'
         *        <br/>
         *        Length:    EDAM_USER_USERNAME_LEN_MIN - EDAM_USER_USERNAME_LEN_MAX
         *        <br/>
         *        Regex:    EDAM_USER_USERNAME_REGEX
         *        </dd>
         *
         *    <dt>email</dt>
         *        <dd>The email address registered for the user.    Must comply with
         *        RFC 2821 and RFC 2822.<br/>
         *        Third party applications that authenticate using OAuth do not have
         *        access to this field.
         *        Length:    EDAM_EMAIL_LEN_MIN - EDAM_EMAIL_LEN_MAX
         *        <br/>
         *        Regex:    EDAM_EMAIL_REGEX
         *        </dd>
         *
         *    <dt>name</dt>
         *        <dd>The printable name of the user, which may be a combination
         *        of given and family names.    This is used instead of separate "first"
         *        and "last" names due to variations in international name format/order.
         *        May not start or end with a whitespace character.    May contain any
         *        character but carriage return or newline (Unicode classes Zl and Zp).
         *        <br/>
         *        Length:    EDAM_USER_NAME_LEN_MIN - EDAM_USER_NAME_LEN_MAX
         *        <br/>
         *        Regex:    EDAM_USER_NAME_REGEX
         *        </dd>
         *
         *    <dt>timezone</dt>
         *        <dd>The zone ID for the user's default location.    If present,
         *        this may be used to localize the display of any timestamp for which no
         *        other timezone is available.
         *        The format must be encoded as a standard zone ID such as
         *        "America/Los_Angeles" or "GMT+08:00"
         *        <br/>
         *        Length:    EDAM_TIMEZONE_LEN_MIN - EDAM_TIMEZONE_LEN_MAX
         *        <br/>
         *        Regex:    EDAM_TIMEZONE_REGEX
         *        </dd>
         *
         *    <dt>privilege</dt>
         *        <dd>The level of access permitted for the user.
         *        </dd>
         *
         *    <dt>created</dt>
         *        <dd>The date and time when this user account was created in the
         *        service.
         *        </dd>
         *
         *    <dt>updated</dt>
         *        <dd>The date and time when this user account was last modified
         *        in the service.
         *        </dd>
         *
         *    <dt>deleted</dt>
         *        <dd>If the account has been deleted from the system (e.g. as
         *        the result of a legal request by the user), the date and time of the
         *        deletion will be represented here.    If not, this value will not be set.
         *        </dd>
         *
         *    <dt>active</dt>
         *        <dd>If the user account is available for login and
         *        synchronization, this flag will be set to true.
         *        </dd>
         *
         *    <dt>shardId</dt>
         *        <dd>DEPRECATED - Client applications should have no need to use this field.
         *        </dd>
         *
         *    <dt>attributes</dt>
         *        <dd>If present, this will contain a list of the attributes
         *        for this user account.
         *        </dd>
         *
         *    <dt>accounting</dt>
         *        <dd>Bookkeeping information for the user's subscription.
         *        </dd>
         *
         *    <dt>premiumInfo</dt>
         *        <dd>If present, this will contain a set of commerce information
         *        relating to the user's premium service level.
         *        </dd>
         *
         *    <dt>businessUserInfo</dt>
         *        <dd>If present, this will contain a set of business information
         *        relating to the user's business membership.    If not present, the
         *        user is not currently part of a business.
         *        </dd>
         *    </dl>
         */
        class User {
            id: number;
            username: string;
            email: string;
            name: string;
            timezone: string;
            privilege: PrivilegeLevel;
            created: number;
            updated: number;
            deleted: number;
            active: boolean;
            shardId: string;
            attributes: UserAttributes;
            accounting: Accounting;
            premiumInfo: PremiumInfo;
            businessUserInfo: BusinessUserInfo;

            constructor(args?: { id?: number; username?: string; email?: string; name?: string; timezone?: string; privilege?: PrivilegeLevel; created?: number; updated?: number; deleted?: number; active?: boolean; shardId?: string; attributes?: UserAttributes; accounting?: Accounting; premiumInfo?: PremiumInfo; businessUserInfo?: BusinessUserInfo; });
        }

        /**
         *    A tag within a user's account is a unique name which may be organized
         *    a simple hierarchy.
         * <dl>
         *    <dt>guid</dt>
         *        <dd>The unique identifier of this tag. Will be set by the service,
         *        so may be omitted by the client when creating the Tag.
         *        <br/>
         *        Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *        <br/>
         *        Regex:    EDAM_GUID_REGEX
         *        </dd>
         *
         *    <dt>name</dt>
         *        <dd>A sequence of characters representing the tag's identifier.
         *        Case is preserved, but is ignored for comparisons.
         *        This means that an account may only have one tag with a given name, via
         *        case-insensitive comparison, so an account may not have both "food" and
         *        "Food" tags.
         *        May not contain a comma (','), and may not begin or end with a space.
         *        <br/>
         *        Length:    EDAM_TAG_NAME_LEN_MIN - EDAM_TAG_NAME_LEN_MAX
         *        <br/>
         *        Regex:    EDAM_TAG_NAME_REGEX
         *        </dd>
         *
         *    <dt>parentGuid</dt>
         *        <dd>If this is set, then this is the GUID of the tag that
         *        holds this tag within the tag organizational hierarchy.    If this is
         *        not set, then the tag has no parent and it is a "top level" tag.
         *        Cycles are not allowed (e.g. a->parent->parent == a) and will be
         *        rejected by the service.
         *        <br/>
         *        Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *        <br/>
         *        Regex:    EDAM_GUID_REGEX
         *        </dd>
         *
         *    <dt>updateSequenceNum</dt>
         *        <dd>A number identifying the last transaction to
         *        modify the state of this object.    The USN values are sequential within an
         *        account, and can be used to compare the order of modifications within the
         *        service.
         *        </dd>
         *    </dl>
         */
        class Tag {
            guid: string;
            name: string;
            parentGuid: string;
            updateSequenceNum: number;

            constructor(args?: { guid?: string; name?: string; parentGuid?: string; updateSequenceNum?: number; });
        }

        /**
         * A structure that wraps a map of name/value pairs whose values are not
         * always present in the structure in order to reduce space when obtaining
         * batches of entities that contain the map.
         *
         * When the server provides the client with a LazyMap, it will fill in either
         * the keysOnly field or the fullMap field, but never both, based on the API
         * and parameters.
         *
         * When a client provides a LazyMap to the server as part of an update to
         * an object, the server will only update the LazyMap if the fullMap field is
         * set. If the fullMap field is not set, the server will not make any changes
         * to the map.
         *
         * Check the API documentation of the individual calls involving the LazyMap
         * for full details including the constraints of the names and values of the
         * map.
         *
         * <dl>
         * <dt>keysOnly</dt>
         *     <dd>The set of keys for the map.    This field is ignored by the
         *             server when set.
         *     </dd>
         *
         * <dt>fullMap</dt>
         *     <dd>The complete map, including all keys and values.
         *     </dd>
         * </dl>
         */
        class LazyMap {
            keysOnly: string[];
            fullMap: { [k: string]: string; };

            constructor(args?: { keysOnly?: string[]; fullMap?: { [k: string]: string; }; });
        }

        /**
         * Structure holding the optional attributes of a Resource
         * <dl>
         * <dt>sourceURL</dt>
         *     <dd>the original location where the resource was hosted
         *     <br/>
         *        Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *     </dd>
         *
         * <dt>timestamp</dt>
         *     <dd>the date and time that is associated with this resource
         *     (e.g. the time embedded in an image from a digital camera with a clock)
         *     </dd>
         *
         * <dt>latitude</dt>
         *     <dd>the latitude where the resource was captured
         *     </dd>
         *
         * <dt>longitude</dt>
         *     <dd>the longitude where the resource was captured
         *     </dd>
         *
         * <dt>altitude</dt>
         *     <dd>the altitude where the resource was captured
         *     </dd>
         *
         * <dt>cameraMake</dt>
         *     <dd>information about an image's camera, e.g. as embedded in
         *     the image's EXIF data
         *     <br/>
         *     Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *     </dd>
         *
         * <dt>cameraModel</dt>
         *     <dd>information about an image's camera, e.g. as embedded
         *     in the image's EXIF data
         *     <br/>
         *     Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *     </dd>
         *
         * <dt>clientWillIndex</dt>
         *     <dd>if true, then the original client that submitted
         *     the resource plans to submit the recognition index for this resource at a
         *     later time.
         *     </dd>
         *
         * <dt>recoType</dt>
         *     <dd>DEPRECATED - this field is no longer set by the service, so should
         *         be ignored.
         *     </dd>
         *
         * <dt>fileName</dt>
         *     <dd>if the resource came from a source that provided an
         *     explicit file name, the original name will be stored here.    Many resources
         *     come from unnamed sources, so this will not always be set.
         *     </dd>
         *
         * <dt>attachment</dt>
         *     <dd>this will be true if the resource should be displayed as an attachment,
         *     or false if the resource should be displayed inline (if possible).
         *     </dd>
         *
         * <dt>applicationData</dt>
         * <dd>Provides a location for applications to store a relatively small
         * (4kb) blob of data associated with a Resource that is not visible to the user
         * and that is opaque to the Evernote service. A single application may use at most
         * one entry in this map, using its API consumer key as the map key. See the
         * documentation for LazyMap for a description of when the actual map values
         * are returned by the service.
         * <p>To safely add or modify your application's entry in the map, use
         * NoteStore.setResourceApplicationDataEntry. To safely remove your application's
         * entry from the map, use NoteStore.unsetResourceApplicationDataEntry.</p>
         * Minimum length of a name (key): EDAM_APPLICATIONDATA_NAME_LEN_MIN
         * <br/>
         * Sum max size of key and value: EDAM_APPLICATIONDATA_ENTRY_LEN_MAX
         * <br/>
         * Syntax regex for name (key): EDAM_APPLICATIONDATA_NAME_REGEX
         * </dd>
         *
         * </dl>
         */
        class ResourceAttributes {
            sourceURL: string;
            timestamp: number;
            latitude: number;
            longitude: number;
            altitude: number;
            cameraMake: string;
            cameraModel: string;
            clientWillIndex: boolean;
            recoType: string;
            fileName: string;
            attachment: boolean;
            applicationData: LazyMap;

            constructor(args?: { sourceURL?: string; timestamp?: number; latitude?: number; longitude?: number; altitude?: number; cameraMake?: string; cameraModel?: string; clientWillIndex?: boolean; recoType?: string; fileName?: string; attachment?: boolean; applicationData?: LazyMap; });
        }

        /**
         * Every media file that is embedded or attached to a note is represented
         * through a Resource entry.
         * <dl>
         * <dt>guid</dt>
         *     <dd>The unique identifier of this resource.    Will be set whenever
         *     a resource is retrieved from the service, but may be null when a client
         *     is creating a resource.
         *     <br/>
         *     Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_GUID_REGEX
         *     </dd>
         *
         * <dt>noteGuid</dt>
         *     <dd>The unique identifier of the Note that holds this
         *     Resource. Will be set whenever the resource is retrieved from the service,
         *     but may be null when a client is creating a resource.
         *     <br/>
         *     Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_GUID_REGEX
         *     </dd>
         *
         * <dt>data</dt>
         *     <dd>The contents of the resource.
         *     Maximum length:    The data.body is limited to EDAM_RESOURCE_SIZE_MAX_FREE
         *     for free accounts and EDAM_RESOURCE_SIZE_MAX_PREMIUM for premium accounts.
         *     </dd>
         *
         * <dt>mime</dt>
         *     <dd>The MIME type for the embedded resource.    E.g. "image/gif"
         *     <br/>
         *     Length:    EDAM_MIME_LEN_MIN - EDAM_MIME_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_MIME_REGEX
         *     </dd>
         *
         * <dt>width</dt>
         *     <dd>If set, this contains the display width of this resource, in
         *     pixels.
         *     </dd>
         *
         * <dt>height</dt>
         *     <dd>If set, this contains the display height of this resource,
         *     in pixels.
         *     </dd>
         *
         * <dt>duration</dt>
         *     <dd>DEPRECATED: ignored.
         *     </dd>
         *
         * <dt>active</dt>
         *     <dd>DEPRECATED: ignored.
         *     </dd>
         *
         * <dt>recognition</dt>
         *     <dd>If set, this will hold the encoded data that provides
         *     information on search and recognition within this resource.
         *     </dd>
         *
         * <dt>attributes</dt>
         *     <dd>A list of the attributes for this resource.
         *     </dd>
         *
         * <dt>updateSequenceNum</dt>
         *     <dd>A number identifying the last transaction to
         *     modify the state of this object. The USN values are sequential within an
         *     account, and can be used to compare the order of modifications within the
         *     service.
         *     </dd>
         *
         * <dt>alternateData</dt>
         *     <dd>Some Resources may be assigned an alternate data format by the service
         *     which may be more appropriate for indexing or rendering than the original
         *     data provided by the user.    In these cases, the alternate data form will
         *     be available via this Data element.    If a Resource has no alternate form,
         *     this field will be unset.</dd>
         * </dl>
         */
        class Resource {
            guid: string;
            noteGuid: string;
            data: Data;
            mime: string;
            width: number;
            height: number;
            duration: number;
            active: boolean;
            recognition: Data;
            attributes: ResourceAttributes;
            updateSequenceNum: number;
            alternateData: Data;

            constructor(args?: { guid?: string; noteGuid?: string; data?: Data; mime?: string; width?: number; height?: number; duration?: number; active?: boolean; recognition?: Data; attributes?: ResourceAttributes; updateSequenceNum?: number; alternateData?: Data; });
        }

        /**
         * The list of optional attributes that can be stored on a note.
         * <dl>
         * <dt>subjectDate</dt>
         *     <dd>time that the note refers to
         *     </dd>
         *
         * <dt>latitude</dt>
         *     <dd>the latitude where the note was taken
         *     </dd>
         *
         * <dt>longitude</dt>
         *     <dd>the longitude where the note was taken
         *     </dd>
         *
         * <dt>altitude</dt>
         *     <dd>the altitude where the note was taken
         *     </dd>
         *
         * <dt>author</dt>
         *     <dd>the author of the content of the note
         *     <br/>
         *     Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *     </dd>
         *
         * <dt>source</dt>
         *     <dd>the method that the note was added to the account, if the
         *     note wasn't directly authored in an Evernote desktop client.
         *     <br/>
         *     Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *     </dd>
         *
         * <dt>sourceURL</dt>
         *     <dd>the original location where the resource was hosted. For web clips,
         *     this will be the URL of the page that was clipped.
         *     <br/>
         *     Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *     </dd>
         *
         * <dt>sourceApplication</dt>
         *     <dd>an identifying string for the application that
         *     created this note.    This string does not have a guaranteed syntax or
         *     structure -- it is intended for human inspection and tracking.
         *     <br/>
         *     Length:    EDAM_ATTRIBUTE_LEN_MIN - EDAM_ATTRIBUTE_LEN_MAX
         *     </dd>
         *
         * <dt>shareDate</dt>
         *    <dd>The date and time when this note was directly shared via its own URL.
         *    This is only set on notes that were individually shared - it is independent
         *    of any notebook-level sharing of the containing notebook. This field
         *    is treated as "read-only" for clients; the server will ignore changes
         *    to this field from an external client.
         *    </dd>
         *
         * <dt>reminderOrder</dt>
         * <dd>The set of notes with this parameter set are considered
         * "reminders" and are to be treated specially by clients to give them
         * higher UI prominence within a notebook.    The value is used to sort
         * the reminder notes within the notebook with higher values
         * representing greater prominence.    Outside of the context of a
         * notebook, the value of this parameter is undefined.    The value is
         * not intended to be compared to the values of reminder notes in
         * other notebooks.    In order to allow clients to place a note at a
         * higher precedence than other notes, you should never set a value
         * greater than the current time (as defined for a Timetstamp). To
         * place a note at higher precedence than existing notes, set the
         * value to the current time as defined for a timestamp (milliseconds
         * since the epoch).    Synchronizing clients must remember the time when
         * the update was performed, using the local clock on the client,
         * and use that value when they later upload the note to the service.
         * Clients must not set the reminderOrder to the reminderTime as the
         * reminderTime could be in the future.    Those two fields are never
         * intended to be related.    The correct value for reminderOrder field
         * for new notes is the "current" time when the user indicated that
         * the note is a reminder.    Clients may implement a separate
         * "sort by date" feature to show notes ordered by reminderTime.
         * Whenever a reminderDoneTime or reminderTime is set but a
         * reminderOrder is not set, the server will fill in the current
         * server time for the reminderOrder field.</dd>
         *
         * <dt>reminderDoneTime</dt>
         * <dd>The date and time when a user dismissed/"marked done" the reminder
         * on the note.    Users typically do not manually set this value directly
         * as it is set to the time when the user dismissed/"marked done" the
         * reminder.</dd>
         *
         * <dt>reminderTime</dt>
         * <dd>The date and time a user has selected to be reminded of the note.
         * A note with this value set is known as a "reminder" and the user can
         * be reminded, via e-mail or client-specific notifications, of the note
         * when the time is reached or about to be reached.    When a user sets
         * a reminder time on a note that has a reminder done time, and that
         * reminder time is in the future, then the reminder done time should be
         * cleared.    This should happen regardless of any existing reminder time
         * that may have previously existed on the note.</dd>
         *
         * <dt>placeName</dt>
         * <dd>Allows the user to assign a human-readable location name associated
         * with a note. Users may assign values like 'Home' and 'Work'. Place
         * names may also be populated with values from geonames database
         * (e.g., a restaurant name). Applications are encouraged to normalize values
         * so that grouping values by place name provides a useful result. Applications
         * MUST NOT automatically add place name values based on geolocation without
         * confirmation from the user; that is, the value in this field should be
         * more useful than a simple automated lookup based on the note's latitude
         * and longitude.</dd>
         *
         * <dt>contentClass</dt>
         * <dd>The class (or type) of note. This field is used to indicate to
         * clients that special structured information is represented within
         * the note such that special rules apply when making
         * modifications. If contentClass is set and the client
         * application does not specifically support the specified class,
         * the client MUST treat the note as read-only. In this case, the
         * client MAY modify the note's notebook and tags via the
         * Note.notebookGuid and Note.tagGuids fields.    The client MAY also
         * modify the reminderOrder field as well as the reminderTime and
         * reminderDoneTime fields.
         * <p>Applications should set contentClass only when they are creating notes
         * that contain structured information that needs to be maintained in order
         * for the user to be able to use the note within that application.
         * Setting contentClass makes a note read-only in other applications, so
         * there is a trade-off when an application chooses to use contentClass.
         * Applications that set contentClass when creating notes must use a contentClass
         * string of the form <i>CompanyName.ApplicationName</i> to ensure uniqueness.</p>
         * Length restrictions: EDAM_NOTE_CONTENT_CLASS_LEN_MIN, EDAM_NOTE_CONTENT_CLASS_LEN_MAX
         * <br/>
         * Regex: EDAM_NOTE_CONTENT_CLASS_REGEX
         * </dd>
         *
         * <dt>applicationData</dt>
         * <dd>Provides a location for applications to store a relatively small
         * (4kb) blob of data that is not meant to be visible to the user and
         * that is opaque to the Evernote service. A single application may use at most
         * one entry in this map, using its API consumer key as the map key. See the
         * documentation for LazyMap for a description of when the actual map values
         * are returned by the service.
         * <p>To safely add or modify your application's entry in the map, use
         * NoteStore.setNoteApplicationDataEntry. To safely remove your application's
         * entry from the map, use NoteStore.unsetNoteApplicationDataEntry.</p>
         * Minimum length of a name (key): EDAM_APPLICATIONDATA_NAME_LEN_MIN
         * <br/>
         * Sum max size of key and value: EDAM_APPLICATIONDATA_ENTRY_LEN_MAX
         * <br/>
         * Syntax regex for name (key): EDAM_APPLICATIONDATA_NAME_REGEX
         * </dd>
         *
         * <dt>creatorId</dt>
         * <dd>The numeric user ID of the user who originally created the note.</dd>
         *
         * <dt>lastEditedBy</dt>
         * <dd>An indication of who made the last change to the note.    If you are
         * accessing the note via a shared notebook to which you have modification
         * rights, or if you are the owner of the notebook to which the note belongs,
         * then you have access to the value.    In this case, the value will be
         * unset if the owner of the notebook containing the note was the last to
         * make the modification, else it will be a string describing the
         * guest who made the last edit.    If you do not have access to this value,
         * it will be left unset.    This field is read-only by clients.    The server
         * will ignore all values set by clients into this field.</dd>
         *
         * <dt>lastEditorId</dt>
         * <dd>The numeric user ID of the user described in lastEditedBy.</dd>
         *
         * <dt>classifications</dt>
         * <dd>A map of classifications applied to the note by clients or by the
         * Evernote service. The key is the string name of the classification type,
         * and the value is a constant that begins with CLASSIFICATION_.</dd>
         *
         * </dl>
         */
        class NoteAttributes {
            subjectDate: number;
            latitude: number;
            longitude: number;
            altitude: number;
            author: string;
            source: string;
            sourceURL: string;
            sourceApplication: string;
            shareDate: number;
            reminderOrder: number;
            reminderDoneTime: number;
            reminderTime: number;
            placeName: string;
            contentClass: string;
            applicationData: LazyMap;
            lastEditedBy: string;
            classifications: { [k: string]: string; };
            creatorId: number;
            lastEditorId: number;

            constructor(args?: { subjectDate?: number; latitude?: number; longitude?: number; altitude?: number; author?: string; source?: string; sourceURL?: string; sourceApplication?: string; shareDate?: number; reminderOrder?: number; reminderDoneTime?: number; reminderTime?: number; placeName?: string; contentClass?: string; applicationData?: LazyMap; lastEditedBy?: string; classifications?: { [k: string]: string; }; creatorId?: number; lastEditorId?: number; });
        }

        /**
         * Represents a single note in the user's account.
         *
         * <dl>
         * <dt>guid</dt>
         *     <dd>The unique identifier of this note.    Will be set by the
         *     server, but will be omitted by clients calling NoteStore.createNote()
         *     <br/>
         *     Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_GUID_REGEX
         *     </dd>
         *
         * <dt>title</dt>
         *     <dd>The subject of the note.    Can't begin or end with a space.
         *     <br/>
         *     Length:    EDAM_NOTE_TITLE_LEN_MIN - EDAM_NOTE_TITLE_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_NOTE_TITLE_REGEX
         *     </dd>
         *
         * <dt>content</dt>
         *     <dd>The XHTML block that makes up the note.    This is
         *     the canonical form of the note's contents, so will include abstract
         *     Evernote tags for internal resource references.    A client may create
         *     a separate transformed version of this content for internal presentation,
         *     but the same canonical bytes should be used for transmission and
         *     comparison unless the user chooses to modify their content.
         *     <br/>
         *     Length:    EDAM_NOTE_CONTENT_LEN_MIN - EDAM_NOTE_CONTENT_LEN_MAX
         *     </dd>
         *
         * <dt>contentHash</dt>
         *     <dd>The binary MD5 checksum of the UTF-8 encoded content
         *     body. This will always be set by the server, but clients may choose to omit
         *     this when they submit a note with content.
         *     <br/>
         *     Length:    EDAM_HASH_LEN (exactly)
         *     </dd>
         *
         * <dt>contentLength</dt>
         *     <dd>The number of Unicode characters in the content of
         *     the note.    This will always be set by the service, but clients may choose
         *     to omit this value when they submit a Note.
         *     </dd>
         *
         * <dt>created</dt>
         *     <dd>The date and time when the note was created in one of the
         *     clients.    In most cases, this will match the user's sense of when
         *     the note was created, and ordering between notes will be based on
         *     ordering of this field.    However, this is not a "reliable" timestamp
         *     if a client has an incorrect clock, so it cannot provide a true absolute
         *     ordering between notes.    Notes created directly through the service
         *     (e.g. via the web GUI) will have an absolutely ordered "created" value.
         *     </dd>
         *
         * <dt>updated</dt>
         *     <dd>The date and time when the note was last modified in one of
         *     the clients.    In most cases, this will match the user's sense of when
         *     the note was modified, but this field may not be absolutely reliable
         *     due to the possibility of client clock errors.
         *     </dd>
         *
         * <dt>deleted</dt>
         *     <dd>If present, the note is considered "deleted", and this
         *     stores the date and time when the note was deleted by one of the clients.
         *     In most cases, this will match the user's sense of when the note was
         *     deleted, but this field may be unreliable due to the possibility of
         *     client clock errors.
         *     </dd>
         *
         * <dt>active</dt>
         *     <dd>If the note is available for normal actions and viewing,
         *     this flag will be set to true.
         *     </dd>
         *
         * <dt>updateSequenceNum</dt>
         *     <dd>A number identifying the last transaction to
         *     modify the state of this note (including changes to the note's attributes
         *     or resources).    The USN values are sequential within an account,
         *     and can be used to compare the order of modifications within the service.
         *     </dd>
         *
         * <dt>notebookGuid</dt>
         *     <dd>The unique identifier of the notebook that contains
         *     this note.    If no notebookGuid is provided on a call to createNote(), the
         *     default notebook will be used instead.
         *     <br/>
         *     Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_GUID_REGEX
         *     </dd>
         *
         * <dt>tagGuids</dt>
         *     <dd>A list of the GUID identifiers for tags that are applied to this note.
         *     This may be provided in a call to createNote() to unambiguously
         *     the tags that should be assigned to the new note.    Alternately, clients
         *     may pass the names of desired tags via the 'tagNames' field during
         *     note creation.
         *     If the list of tags are omitted on a call to createNote(), then
         *     the server will assume that no changes have been made to the resources.
         *     Maximum:    EDAM_NOTE_TAGS_MAX tags per note
         *     </dd>
         *
         * <dt>resources</dt>
         *     <dd>The list of resources that are embedded within this note.
         *     If the list of resources are omitted on a call to updateNote(), then
         *     the server will assume that no changes have been made to the resources.
         *     The binary contents of the resources must be provided when the resource
         *     is first sent to the service, but it will be omitted by the service when
         *     the Note is returned in the future.
         *     Maximum:    EDAM_NOTE_RESOURCES_MAX resources per note
         *     </dd>
         *
         * <dt>attributes</dt>
         *     <dd>A list of the attributes for this note.
         *     If the list of attributes are omitted on a call to updateNote(), then
         *     the server will assume that no changes have been made to the resources.
         *     </dd>
         *
         * <dt>tagNames</dt>
         *     <dd>May be provided by clients during calls to createNote() as an
         *     alternative to providing the tagGuids of existing tags.    If any tagNames
         *     are provided during createNote(), these will be found, or created if they
         *     don't already exist.    Created tags will have no parent (they will be at
         *     the top level of the tag panel).
         *     </dd>
         * </dl>
         */
        class Note {
            guid: string;
            title: string;
            content: string;
            contentHash: string;
            contentLength: number;
            created: number;
            updated: number;
            deleted: number;
            active: boolean;
            updateSequenceNum: number;
            notebookGuid: string;
            tagGuids: string[];
            resources: Resource[];
            attributes: NoteAttributes;
            tagNames: string[];

            constructor(args?: { guid?: string; title?: string; content?: string; contentHash?: string; contentLength?: number; created?: number; updated?: number; deleted?: number; active?: boolean; updateSequenceNum?: number; notebookGuid?: string; tagGuids?: string[]; resources?: Resource[]; attributes?: NoteAttributes; tagNames?: string[]; });
        }

        /**
         * If a Notebook has been opened to the public, the Notebook will have a
         * reference to one of these structures, which gives the location and optional
         * description of the externally-visible public Notebook.
         * <dl>
         * <dt>uri</dt>
         *     <dd>If this field is present, then the notebook is published for
         *     mass consumption on the Internet under the provided URI, which is
         *     relative to a defined base publishing URI defined by the service.
         *     This field can only be modified via the web service GUI ... publishing
         *     cannot be modified via an offline client.
         *     <br/>
         *     Length:    EDAM_PUBLISHING_URI_LEN_MIN - EDAM_PUBLISHING_URI_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_PUBLISHING_URI_REGEX
         *     </dd>
         *
         * <dt>order</dt>
         *     <dd>When the notes are publicly displayed, they will be sorted
         *     based on the requested criteria.
         *     </dd>
         *
         * <dt>ascending</dt>
         *     <dd>If this is set to true, then the public notes will be
         *     displayed in ascending order (e.g. from oldest to newest).    Otherwise,
         *     the notes will be displayed in descending order (e.g. newest to oldest).
         *     </dd>
         *
         * <dt>publicDescription</dt>
         *     <dd>This field may be used to provide a short
         *     description of the notebook, which may be displayed when (e.g.) the
         *     notebook is shown in a public view.    Can't begin or end with a space.
         *     <br/>
         *     Length:    EDAM_PUBLISHING_DESCRIPTION_LEN_MIN -
         *                        EDAM_PUBLISHING_DESCRIPTION_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_PUBLISHING_DESCRIPTION_REGEX
         *     </dd>
         *
         * </dl>
         */
        class Publishing {
            uri: string;
            order: NoteSortOrder;
            ascending: boolean;
            publicDescription: string;

            constructor(args?: { uri?: string; order?: NoteSortOrder; ascending?: boolean; publicDescription?: string; });
        }

        /**
         * If a Notebook contained in an Evernote Business account has been published
         * the to business library, the Notebook will have a reference to one of these
         * structures, which specifies how the Notebook will be represented in the
         * library.
         *
         * <dl>
         * <dt>notebookDescription</dt>
         *     <dd>A short description of the notebook's content that will be displayed
         *             in the business library user interface. The description may not begin
         *             or end with whitespace.
         *     <br/>
         *     Length: EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MIN -
         *                     EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_REGEX
         *     </dd>
         *
         * <dt>privilege</dt>
         *     <dd>The privileges that will be granted to users who join the notebook through
         *             the business library.
         *     </dd>
         *
         * <dt>recommended</dt>
         *     <dd>Whether the notebook should be "recommended" when displayed in the business
         *             library user interface.
         *     </dd>
         * </dl>
         */
        class BusinessNotebook {
            notebookDescription: string;
            privilege: SharedNotebookPrivilegeLevel;
            recommended: boolean;

            constructor(args?: { notebookDescription?: string; privilege?: SharedNotebookPrivilegeLevel; recommended?: boolean; });
        }

        /**
         * A structure defining the scope of a SavedSearch.
         *
         * <dl>
         *     <dt>includeAccount</dt>
         *     <dd>The search should include notes from the account that contains the SavedSearch.</dd>
         *
         *     <dt>includePersonalLinkedNotebooks</dt>
         *     <dd>The search should include notes within those shared notebooks
         *     that the user has joined that are NOT business notebooks.</dd>
         *
         *     <dt>includeBusinessLinkedNotebooks</dt>
         *     <dd>The search should include notes within those shared notebooks
         *     that the user has joined that are business notebooks in the business that
         *     the user is currently a member of.</dd>
         * </dl>
         */
        class SavedSearchScope {
            includeAccount: boolean;
            includePersonalLinkedNotebooks: boolean;
            includeBusinessLinkedNotebooks: boolean;

            constructor(args?: { includeAccount?: boolean; includePersonalLinkedNotebooks?: boolean; includeBusinessLinkedNotebooks?: boolean; });
        }

        /**
         * A named search associated with the account that can be quickly re-used.
         * <dl>
         * <dt>guid</dt>
         *     <dd>The unique identifier of this search.    Will be set by the
         *     service, so may be omitted by the client when creating.
         *     <br/>
         *     Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_GUID_REGEX
         *     </dd>
         *
         * <dt>name</dt>
         *     <dd>The name of the saved search to display in the GUI.    The
         *     account may only contain one search with a given name (case-insensitive
         *     compare). Can't begin or end with a space.
         *     <br/>
         *     Length:    EDAM_SAVED_SEARCH_NAME_LEN_MIN - EDAM_SAVED_SEARCH_NAME_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_SAVED_SEARCH_NAME_REGEX
         *     </dd>
         *
         * <dt>query</dt>
         *     <dd>A string expressing the search to be performed.
         *     <br/>
         *     Length:    EDAM_SAVED_SEARCH_QUERY_LEN_MIN - EDAM_SAVED_SEARCH_QUERY_LEN_MAX
         *     </dd>
         *
         * <dt>format</dt>
         *     <dd>The format of the query string, to determine how to parse
         *     and process it.
         *     </dd>
         *
         * <dt>updateSequenceNum</dt>
         *     <dd>A number identifying the last transaction to
         *     modify the state of this object.    The USN values are sequential within an
         *     account, and can be used to compare the order of modifications within the
         *     service.
         *     </dd>
         *
         * <dt>scope</dt>
         *     <dd><p>Specifies the set of notes that should be included in the search, if
         *        possible.</p>
         *        <p>Clients are expected to search as much of the desired scope as possible,
         *        with the understanding that a given client may not be able to cover the full
         *        specified scope. For example, when executing a search that includes notes in both
         *        the owner's account and business notebooks, a mobile client may choose to only
         *        search within the user's account because it is not capable of searching both
         *        scopes simultaneously. When a search across multiple scopes is not possible,
         *        a client may choose which scope to search based on the current application
         *        context. If a client cannot search any of the desired scopes, it should refuse
         *        to execute the search.</p>
         *        </dd>
         * </dl>
         */
        class SavedSearch {
            guid: string;
            name: string;
            query: string;
            format: QueryFormat;
            updateSequenceNum: number;
            scope: SavedSearchScope;

            constructor(args?: { guid?: string; name?: string; query?: string; format?: QueryFormat; updateSequenceNum?: number; scope?: SavedSearchScope; });
        }

        /**
         * Settings meant for the recipient of a shared notebook, such as
         * for indicating which types of notifications the recipient wishes
         * for reminders, etc.
         *
         * The reminderNotifyEmail and reminderNotifyInApp fields have a
         * 3-state read value but a 2-state write value.    On read, it is
         * possible to observe "unset", true, or false.    The initial state is
         * "unset".    When you choose to set a value, you may set it to either
         * true or false, but you cannot unset the value.    Once one of these
         * members has a true/false value, it will always have a true/false
         * value.
         *
         * <dl>
         * <dt>reminderNotifyEmail</dt>
         * <dd>Indicates that the user wishes to receive daily e-mail notifications
         *         for reminders associated with the shared notebook.    This may be
         *         true only for business notebooks that belong to the business of
         *         which the user is a member.    You may only set this value on a
         *         notebook in your business.</dd>
         * <dt>reminderNotifyInApp</dt>
         * <dd>Indicates that the user wishes to receive notifications for
         *         reminders by applications that support providing such
         *         notifications.    The exact nature of the notification is defined
         *         by the individual applications.</dd>
         * </dl>
         *
         */
        class SharedNotebookRecipientSettings {
            reminderNotifyEmail: boolean;
            reminderNotifyInApp: boolean;

            constructor(args?: { reminderNotifyEmail?: boolean; reminderNotifyInApp?: boolean; });
        }

        /**
         * Shared notebooks represent a relationship between a notebook and a single
         * share invitation recipient.
         * <dl>
         * <dt>id</dt>
         * <dd>the primary identifier of the share</dd>
         *
         * <dt>userId</dt>
         * <dd>the user id of the owner of the notebook</dd>
         *
         * <dt>notebookGuid</dt>
         * <dd>the GUID of the associated notebook shared.</dd>
         *
         * <dt>email</dt>
         * <dd>the email address of the recipient - used by the notebook
         * owner to identify who they shared with.</dd>
         *
         * <dt>notebookModifiable</dt>
         * <dd>(DEPRECATED) a flag indicating the share is read/write -otherwise it's read
         *         only.    This field is deprecated in favor of the new "privilege" field.</dd>
         *
         * <dt>requireLogin</dt>
         * <dd>(DEPRECATED) indicates that a user must login to access the share.    This
         *         field is deprecated and will be "true" for all new shared notebooks.    It
         *         is read-only and ignored when creating or modifying a shared notebook,
         *         except that a shared notebook can be modified to require login.
         *         See "allowPreview" for information on privileges and shared notebooks.</dd>
         *
         * <dt>serviceCreated</dt>
         * <dd>the date the owner first created the share with the specific email
         *     address</dd>
         *
         * <dt>serviceUpdated</dt>
         * <dd>the date the shared notebook was last updated on the service.    This
         *         will be updated when authenticateToSharedNotebook is called the first
         *         time with a shared notebook requiring login (i.e. when the username is
         *         bound to that shared notebook).</dd>
         *
         * <dt>username</dt>
         * <dd>the username of the user who can access this share.
         *     Once it's assigned it cannot be changed.</dd>
         *
         * <dt>privilege</dt>
         * <dd>The privilege level granted to the notebook, activity stream, and
         *         invitations.    See the corresponding enumeration for details.</dd>
         *
         * <dt>allowPreview</dt>
         * <dd>Whether or not to grant "READ_NOTEBOOK" privilege without an
         *         authentication token, for authenticateToSharedNotebook(...).    With
         *         the change to "requireLogin" always being true for new shared
         *         notebooks, this is the only way to access a shared notebook without
         *         an authorization token.    This setting expires after the first use
         *         of authenticateToSharedNotebook(...) with a valid authentication
         *         token.</dd>
         *
         * <dt>recipientSettings</dt>
         * <dd>Settings intended for use only by the recipient of this shared
         *         notebook.    You should skip setting this value unless you want
         *         to change the value contained inside the structure, and only if
         *         you are the recipient.</dd>
         * </dl>
         */
        class SharedNotebook {
            id: number;
            userId: number;
            notebookGuid: string;
            email: string;
            notebookModifiable: boolean;
            requireLogin: boolean;
            serviceCreated: number;
            serviceUpdated: number;
            shareKey: string;
            username: string;
            privilege: SharedNotebookPrivilegeLevel;
            allowPreview: boolean;
            recipientSettings: SharedNotebookRecipientSettings;

            constructor(args?: { id?: number; userId?: number; notebookGuid?: string; email?: string; notebookModifiable?: boolean; requireLogin?: boolean; serviceCreated?: number; serviceUpdated?: number; shareKey?: string; username?: string; privilege?: SharedNotebookPrivilegeLevel; allowPreview?: boolean; recipientSettings?: SharedNotebookRecipientSettings; });
        }

        /**
         * This structure captures information about the types of operations
         * that cannot be performed on a given notebook with a type of
         * authenticated access and credentials.    The values filled into this
         * structure are based on then-current values in the server database
         * for shared notebooks and notebook publishing records, as well as
         * information related to the authentication token.    Information from
         * the authentication token includes the application that is accessing
         * the server, as defined by the permissions granted by consumer (api)
         * key, and the method used to obtain the token, for example via
         * authenticateToSharedNotebook, authenticateToBusiness, etc.    Note
         * that changes to values in this structure that are the result of
         * shared notebook or publishing record changes are communicated to
         * the client via a change in the notebook USN during sync.    It is
         * important to use the same access method, parameters, and consumer
         * key in order obtain correct results from the sync engine.
         *
         * The server has the final say on what is allowed as values may
         * change between calls to obtain NotebookRestrictions instances
         * and to operate on data on the service.
         *
         * If the following are set and true, then the given restriction is
         * in effect, as accessed by the same authentication token from which
         * the values were obtained.
         *
         * <dt>noReadNotes</dt>
         *     <dd>The client is not able to read notes from the service and
         *     the notebook is write-only.
         *     </dd>
         * <dt>noCreateNotes</dt>
         *     <dd>The client may not create new notes in the notebook.
         *     </dd>
         * <dt>noUpdateNotes</dt>
         *     <dd>The client may not update notes currently in the notebook.
         *     </dd>
         * <dt>noExpungeNotes</dt>
         *     <dd>The client may not expunge notes currently in the notebook.
         *     </dd>
         * <dt>noShareNotes</dt>
         *     <dd>The client may not share notes in the notebook via the
         *     shareNote method.
         *     </dd>
         * <dt>noEmailNotes</dt>
         *     <dd>The client may not e-mail notes via the Evernote service by
         *     using the emailNote method.
         *     </dd>
         * <dt>noSendMessageToRecipients</dt>
         *     <dd>The client may not send messages to the share recipients of
         *     the notebook.
         *     </dd>
         * <dt>noUpdateNotebook</dt>
         *     <dd>The client may not update the Notebook object itself, for
         *     example, via the updateNotebook method.
         *     </dd>
         * <dt>noExpungeNotebook</dt>
         *     <dd>The client may not expunge the Notebook object itself, for
         *     example, via the expungeNotebook method.
         *     </dd>
         * <dt>noSetDefaultNotebook</dt>
         *     <dd>The client may not set this notebook to be the default notebook.
         *     The caller should leave Notebook.defaultNotebook unset.
         *     </dd>
         * <dt>noSetNotebookStack</dt>
         *     <dd>If the client is able to update the Notebook, the Notebook.stack
         *     value may not be set.
         *     </dd>
         * <dt>noPublishToPublic</dt>
         *     <dd>The client may not change the publish the notebook to the public.
         *     For example, business notebooks may not be shared publicly.
         *     </dd>
         * <dt>noPublishToBusinessLibrary</dt>
         *     <dd>The client may not publish the notebook to the business library.
         *     </dd>
         * <dt>noCreateTags</dt>
         *     <dd>The client may not complete an operation that results in a new tag
         *     being created in the owner's account.
         *     </dd>
         * <dt>noUpdateTags</dt>
         *     <dd>The client may not update tags in the owner's account.
         *     </dd>
         * <dt>noExpungeTags</dt>
         *     <dd>The client may not expunge tags in the owner's account.
         *     </dd>
         * <dt>noSetParentTag</dt>
         *     <dd>If the client is able to create or update tags in the owner's account,
         *     then they will not be able to set the parent tag.    Leave the value unset.
         *     </dd>
         * <dt>noCreateSharedNotebooks</dt>
         *     <dd>The client is unable to create shared notebooks for the notebook.
         *     </dd>
         * <dt>updateWhichSharedNotebookRestrictions</dt>
         *     <dd>Restrictions on which shared notebook instances can be updated.    If the
         *     value is not set or null, then the client can update any of the shared notebooks
         *     associated with the notebook on which the NotebookRestrictions are defined.
         *     See the enumeration for further details.
         *     </dd>
         * <dt>expungeWhichSharedNotebookRestrictions</dt>
         *     <dd>Restrictions on which shared notebook instances can be expunged.    If the
         *     value is not set or null, then the client can expunge any of the shared notebooks
         *     associated with the notebook on which the NotebookRestrictions are defined.
         *     See the enumeration for further details.
         *     </dd>
         */
        class NotebookRestrictions {
            noReadNotes: boolean;
            noCreateNotes: boolean;
            noUpdateNotes: boolean;
            noExpungeNotes: boolean;
            noShareNotes: boolean;
            noEmailNotes: boolean;
            noSendMessageToRecipients: boolean;
            noUpdateNotebook: boolean;
            noExpungeNotebook: boolean;
            noSetDefaultNotebook: boolean;
            noSetNotebookStack: boolean;
            noPublishToPublic: boolean;
            noPublishToBusinessLibrary: boolean;
            noCreateTags: boolean;
            noUpdateTags: boolean;
            noExpungeTags: boolean;
            noSetParentTag: boolean;
            noCreateSharedNotebooks: boolean;
            updateWhichSharedNotebookRestrictions: SharedNotebookInstanceRestrictions;
            expungeWhichSharedNotebookRestrictions: SharedNotebookInstanceRestrictions;

            constructor(args?: { noReadNotes?: boolean; noCreateNotes?: boolean; noUpdateNotes?: boolean; noExpungeNotes?: boolean; noShareNotes?: boolean; noEmailNotes?: boolean; noSendMessageToRecipients?: boolean; noUpdateNotebook?: boolean; noExpungeNotebook?: boolean; noSetDefaultNotebook?: boolean; noSetNotebookStack?: boolean; noPublishToPublic?: boolean; noPublishToBusinessLibrary?: boolean; noCreateTags?: boolean; noUpdateTags?: boolean; noExpungeTags?: boolean; noSetParentTag?: boolean; noCreateSharedNotebooks?: boolean; updateWhichSharedNotebookRestrictions?: SharedNotebookInstanceRestrictions; expungeWhichSharedNotebookRestrictions?: SharedNotebookInstanceRestrictions; });
        }

        /**
         * A unique container for a set of notes.
         * <dl>
         * <dt>guid</dt>
         *     <dd>The unique identifier of this notebook.
         *     <br/>
         *     Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_GUID_REGEX
         *     </dd>
         *
         * <dt>name</dt>
         *     <dd>A sequence of characters representing the name of the
         *     notebook.    May be changed by clients, but the account may not contain two
         *     notebooks with names that are equal via a case-insensitive comparison.
         *     Can't begin or end with a space.
         *     <br/>
         *     Length:    EDAM_NOTEBOOK_NAME_LEN_MIN - EDAM_NOTEBOOK_NAME_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_NOTEBOOK_NAME_REGEX
         *     </dd>
         *
         * <dt>updateSequenceNum</dt>
         *     <dd>A number identifying the last transaction to
         *     modify the state of this object.    The USN values are sequential within an
         *     account, and can be used to compare the order of modifications within the
         *     service.
         *     </dd>
         *
         * <dt>defaultNotebook</dt>
         *     <dd>If true, this notebook should be used for new notes
         *     whenever the user has not (or cannot) specify a desired target notebook.
         *     For example, if a note is submitted via SMTP email.
         *     The service will maintain at most one defaultNotebook per account.
         *     If a second notebook is created or updated with defaultNotebook set to
         *     true, the service will automatically update the prior notebook's
         *     defaultNotebook field to false.    If the default notebook is deleted
         *     (i.e. "active" set to false), the "defaultNotebook" field will be
         *     set to false by the service.    If the account has no default notebook
         *     set, the service will use the most recent notebook as the default.
         *     </dd>
         *
         * <dt>serviceCreated</dt>
         *     <dd>The time when this notebook was created on the
         *     service. This will be set on the service during creation, and the service
         *     will provide this value when it returns a Notebook to a client.
         *     The service will ignore this value if it is sent by clients.
         *     </dd>
         *
         * <dt>serviceUpdated</dt>
         *     <dd>The time when this notebook was last modified on the
         *     service.    This will be set on the service during creation, and the service
         *     will provide this value when it returns a Notebook to a client.
         *     The service will ignore this value if it is sent by clients.
         *     </dd>
         *
         * <dt>publishing</dt>
         *     <dd>If the Notebook has been opened for public access, or
         *     business users shared with their business (i.e. if 'published' is
         *     set to true), then this will point to the set of publishing
         *     information for the Notebook (URI, description, etc.).    A
         *     Notebook cannot be published without providing this information,
         *     but it will persist for later use if publishing is ever disabled
         *     on the Notebook.    Clients that do not wish to change the
         *     publishing behavior of a Notebook should not set this value when
         *     calling NoteStore.updateNotebook().
         *     </dd>
         *
         * <dt>published</dt>
         *     <dd>If this is set to true, then the Notebook will be
         *     accessible either to the public, or for business users to their business,
         *     via the 'publishing' specification, which must also be set.    If this is set
         *     to false, the Notebook will not be available to the public (or business).
         *     Clients that do not wish to change the publishing behavior of a Notebook
         *     should not set this value when calling NoteStore.updateNotebook().
         *     </dd>
         *
         * <dt>stack</dt>
         *     <dd>If this is set, then the notebook is visually contained within a stack
         *     of notebooks with this name.    All notebooks in the same account with the
         *     same 'stack' field are considered to be in the same stack.
         *     Notebooks with no stack set are "top level" and not contained within a
         *     stack.
         *     </dd>
         *
         * <dt>sharedNotebookIds</dt>
         *     <dd><i>DEPRECATED</i> - replaced by sharedNotebooks.</dd>
         *
         * <dt>sharedNotebooks</dt>
         *     <dd>The list of recipients to whom this notebook has been shared
         *     (one SharedNotebook object per recipient email address). This field will
         *     be unset if you do not have permission to access this data. If you are
         *     accessing the notebook as the owner or via a shared notebook that is
         *     modifiable, then you have access to this data and the value will be set.
         *     This field is read-only. Clients may not make changes to shared notebooks
         *     via this field.
         *     </dd>
         *
         * <dt>businessNotebook</dt>
         *     <dd>If the notebook is part of a business account and has been published to the
         *     business library, this will contain information for the library listing.
         *     The presence or absence of this field is not a reliable test of whether a given
         *     notebook is in fact a business notebook - the field is only used when a notebook is or
         *     has been published to the business library.
         *     </dd>
         *
         * <dt>contact</dt>
         *     <dd>Intended for use with Business accounts, this field identifies the user who
         *     has been designated as the "contact".    For notebooks created in business
         *     accounts, the server will automatically set this value to the user who created
         *     the notebook unless Notebook.contact.username has been set, in which that value
         *     will be used.    When updating a notebook, it is common to leave Notebook.contact
         *     field unset, indicating that no change to the value is being requested and that
         *     the existing value, if any, should be preserved.
         *     </dd>
         *
         * </dl>
         */
        class Notebook {
            guid: string;
            name: string;
            updateSequenceNum: number;
            defaultNotebook: boolean;
            serviceCreated: number;
            serviceUpdated: number;
            publishing: Publishing;
            published: boolean;
            stack: string;
            sharedNotebookIds: number[];
            sharedNotebooks: SharedNotebook[];
            businessNotebook: BusinessNotebook;
            contact: User;
            restrictions: NotebookRestrictions;

            constructor(args?: { guid?: string; name?: string; updateSequenceNum?: number; defaultNotebook?: boolean; serviceCreated?: number; serviceUpdated?: number; publishing?: Publishing; published?: boolean; stack?: string; sharedNotebookIds?: number[]; sharedNotebooks?: SharedNotebook[]; businessNotebook?: BusinessNotebook; contact?: User; restrictions?: NotebookRestrictions; });
        }

        /**
         * A link in an users account that refers them to a public or individual share in
         * another user's account.
         *
         * <dl>
         * <dt>shareName</dt>
         * <dd>the display name of the shared notebook.
         *     The link owner can change this.</dd>
         *
         * <dt>username</dt>
         * <dd>the username of the user who owns the shared or public notebook</dd>
         *
         * <dt>shardId</dt>
         * <dd>the shard ID of the notebook if the notebook is not public</dt>
         *
         * <dt>shareKey</dt>
         * <dd>the secret key that provides access to the shared notebook</dd>
         *
         * <dt>uri</dt>
         * <dd>the identifier of the public notebook</dd>
         *
         * <dt>guid</dt>
         *     <dd>The unique identifier of this linked notebook.    Will be set whenever
         *     a linked notebook is retrieved from the service, but may be null when a client
         *     is creating a linked notebook.
         *     <br/>
         *     Length:    EDAM_GUID_LEN_MIN - EDAM_GUID_LEN_MAX
         *     <br/>
         *     Regex:    EDAM_GUID_REGEX
         *     </dd>
         *
         * <dt>updateSequenceNum</dt>
         *     <dd>A number identifying the last transaction to
         *     modify the state of this object.    The USN values are sequential within an
         *     account, and can be used to compare the order of modifications within the
         *     service.
         *     </dd>
         *
         * <dt>noteStoreUrl</dt>
         *     <dd>
         *     This field will contain the full URL that clients should use to make
         *     NoteStore requests to the server shard that contains that notebook's data.
         *     I.e. this is the URL that should be used to create the Thrift HTTP client
         *     transport to send messages to the NoteStore service for the account.
         *     </dd>
         *
         * <dt>webApiUrlPrefix:</dt>
         *     <dd>
         *     This field will contain the initial part of the URLs that should be used
         *     to make requests to Evernote's thin client "web API", which provide
         *     optimized operations for clients that aren't capable of manipulating
         *     the full contents of accounts via the full Thrift data model. Clients
         *     should concatenate the relative path for the various servlets onto the
         *     end of this string to construct the full URL, as documented on our
         *     developer web site.
         *     </dd>
         *
         * <dt>stack</dt>
         *     <dd>If this is set, then the notebook is visually contained within a stack
         *     of notebooks with this name.    All notebooks in the same account with the
         *     same 'stack' field are considered to be in the same stack.
         *     Notebooks with no stack set are "top level" and not contained within a
         *     stack.    The link owner can change this and this field is for the benefit
         *     of the link owner.
         *     </dd>
         *
         * <dt>businessId</dt>
         *     <dd>If set, this will be the unique identifier for the business that owns
         *     the notebook to which the linked notebook refers.
         *
         * </dl>
         */
        class LinkedNotebook {
            shareName: string;
            username: string;
            shardId: string;
            shareKey: string;
            uri: string;
            guid: string;
            updateSequenceNum: number;
            noteStoreUrl: string;
            webApiUrlPrefix: string;
            stack: string;
            businessId: number;

            constructor(args?: { shareName?: string; username?: string; shardId?: string; shareKey?: string; uri?: string; guid?: string; updateSequenceNum?: number; noteStoreUrl?: string; webApiUrlPrefix?: string; stack?: string; businessId?: number; });
        }

        /**
         * A structure that describes a notebook or a user's relationship with
         * a notebook. NotebookDescriptor is expected to remain a lighter-weight
         * structure when compared to Notebook.
         * <dl>
         * <dt>guid</dt>
         *     <dd>The unique identifier of the notebook.
         *     </dd>
         *
         * <dt>notebookDisplayName</dt>
         *     <dd>A sequence of characters representing the name of the
         *     notebook.
         *     </dd>
         *
         * <dt>contactName</dt>
         *     <dd>The User.name value of the notebook's "contact".
         *     </dd>
         *
         * <dt>hasSharedNotebook</dt>
         *     <dd>Whether a SharedNotebook record exists between the calling user and this
         *     notebook.
         *     </dd>
         *
         * <dt>joinedUserCount</dt>
         *     <dd>The number of users who have joined this notebook.
         *     </dd>
         *
         * </dl>
         */
        class NotebookDescriptor {
            guid: string;
            notebookDisplayName: string;
            contactName: string;
            hasSharedNotebook: boolean;
            joinedUserCount: number;

            constructor(args?: { guid?: string; notebookDisplayName?: string; contactName?: string; hasSharedNotebook?: boolean; joinedUserCount?: number; });
        }

        /**
         * A value for the "recipe" key in the "classifications" map in NoteAttributes
         * that indicates the user has classified a note as being a non-recipe.
         */
        var CLASSIFICATION_RECIPE_USER_NON_RECIPE: string;

        /**
         * A value for the "recipe" key in the "classifications" map in NoteAttributes
         * that indicates the user has classified a note as being a recipe.
         */
        var CLASSIFICATION_RECIPE_USER_RECIPE: string;

        /**
         * A value for the "recipe" key in the "classifications" map in NoteAttributes
         * that indicates the Evernote service has classified a note as being a recipe.
         */
        var CLASSIFICATION_RECIPE_SERVICE_RECIPE: string;

        /**
         * Standardized value for the 'source' NoteAttribute for notes that
         * were clipped from the web in some manner.
         */
        var EDAM_NOTE_SOURCE_WEB_CLIP: string;

        /**
         * Standardized value for the 'source' NoteAttribute for notes that
         * were clipped from an email message.
         */
        var EDAM_NOTE_SOURCE_MAIL_CLIP: string;

        /**
         * Standardized value for the 'source' NoteAttribute for notes that
         * were created via email sent to Evernote's email interface.
         */
        var EDAM_NOTE_SOURCE_MAIL_SMTP_GATEWAY: string;
        /**
         * Service:    UserStore
         * <p>
         * The UserStore service is primarily used by EDAM clients to establish
         * authentication via username and password over a trusted connection (e.g.
         * SSL).    A client's first call to this interface should be checkVersion() to
         * ensure that the client's software is up to date.
         * </p>
         * All calls which require an authenticationToken may throw an
         * EDAMUserException for the following reasons:
         *    <ul>
         *     <li> AUTH_EXPIRED "authenticationToken" - token has expired
         *     <li> BAD_DATA_FORMAT "authenticationToken" - token is malformed
         *     <li> DATA_REQUIRED "authenticationToken" - token is empty
         *     <li> INVALID_AUTH "authenticationToken" - token signature is invalid
         * </ul>
         */
        class UserStoreClient {
            seqid: number;

            /**
             * This should be the first call made by a client to the EDAM service.    It
             * tells the service what protocol version is used by the client.    The
             * service will then return true if the client is capable of talking to
             * the service, and false if the client's protocol version is incompatible
             * with the service, so the client must upgrade.    If a client receives a
             * false value, it should report the incompatibility to the user and not
             * continue with any more EDAM requests (UserStore or NoteStore).
             *
             * @param clientName
             *     This string provides some information about the client for
             *     tracking/logging on the service.    It should provide information about
             *     the client's software and platform. The structure should be:
             *     application/version; platform/version; [ device/version ]
             *     E.g. "Evernote Windows/3.0.1; Windows/XP SP3".
             *
             * @param edamVersionMajor
             *     This should be the major protocol version that was compiled by the
             *     client.    This should be the current value of the EDAM_VERSION_MAJOR
             *     constant for the client.
             *
             * @param edamVersionMinor
             *     This should be the major protocol version that was compiled by the
             *     client.    This should be the current value of the EDAM_VERSION_MINOR
             *     constant for the client.
             */
            checkVersion(clientName: string, edamVersionMajor: number, edamVersionMinor: number, cb: Callback<boolean>): void;

            /**
             * This provides bootstrap information to the client. Various bootstrap
             * profiles and settings may be used by the client to configure itself.
             *
             * @param locale
             *     The client's current locale, expressed in language[_country]
             *     format. E.g., "en_US". See ISO-639 and ISO-3166 for valid
             *     language and country codes.
             *
             * @return
             *     The bootstrap information suitable for this client.
             */
            getBootstrapInfo(locale: string, cb: Callback<BootstrapInfo>): void;

            /**
             * Revoke an existing long lived authentication token. This can be used to
             * revoke OAuth tokens or tokens created by calling authenticateLongSession,
             * and allows a user to effectively log out of Evernote from the perspective
             * of the application that holds the token. The authentication token that is
             * passed is immediately revoked and may not be used to call any authenticated
             * EDAM function.
             *
             * @param authenticationToken the authentication token to revoke.
             *
             * @throws EDAMUserException <ul>
             *     <li> DATA_REQUIRED "authenticationToken" - no authentication token provided
             *     <li> BAD_DATA_FORMAT "authenticationToken" - the authentication token is not well formed
             *     <li> INVALID_AUTH "authenticationToken" - the authentication token is invalid
             *     <li> AUTH_EXPIRED "authenticationToken" - the authentication token is expired or
             *         is already revoked.
             * </ul>
             */
            revokeLongSession(cb: Callback<void>): void;

            /**
             * This is used to take an existing authentication token that grants access
             * to an individual user account (returned from 'authenticate',
             * 'authenticateLongSession' or an OAuth authorization) and obtain an additional
             * authentication token that may be used to access business notebooks if the user
             * is a member of an Evernote Business account.
             *
             * The resulting authentication token may be used to make NoteStore API calls
             * against the business using the NoteStore URL returned in the result.
             *
             * @param authenticationToken
             *     The authentication token for the user. This may not be a shared authentication
             *     token (returned by NoteStore.authenticateToSharedNotebook or
             *     NoteStore.authenticateToSharedNote) or a business authentication token.
             *
             * @return
             *     The result of the authentication, with the token granting access to the
             *     business in the result's 'authenticationToken' field. The URL that must
             *     be used to access the business account NoteStore will be returned in the
             *     result's 'noteStoreUrl' field.    The 'User' field will
             *     not be set in the result.
             *
             * @throws EDAMUserException <ul>
             *     <li> PERMISSION_DENIED "authenticationToken" - the provided authentication token
             *                is a shared or business authentication token. </li>
             *     <li> PERMISSION_DENIED "Business" - the user identified by the provided
             *                authentication token is not currently a member of a business. </li>
             *     <li> PERMISSION_DENIED "Business.status" - the business that the user is a
             *                member of is not currently in an active status. </li>
             * </ul>
             */
            authenticateToBusiness(cb: Callback<AuthenticationResult>): void;

            /**
             * Returns the User corresponding to the provided authentication token,
             * or throws an exception if this token is not valid.
             * The level of detail provided in the returned User structure depends on
             * the access level granted by the token, so a web service client may receive
             * fewer fields than an integrated desktop client.
             */
            getUser(cb: Callback<User>): void;

            /**
             * Asks the UserStore about the publicly available location information for
             * a particular username.
             *
             * @throws EDAMUserException <ul>
             *     <li> DATA_REQUIRED "username" - username is empty
             * </ul>
             */
            getPublicUserInfo(username: string, cb: Callback<PublicUserInfo>): void;


            /**
             * Returns the URL that should be used to talk to the NoteStore for the
             * account represented by the provided authenticationToken.
             * This method isn't needed by most clients, who can retrieve the correct
             * NoteStore URL from the AuthenticationResult returned from the authenticate
             * or refreshAuthentication calls. This method is typically only needed
             * to look up the correct URL for a long-lived session token (e.g. for an
             * OAuth web service).
             */
            getNoteStoreUrl(cb: Callback<string>): void;
        }
        /**
         *    This structure is used to provide publicly-available user information
         *    about a particular account.
         * <dl>
         *    <dt>userId:</dt>
         *        <dd>
         *        The unique numeric user identifier for the user account.
         *        </dd>
         *    <dt>shardId:</dt>
         *        <dd>
         *        DEPRECATED - Client applications should have no need to use this field.
         *        </dd>
         *    <dt>privilege:</dt>
         *        <dd>
         *        The privilege level of the account, to determine whether
         *        this is a Premium or Free account.
         *        </dd>
         *    <dt>noteStoreUrl:</dt>
         *        <dd>
         *        This field will contain the full URL that clients should use to make
         *        NoteStore requests to the server shard that contains that user's data.
         *        I.e. this is the URL that should be used to create the Thrift HTTP client
         *        transport to send messages to the NoteStore service for the account.
         *        </dd>
         *    <dt>webApiUrlPrefix:</dt>
         *        <dd>
         *        This field will contain the initial part of the URLs that should be used
         *        to make requests to Evernote's thin client "web API", which provide
         *        optimized operations for clients that aren't capable of manipulating
         *        the full contents of accounts via the full Thrift data model. Clients
         *        should concatenate the relative path for the various servlets onto the
         *        end of this string to construct the full URL, as documented on our
         *        developer web site.
         *        </dd>
         *    </dl>
         */
        class PublicUserInfo {
            userId: number;
            shardId: string;
            privilege: PrivilegeLevel;
            username: string;
            noteStoreUrl: string;
            webApiUrlPrefix: string;

            constructor(args?: { userId: number; shardId: string; privilege?: PrivilegeLevel; username?: string; noteStoreUrl?: string; webApiUrlPrefix?: string; });
        }

        /**
         *    When an authentication (or re-authentication) is performed, this structure
         *    provides the result to the client.
         * <dl>
         *    <dt>currentTime:</dt>
         *        <dd>
         *        The server-side date and time when this result was
         *        generated.
         *        </dd>
         *    <dt>authenticationToken:</dt>
         *        <dd>
         *        Holds an opaque, ASCII-encoded token that can be
         *        used by the client to perform actions on a NoteStore.
         *        </dd>
         *    <dt>expiration:</dt>
         *        <dd>
         *        Holds the server-side date and time when the
         *        authentication token will expire.
         *        This time can be compared to "currentTime" to produce an expiration
         *        time that can be reconciled with the client's local clock.
         *        </dd>
         *    <dt>user:</dt>
         *        <dd>
         *        Holds the information about the account which was
         *        authenticated if this was a full authentication.    May be absent if this
         *        particular authentication did not require user information.
         *        </dd>
         *    <dt>publicUserInfo:</dt>
         *        <dd>
         *        If this authentication result was achieved without full permissions to
         *        access the full User structure, this field may be set to give back
         *        a more limited public set of data.
         *        </dd>
         *    <dt>noteStoreUrl:</dt>
         *        <dd>
         *        This field will contain the full URL that clients should use to make
         *        NoteStore requests to the server shard that contains that user's data.
         *        I.e. this is the URL that should be used to create the Thrift HTTP client
         *        transport to send messages to the NoteStore service for the account.
         *        </dd>
         *    <dt>webApiUrlPrefix:</dt>
         *        <dd>
         *        This field will contain the initial part of the URLs that should be used
         *        to make requests to Evernote's thin client "web API", which provide
         *        optimized operations for clients that aren't capable of manipulating
         *        the full contents of accounts via the full Thrift data model. Clients
         *        should concatenate the relative path for the various servlets onto the
         *        end of this string to construct the full URL, as documented on our
         *        developer web site.
         *        </dd>
         *    <dt>secondFactorRequired:</dt>
         *        <dd>
         *        If set to true, this field indicates that the user has enabled two-factor
         *        authentication and must enter their second factor in order to complete
         *        authentication. In this case the value of authenticationResult will be
         *        a short-lived authentication token that may only be used to make a
         *        subsequent call to completeTwoFactorAuthentication.
         *        </dd>
         *    <dt>secondFactorDeliveryHint:</dt>
         *        <dd>
         *        When secondFactorRequired is set to true, this field may contain a string
         *        describing the second factor delivery method that the user has configured.
         *        This will typically be an obfuscated mobile device number, such as
         *        "(xxx) xxx-x095". This string can be displayed to the user to remind them
         *        how to obtain the required second factor.
         *        TODO do we need to differentiate between SMS and voice delivery?
         *        </dd>
         *    </dl>
         */
        class AuthenticationResult {
            currentTime: number;
            authenticationToken: string;
            expiration: number;
            user: User;
            publicUserInfo: PublicUserInfo;
            noteStoreUrl: string;
            webApiUrlPrefix: string;
            secondFactorRequired: boolean;
            secondFactorDeliveryHint: string;

            constructor(args?: { currentTime: number; authenticationToken: string; expiration: number; user?: User; publicUserInfo?: PublicUserInfo; noteStoreUrl?: string; webApiUrlPrefix?: string; secondFactorRequired?: boolean; secondFactorDeliveryHint?: string; });
        }

        /**
         *    This structure describes a collection of bootstrap settings.
         * <dl>
         *    <dt>serviceHost:</dt>
         *        <dd>
         *        The hostname and optional port for composing Evernote web service URLs.
         *        This URL can be used to access the UserStore and related services,
         *        but must not be used to compose the NoteStore URL. Client applications
         *        must handle serviceHost values that include only the hostname
         *        (e.g. www.evernote.com) or both the hostname and port (e.g. www.evernote.com:8080).
         *        If no port is specified, or if port 443 is specified, client applications must
         *        use the scheme "https" when composing URLs. Otherwise, a client must use the
         *        scheme "http".
         *    </dd>
         *    <dt>marketingUrl:</dt>
         *        <dd>
         *        The URL stem for the Evernote corporate marketing website, e.g. http://www.evernote.com.
         *        This stem can be used to compose website URLs. For example, the URL of the Evernote
         *        Trunk is composed by appending "/about/trunk/" to the value of marketingUrl.
         *        </dd>
         *    <dt>supportUrl:</dt>
         *        <dd>
         *        The full URL for the Evernote customer support website, e.g. https://support.evernote.com.
         *        </dd>
         *    <dt>accountEmailDomain:</dt>
         *        <dd>
         *        The domain used for an Evernote user's incoming email address, which allows notes to
         *        be emailed into an account. E.g. m.evernote.com.
         *        </dd>
         *    <dt>enableFacebookSharing:</dt>
         *        <dd>
         *        Whether the client application should enable sharing of notes on Facebook.
         *        </dd>
         *    <dt>enableGiftSubscriptions:</dt>
         *        <dd>
         *        Whether the client application should enable gift subscriptions.
         *        </dd>
         *    <dt>enableSupportTickets:</dt>
         *        <dd>
         *        Whether the client application should enable in-client creation of support tickets.
         *        </dd>
         *    <dt>enableSharedNotebooks:</dt>
         *        <dd>
         *        Whether the client application should enable shared notebooks.
         *        </dd>
         *    <dt>enableSingleNoteSharing:</dt>
         *        <dd>
         *        Whether the client application should enable single note sharing.
         *        </dd>
         *    <dt>enableSponsoredAccounts:</dt>
         *        <dd>
         *        Whether the client application should enable sponsored accounts.
         *        </dd>
         *    <dt>enableTwitterSharing:</dt>
         *        <dd>
         *        Whether the client application should enable sharing of notes on Twitter.
         *        </dd>
         *    </dl>
         */
        class BootstrapSettings {
            serviceHost: string;
            marketingUrl: string;
            supportUrl: string;
            accountEmailDomain: string;
            enableFacebookSharing: boolean;
            enableGiftSubscriptions: boolean;
            enableSupportTickets: boolean;
            enableSharedNotebooks: boolean;
            enableSingleNoteSharing: boolean;
            enableSponsoredAccounts: boolean;
            enableTwitterSharing: boolean;
            enableLinkedInSharing: boolean;
            enablePublicNotebooks: boolean;

            constructor(args?: { serviceHost: string; marketingUrl: string; supportUrl: string; accountEmailDomain: string; enableFacebookSharing?: boolean; enableGiftSubscriptions?: boolean; enableSupportTickets?: boolean; enableSharedNotebooks?: boolean; enableSingleNoteSharing?: boolean; enableSponsoredAccounts?: boolean; enableTwitterSharing?: boolean; enableLinkedInSharing?: boolean; enablePublicNotebooks?: boolean; });
        }

        /**
         *    This structure describes a collection of bootstrap settings.
         * <dl>
         *    <dt>name:</dt>
         *        <dd>
         *        The unique name of the profile, which is guaranteed to remain consistent across
         *        calls to getBootstrapInfo.
         *        </dd>
         *    <dt>settings:</dt>
         *        <dd>
         *        The settings for this profile.
         *        </dd>
         *    </dl>
         */
        class BootstrapProfile {
            name: string;
            settings: BootstrapSettings;

            constructor(args?: { name: string; settings: BootstrapSettings; });
        }

        /**
         *    This structure describes a collection of bootstrap profiles.
         * <dl>
         *    <dt>profiles:</dt>
         *        <dd>
         *        List of one or more bootstrap profiles, in descending
         *        preference order.
         *        </dd>
         *    </dl>
         */
        class BootstrapInfo {
            profiles: BootstrapProfile[];

            constructor(args?: { profiles: BootstrapProfile[]; });
        }

        /**
         * The major version number for the current revision of the EDAM protocol.
         * Clients pass this to the service using UserStore.checkVersion at the
         * beginning of a session to confirm that they are not out of date.
         */
        var EDAM_VERSION_MAJOR: number;

        /**
         * The minor version number for the current revision of the EDAM protocol.
         * Clients pass this to the service using UserStore.checkVersion at the
         * beginning of a session to confirm that they are not out of date.
         */
        var EDAM_VERSION_MINOR: number;

    }
}