@isrd-isi-edu/ermrestjs 2.0.0

package/dist/ermrest.d.ts

@@ -0,0 +1,3481 @@
+import { AttributeGroupColumn } from '../js/ag_reference';
+import { AttributeGroupLocation } from '../js/ag_reference';
+import { AttributeGroupReference } from '../js/ag_reference';
+import { AttributeGroupReference as AttributeGroupReference_2 } from '../../../js/ag_reference';
+import { AxiosStatic } from 'axios';
+import { BinaryPredicate } from '../js/filters';
+import { BucketAttributeGroupReference } from '../js/ag_reference';
+import { BucketAttributeGroupReference as BucketAttributeGroupReference_2 } from '../../../js/ag_reference';
+import { Catalog } from '../../../js/core';
+import { Catalog as Catalog_2 } from '../../js/core';
+import { Checksum } from '../js/hatrac';
+import { Column } from '../../../js/core';
+import { Column as Column_2 } from '../../js/core';
+import { createLocation } from '../js/parser';
+import { createPath } from '../js/parser';
+import { createSearchPath } from '../js/parser';
+import { _currDate } from '../js/utils/helpers';
+import { DataPath } from '../js/datapath';
+import { decodeFacet } from '../js/utils/helpers';
+import { default as default_2 } from 'q';
+import { default as default_3 } from 'handlebars';
+import { encodeFacet } from '../js/utils/helpers';
+import { encodeFacetString } from '../js/utils/helpers';
+import { ermrestFactory } from '../js/core';
+import { Exporter } from '../js/export';
+import { ForeignKeyRef } from '../../../js/core';
+import { ForeignKeyRef as ForeignKeyRef_2 } from '../../js/core';
+import { _formatUtils } from '../js/utils/helpers';
+import { getElapsedTime } from '../js/setup/node';
+import { Key } from '../../../js/core';
+import { Key as Key_2 } from '../../js/core';
+import { Location as Location_2 } from '../../../js/parser';
+import { onload as onload_2 } from '../js/setup/node';
+import { parse } from '../js/parser';
+import { default as printf } from '../js/format';
+import { processMarkdownPattern } from '../js/utils/helpers';
+import { renderMustacheTemplate } from '../js/utils/helpers';
+import { Server } from '../../../js/core';
+import { Table } from '../../js/core';
+import { Table as Table_2 } from '../../../js/core';
+import { Type } from '../../../js/core';
+import { Upload } from '../js/hatrac';
+import { default as validateJSONLD } from '../js/json_ld_validator.js';
+import { _validateMustacheTemplate } from '../js/utils/helpers';
+
+declare type ActiveList = {
+    requests: any[];
+    allOutBounds: Array<ForeignKeyPseudoColumn | PseudoColumn>;
+    selfLinks: Array<KeyPseudoColumn>;
+};
+
+export declare const appLinkFn: typeof ConfigService.setAppLinkFn;
+
+declare type AppLinkFnType = (tag: string, location: any, context: string) => string;
+
+declare type AssetMetadata = {
+    url: string;
+    caption: string;
+    filename: string;
+    byteCount: string;
+    md5: string;
+    sha256: string;
+    sameHost: boolean;
+    hostInformation: string;
+};
+
+/**
+ * @class
+ * @param {Reference} reference column's reference
+ * @param {Column} column the asset column
+ * @param {SourceObjectWrapper} sourceObjectWrapper the source object wrapper
+ * @param {string=} name the name of this column
+ *
+ * @property {string} urlPattern  A desired upload location can be derived by Pattern Expansion on pattern.
+ * @property {(Column|null)} filenameColumn if it's string, then it is the name of column we want to store filename inside of it.
+ * @property {(Column|null)} byteCountColumn if it's string, then it is the name of column we want to store byte count inside of it.
+ * @property {(Column|boolean|null)} md5 if it's string, then it is the name of column we want to store md5 inside of it. If it's true, that means we must use md5.
+ * @property {(Column|boolean|null)} sha256 if it's string, then it is the name of column we want to store sha256 inside of it. If it's true, that means we must use sha256.
+ * @property {(string[]|null)} filenameExtFilter set of filename extension filters for use by upload agents to indicate to the user the acceptable filename patterns.
+ *
+ * @desc
+ * Constructor for AssetPseudoColumn.
+ * This class is a wrapper for {@link Column} objects that have asset annotation.
+ * This class extends the {@link ReferenceColumn}
+ */
+declare class AssetPseudoColumn extends ReferenceColumn {
+    /**
+     * @type {boolean}
+     * @desc indicates that this object represents a PseudoColumn.
+     */
+    isPseudo: boolean;
+    /**
+     * @type {boolean}
+     * @desc Indicates that this ReferenceColumn is an asset.
+     */
+    isAsset: boolean;
+    private _baseCol;
+    private _annotation;
+    private _templateEngine?;
+    private _urlPattern?;
+    private _filenameColumn?;
+    private _byteCountColumn?;
+    private _md5?;
+    private _sha256?;
+    private _filenamePattern?;
+    private _filenameExtFilter?;
+    private _filenameExtRegexp?;
+    private _displayImagePreview?;
+    private _filePreview?;
+    constructor(reference: Reference, column: Column, sourceObjectWrapper?: SourceObjectWrapper, name?: string, mainTuple?: Tuple);
+    /**
+     * If url_pattern is invalid or browser_upload=false the input will be disabled.
+     * @param  {string} context the context
+     * @return {boolean|object}
+     */
+    protected _determineInputDisabled(context: string): boolean | {
+        message: string;
+    };
+    /**
+     * Given the data, will return the appropriate metadata values. The returned object
+     * will have the following attributes:
+     * - filename
+     * - byteCount
+     * - md5
+     * - sha256
+     * - origin
+     * - caption: the string that can be used for showing the selected file.
+     * The heuristics for origin and caption:
+     *   1. if filenameColumn is defined and its value is not null, use it as caption.
+     *   2. otherwise, if the url is from hatrac, extract the filename and use it as caption.
+     *   3. otherwise, use the last part of url as caption. in detailed context, if url is absolute find the origin.
+     * @param  {Object} data    key-value pair of data
+     * @param  {String} context context string
+     * @param  {Object} options
+     * @return {Object} metadata object with `caption`, `filename`, `byteCount`, `md5`, and `sha256` attributes.
+     */
+    getMetadata(data: any, context?: string, options?: any): AssetMetadata;
+    /**
+     * Format the presentation value corresponding to this asset definition.
+     * 1. return the raw data in entry contexts.
+     * 2. otherwise if it has wait-for return empty.
+     * 3. otherwise if column-display is defined, use it.
+     * 4. otherwise if value is null, return null.
+     * 5. otherwise use getMetadata to genarate caption and origin and return a download button.
+     *
+     * @param {Object} data the raw data of the table
+     * @param {String=} context the app context (optional)
+     * @param {Object=} templateVariables the template variables that should be used (optional)
+     * @param {Object=} options (optional)
+     * @returns {Object} A key value pair containing value and isHTML that detemrines the presentation.
+     */
+    formatPresentation(data: any, context?: string, templateVariables?: any, options?: any): any;
+    /**
+     * Modify the default column_order heuristics for the asset, by using the filename
+     * if
+     *  - the filename_column is defined and valid
+     *  - column_order is not defined on the column-display
+     * This has been done to ensure the sorted column is the same as displayed value.
+     * In most default cases, all the conditions will met.
+     * @private
+     */
+    protected _determineSortable(): void;
+    /**
+     * Returns the template_engine defined in the annotation
+     */
+    get templateEngine(): string;
+    /**
+     * Returns the url_pattern defined in the annotation (the raw value and not computed).
+     */
+    get urlPattern(): string;
+    /**
+     * The column object that filename is stored in.
+     */
+    get filenameColumn(): Column | null;
+    /**
+     * The column object that byte count is stored in.
+     */
+    get byteCountColumn(): Column | null;
+    /**
+     * The column object that md5 hash is stored in.
+     */
+    get md5(): Column | boolean | null;
+    /**
+     * The column object that sha256 hash is stored in.
+     */
+    get sha256(): Column | boolean | null;
+    /**
+     * Returns the stored filename pattern.
+     */
+    get filenamePattern(): string;
+    /**
+     * The column object that file extension is stored in.
+     */
+    get filenameExtFilter(): string[];
+    /**
+     * The regular expressions that will be used for extracting the extension
+     */
+    get filenameExtRegexp(): string[];
+    /**
+     * whether we should show the image preview or not
+     */
+    get displayImagePreview(): boolean;
+    /**
+     * whether we should show the file preview or not
+     */
+    get filePreview(): null | {
+        showCsvHeader: boolean;
+    };
+    /**
+     * Returns the wait for list for this column.
+     */
+    get waitFor(): VisibleColumn[];
+}
+
+export { AttributeGroupColumn }
+
+export { AttributeGroupLocation }
+
+export { AttributeGroupReference }
+
+export declare class AuthnService {
+    private static _session;
+    static setClientSession(session: object): void;
+    static get session(): any;
+    /**
+     * check if at least one of the groups in the groupArray is included in the session attributes.
+     * If the groupArray is null or contains "*", it will return true.
+     * @param groupArray the array of globus group IDs
+     * @param session the session object to check against (if not provided, it will use the current session)
+     */
+    static isUserInAcl(groupArray: string[] | null, session?: any): boolean;
+}
+
+export declare class BadGatewayError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+export declare class BadRequestError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+export declare class BatchDeleteResponse extends ERMrestError {
+    successTupleData: any;
+    failedTupleData: any;
+    constructor(successTupleData: any, failedTupleData: any, subMessage?: string);
+}
+
+export declare class BatchUnlinkResponse extends ERMrestError {
+    successTupleData: any;
+    failedTupleData: any;
+    constructor(successTupleData: any, failedTupleData: any, subMessage?: string);
+}
+
+export { BinaryPredicate }
+
+export { BucketAttributeGroupReference }
+
+/**
+ * Constructor to create a BulkCreateForeignKeyObject object
+ *
+ * NOTE: Potential improvement to the heuristics when there is no annotation defined
+ *   if we have:
+ *     - >2 FK columns
+ *     - there is a key with 2 foreign key columns in it
+ *     - that key includes the _mainColumn mentioned in prefillObject
+ *   should we assume that's the main/leaf columns for the association?
+ */
+declare class BulkCreateForeignKeyObject {
+    private _reference;
+    private _prefillObject;
+    private _mainColumn;
+    private _leafColumn;
+    private _isUnique;
+    private _disabledRowsFilters?;
+    private _andFilters?;
+    /**
+     * @param reference reference for the association table
+     * @param prefillObject generated prefill object from chaise after extracting the query param and fetching the data from cookie storage
+     * @param fkCols set of foreignkey columns that are not system columns (they might be overlapping so we're not using array)
+     * @param mainColumn the column from the assocation table that points to the main table in the association
+     * @param leafColumn the column from the assocation table that points to the leaf table in the association we are selecting rows from to associate to main
+     */
+    constructor(reference: Reference, prefillObject: any, fkCols: Record<string, boolean>, mainColumn: ForeignKeyPseudoColumn, leafColumn: ForeignKeyPseudoColumn);
+    /**
+     * the column that points to the table that rows are being selected from
+     */
+    get leafColumn(): ForeignKeyPseudoColumn;
+    /**
+     * if the 2 foreign key columns are part of a unqiue key
+     */
+    get isUnique(): boolean;
+    /**
+     * @returns filters array for getting the rows that should be disabled
+     */
+    disabledRowsFilter(): any[];
+    /**
+     * @returns filters array to use on leafColumn.reference for ensuring rows from the table are only able to be added if their key information is not null
+     */
+    andFiltersForLeaf(): any[];
+}
+
+declare class CatalogService {
+    private static constraintNames;
+    static addConstraintName(catalogId: string, schemaName: string, constraintName: string, obj: any, subject: _constraintTypes): void;
+    static getConstraintObject(catalogId: string, schemaName: string, constraintName: string, subject?: _constraintTypes): {
+        subject: _constraintTypes;
+        object: Key_2 | ForeignKeyRef_2;
+        RID: string;
+    } | null;
+    static clearConstraintNames(): void;
+}
+
+export declare const _certifyContextHeader: typeof HTTPService.certifyContextHeader;
+
+export { Checksum }
+
+declare class ChoiceFacetFilter extends FacetFilter {
+    facetFilterKey: string;
+    constructor(value: unknown, column: Column);
+}
+
+/**
+ * Constructs a citation for the given tuple.
+ * The given citationAnnotation must be valid and have the appropriate variables.
+ */
+declare class Citation {
+    private _table;
+    private _citationAnnotation;
+    waitFor: VisibleColumn[];
+    hasWaitFor: boolean;
+    hasWaitForAggregate: boolean;
+    constructor(reference: Reference, citationAnnotation: CitationAnnotation);
+    /**
+     * Given the templateVariables variables, will generate the citaiton.
+     * @param tuple - the tuple object that this citaiton is based on
+     * @param templateVariables - if it's not an obect, we will use the tuple templateVariables
+     * @return if the returned template for required attributes are empty, it will return null.
+     */
+    compute(tuple: Tuple, templateVariables?: any): CitationObject | null;
+}
+
+declare interface CitationAnnotation {
+    journal_pattern?: string;
+    year_pattern?: string;
+    url_pattern?: string;
+    author_pattern?: string;
+    title_pattern?: string;
+    id_pattern?: string;
+    template_engine?: string;
+    wait_for?: any;
+}
+
+declare interface CitationObject {
+    author?: string | null;
+    title?: string | null;
+    journal?: string | null;
+    year?: string | null;
+    url?: string | null;
+    id?: string | null;
+}
+
+export declare const _clearConstraintNames: typeof CatalogService.clearConstraintNames;
+
+/**
+ * Constructs an Aggregate Function object
+ *
+ * Column Aggregate Functions is a collection of available aggregates for the
+ * particular ReferenceColumn (min, max, count not null, and count distinct for it's column).
+ * Each aggregate should return the string representation for querying for that information.
+ *
+ * Usage:
+ *  Clients _do not_ directly access this constructor. ERMrest.ReferenceColumn
+ *  will access this constructor for purposes of fetching aggregate data
+ *  for a specific column
+ */
+declare class ColumnAggregateFn {
+    column: ReferenceColumn;
+    constructor(column: ReferenceColumn);
+    /**
+     * minimum aggregate representation
+     */
+    get minAgg(): string;
+    /**
+     * maximum aggregate representation
+     */
+    get maxAgg(): string;
+    /**
+     * not null count aggregate representation
+     */
+    get countNotNullAgg(): string;
+    /**
+     * distinct count aggregate representation
+     */
+    get countDistinctAgg(): string;
+}
+
+/**
+ * Can be used to access group aggregate functions.
+ * Usage:
+ *  Clients _do not_ directly access this constructor. ERMrest.ReferenceColumn
+ *  will access this constructor for purposes of fetching grouped aggregate data
+ *  for a specific column
+ */
+declare class ColumnGroupAggregateFn {
+    column: ReferenceColumn;
+    private _ref;
+    constructor(column: ReferenceColumn, ref: Reference);
+    /**
+     * Will return a compact/select attribute group reference which can be used to show distinct values and their counts
+     * The result is based on shortest key of the parent table. If we have join
+     * in the path, we are counting the shortest key of the parent table (not the end table).
+     * NOTE: Will create a new reference by each call.
+     * @param columnDisplayname the displayname of main column.
+     * @param sortColumns the sort column object that you want to pass
+     * @param hideNumOccurrences whether we should add number of Occurrences or not.
+     * @param dontAllowNull whether the null value should be returned for the facet or not.
+     * @returns AttributeGroupReference
+     */
+    entityCounts(columnDisplayname?: DisplayName | string, sortColumns?: SortColumn[], hideNumOccurrences?: boolean, dontAllowNull?: boolean): AttributeGroupReference_2;
+    /**
+     * Given number of buckets, min and max will return bin of results.
+     * The result is based on shortest key of the parent table. If we have join
+     * in the path, we are creating the histogram based on shortest key of the
+     * parent table (not the end table).
+     * @param bucketCount number of buckets
+     * @param min minimum value
+     * @param max maximum value
+     * @return BucketAttributeGroupReference
+     */
+    histogram(bucketCount: number, min: any, max: any): BucketAttributeGroupReference_2;
+}
+
+declare enum CommentDisplayModes {
+    INLINE = "inline",
+    TOOLTIP = "tooltip"
+}
+
+declare type CommentType = {
+    value: string;
+    isHTML: boolean;
+    unformatted: string;
+    displayMode: CommentDisplayModes;
+} | false | null;
+
+declare class ConfigService {
+    private static _http;
+    private static _q;
+    private static _clientConfig;
+    private static _appLinkFn;
+    private static _systemColumnsHeuristicsMode;
+    private static _markdownItDefaultLinkOpenRenderer;
+    /**
+     * This function is used to configure the module
+     * Notes:
+     * - if this configure function is not called, we're going to use axios by default.
+     * - The second parameter is not used and only added for backwards compatibility.
+     * @param http any http service (like Angular $http or axios)
+     * @param q Any promise library (like Angular $q or Q library)
+     */
+    static configure(http: any, q: any): void;
+    static get http(): AxiosStatic;
+    static get q(): typeof default_2;
+    /**
+     * This function will be called to set the config object
+     */
+    static setClientConfig(clientConfig: any): Promise<void>;
+    static get clientConfig(): any;
+    /**
+     * check whether the client config is set or not
+     */
+    static verifyClientConfig(dontThrowError?: boolean): boolean;
+    static setAppLinkFn(fn: AppLinkFnType): void;
+    /**
+     * Given an app tag, location object and context will return the full url.
+     * @param tag the tag that is defined in the annotation. If null, should use context.
+     * @param location the location object that ERMrest will return.
+     * @param context - optional, used to determine default app if tag is null/undefined
+     */
+    static get appLinkFn(): AppLinkFnType;
+    static setSystemColumnsHeuristicsMode(fn: (context: string) => any): void;
+    static get systemColumnsHeuristicsMode(): (context: string) => any | undefined;
+    /**
+     * @private
+     * @desc
+     * Change the link_open function to add classes to links, based on clientConfig
+     * It will add
+     *  - external-link-icon
+     *  - exteranl-link if clientConfig.disableExternalLinkModal is not true
+     *
+     * NOTE we should call this function only ONCE when the setClientConfig is done
+     */
+    static _markdownItLinkOpenAddExternalLink(): void;
+    /**
+     * Expose authCookie function, to reset ermrest cookie
+     * NOTE meant to be used only in node environments
+     */
+    static resetUserCookie(): void;
+    /**
+     * Expose authCookie function, to set ermrest cookie
+     * NOTE meant to be used only in node environments
+     */
+    static setUserCookie(authCookie: string): void;
+}
+
+export declare const configure: typeof ConfigService.configure;
+
+export declare class ConflictError extends ERMrestError {
+    constructor(status: string, message: string, subMessage?: string);
+}
+
+declare enum _constraintTypes {
+    KEY = "k",
+    FOREIGN_KEY = "fk"
+}
+
+export declare const contextHeaderName = "Deriva-Client-Context";
+
+/**
+ * Contructs the Contextualize object.
+ *
+ * Usage:
+ * Clients _do not_ directly access this constructor.
+ * See {@link Reference#contextualize}
+ *
+ * It will be used for creating contextualized references.
+ */
+declare class Contextualize {
+    private _reference;
+    constructor(reference: Reference);
+    /**
+     * The _record_ context of this reference.
+     */
+    get detailed(): Reference;
+    /**
+     * The _compact_ context of this reference.
+     */
+    get compact(): Reference;
+    /**
+     * The _compact/brief_ context of this reference.
+     */
+    get compactBrief(): Reference;
+    /**
+     * The _compact/select_ context of this reference.
+     */
+    get compactSelect(): Reference;
+    /**
+     * The _compact/select/association_ context of this reference.
+     */
+    get compactSelectAssociation(): Reference;
+    /**
+     * The _compact/select/association/link_ context of this reference.
+     */
+    get compactSelectAssociationLink(): Reference;
+    /**
+     * The _compact/select/association/unlink_ context of this reference.
+     */
+    get compactSelectAssociationUnlink(): Reference;
+    /**
+     * The _compact/select/foreign_key_ context of this reference.
+     */
+    get compactSelectForeignKey(): Reference;
+    /**
+     * The _compact/select/foreign_key/bulk_ context of this reference.
+     */
+    get compactSelectBulkForeignKey(): Reference;
+    /**
+     * The _compact/select/saved_queries_ context of this reference.
+     */
+    get compactSelectSavedQueries(): Reference;
+    /**
+     * The _compact/select/show_more_ context of this reference.
+     */
+    get compactSelectShowMore(): Reference;
+    /**
+     * The _entry_ context of this reference.
+     */
+    get entry(): Reference;
+    /**
+     * The _entry/create_ context of this reference.
+     */
+    get entryCreate(): Reference;
+    /**
+     * The _entry/edit_ context of this reference.
+     */
+    get entryEdit(): Reference;
+    /**
+     * The _entry/compact_ context of this reference.
+     */
+    get compactEntry(): Reference;
+    /**
+     * get compactBriefInline - The compact brief inline context of the reference
+     */
+    get compactBriefInline(): Reference;
+    /**
+     * get Export - export context
+     */
+    get export(): Reference;
+    /**
+     * get exportCompact - export context for compact view
+     */
+    get exportCompact(): Reference;
+    /**
+     * get exportDetailed - export context for detailed view
+     */
+    get exportDetailed(): Reference;
+    private _contextualize;
+}
+
+export { createLocation }
+
+export declare const _createPage: (reference: Reference, etag: string, data: any, hasPrevious: boolean, hasNext: boolean) => Page;
+
+export { createPath }
+
+export { createSearchPath }
+
+export { _currDate }
+
+export { DataPath }
+
+export { decodeFacet }
+
+declare class DerivedAssociationReference extends Reference {
+    private _origFKR;
+    private _associationToRelatedFKR;
+    constructor(location: Location_2, catalog: Catalog, origFKR: ForeignKeyRef, associationToRelatedFKR: ForeignKeyRef);
+    /**
+     * the main tuple
+     */
+    get associationToRelatedFKR(): ForeignKeyRef;
+    get origFKR(): ForeignKeyRef;
+    copy(): DerivedAssociationReference;
+}
+
+declare type DisplayName = {
+    value: string | null;
+    isHTML: boolean;
+    unformatted?: string | null;
+};
+
+export declare class DuplicateConflictError extends ConflictError {
+    duplicateReference: any;
+    constructor(status: string, message: string, subMessage?: string, duplicateReference?: any);
+}
+
+export { encodeFacet }
+
+export { encodeFacetString }
+
+/**
+ * @memberof ERMrest
+ * @param  {int} code           http error code
+ * @param  {string} status      message status/title in the modal box
+ * @param  {string} message     main user error message
+ * @param  {string} subMessage  technical details about the error. Appear in collapsible span in the modal box
+ * @param  {string} redirectPath path that would be added to the host to create full redirect link in Chaise
+ * @constructor
+ */
+export declare class ERMrestError extends Error {
+    code: string | number;
+    status: string;
+    message: string;
+    subMessage?: string | undefined;
+    errorData: {
+        redirectPath?: string;
+    };
+    constructor(code: string | number, status: string, message: string, subMessage?: string | undefined, redirectPath?: string);
+}
+
+export { ermrestFactory }
+
+declare class ErrorService {
+    /**
+     * Log the error object to the given ermrest location.
+     * It will generate a put request to the /terminal_error with the correct headers.
+     * ermrset will return a 400 page, but will log the message.
+     * @param  {object} err             the error object
+     * @param  {string} ermrestLocation the ermrest location
+     */
+    static logError(err: any, ermrestLocation: any, contextHeaderParams?: any): Promise<void>;
+    /**
+     * create an error object from http response
+     * @param response http response object
+     * @param reference the reference object
+     * @param ctionFlag the flag that signals the action that the error occurred from
+     */
+    static responseToError(response: any, reference?: any, actionFlag?: string): Error;
+    /**
+     * @function
+     * @param  {string} errorStatusText    http error status text
+     * @param  {string} generatedErrMessage response data returned by http request
+     * @return {object}                    error object
+     * @desc
+     *  - Integrity error message: This entry cannot be deleted as it is still referenced from the Human Age table.
+     *                           All dependent entries must be removed before this item can be deleted.
+     *  - Duplicate error message: The entry cannot be created/updated. Please use a different ID for this record.
+     *                            Or (The entry cannot be created. Please use a combination of different _fields_ to create new record.)
+     *
+     */
+    private static _conflictErrorMapping;
+}
+
+export { Exporter }
+
+declare interface FacetChoiceDisplayName {
+    uniqueId: any;
+    displayname: DisplayName;
+    tuple: Tuple | null;
+}
+
+/**
+ * @param {Reference} reference the reference that this FacetColumn blongs to.
+ * @param {int} index The index of this FacetColumn in the list of facetColumns
+ * @param {SourceObjectWrapper} facetObjectWrapper The filter object that this FacetColumn will be created based on
+ * @param {?FacetFilter[]} filters Array of filters
+ */
+declare class FacetColumn {
+    /**
+     * The column object that the filters are based on
+     */
+    _column: Column;
+    /**
+     * The reference that this facet blongs to
+     */
+    reference: Reference;
+    /**
+     * The index of facetColumn in the list of facetColumns
+     * NOTE: Might not be needed
+     */
+    index: number;
+    /**
+     * A valid data-source path
+     * NOTE: we're not validating this data-source, we assume that this is valid.
+     */
+    dataSource: any;
+    /**
+     * the compressed version of data source data-source path
+     */
+    compressedDataSource: any;
+    /**
+     * Filters that are applied to this facet.
+     */
+    filters: Array<FacetFilter | NotNullFacetFilter>;
+    _facetObject: any;
+    sourceObjectWrapper: SourceObjectWrapper;
+    sourceObjectNodes: SourceObjectNode[];
+    lastForeignKeyNode?: SourceObjectNode;
+    foreignKeyPathLength: number;
+    /**
+     * Whether the source has path or not
+     */
+    hasPath: boolean;
+    /**
+     * Returns true if the source is on a key column.
+     * If facetObject['entity'] is defined as false, it will return false,
+     * otherwise it will true if filter is based on key.
+     */
+    isEntityMode: boolean;
+    private _isOpen?;
+    private _preferredMode?;
+    private _barPlot?;
+    private _numBuckets?;
+    private _referenceColumn?;
+    private _sourceReference?;
+    private _displayname?;
+    private _comment?;
+    private _hideNullChoice?;
+    private _hideNotNullChoice?;
+    private _hideNumOccurrences?;
+    private _sortColumns?;
+    private _scalarValuesRef?;
+    private _fastFilterSource?;
+    private _hasNotNullFilter?;
+    private _hasNullFilter?;
+    private _searchFilters?;
+    private _choiceFilters?;
+    private _rangeFilters?;
+    constructor(reference: Reference, index: number, facetObjectWrapper: SourceObjectWrapper, filters?: Array<FacetFilter | NotNullFacetFilter>);
+    /**
+     * If has filters it will return true,
+     * otherwise returns facetObject['open']
+     */
+    get isOpen(): boolean;
+    /**
+     * The Preferred ux mode.
+     * Any of:
+     * `choices`, `ranges`, or `check_presence`
+     * This should be used if we're not in entity mode. In entity mode it will
+     * always return `choices`.
+     *
+     * The logic is as follows,
+     * 1. if facet has only choice or range filter, return that.
+     * 2. use ux_mode if available
+     * 3. use choices if in entity mode
+     * 4. return choices if int or serial, part of key, and not null.
+     * 5. return ranges or choices based on the type.
+     *
+     *  Note:
+     *   - null and not-null are applicaple in all types, so we're ignoring those while figuring out the preferred mode.
+     */
+    get preferredMode(): string;
+    /**
+     * Returns true if the plotly histogram graph should be shown in the UI
+     * If _facetObject.barPlot is not defined, the value is true. By default
+     * the histogram should be shown unless specified otherwise
+     */
+    get barPlot(): boolean;
+    /**
+     * Returns the value of `barPlot.nBins` if it was defined as part of the
+     * `facetObject` in the annotation. If undefined, the default # of buckets is 30
+     */
+    get histogramBucketCount(): number;
+    /**
+     * ReferenceColumn that this facetColumn is based on
+     */
+    get column(): ReferenceColumn;
+    /**
+     * uncontextualized {@link ERMrest.Reference} that has all the joins specified
+     * in the source with all the filters of other FacetColumns in the reference.
+     *
+     * The returned reference will be in the following format:
+     * <main-table>/<facets of main table except current facet>/<path to current facet>
+     *
+     *
+     * Consider the following scenario:
+     * Table T has two foreignkeys to R1 (fk1), R2 (fk2), and R3 (fk3).
+     * R1 has a fitler for term=1, and R2 has a filter for term=2
+     * Then the source reference for R3 will be the following:
+     * T:=S:T/(fk1)/term=1/$T/(fk2)/term2/$T/M:=(fk3)
+     * As you can see it has all the filters of the main table + join to current table.
+     *
+     * Notes:
+     * - This function used to reverse the path from the current facet to each of the
+     *   other facets in the main reference. Since this was very inefficient, we decided
+     *   to rewrite it to start from the main table instead.
+     * - The path from the main table to facet is based on the given column directive and
+     *   therefore might have filters or reused table instances (shared path). That's why
+     *   we're ensuring to pass the whole facetObjectWrapper to parser, so it can properly
+     *   parse it.
+     */
+    get sourceReference(): Reference;
+    /**
+     * Returns the displayname object that should be used for this facetColumn.
+     * TODO the heuristics should be changed to be aligned with PseudoColumn
+     * Heuristics are as follows (first applicable rule):
+     *  0. If markdown_name is defined, use it.
+     *  1. If column is part of the main table (there's no join), use the column's displayname.
+     *  2. If last foreignkey is outbound and has to_name, use it.
+     *  3. If last foreignkey is inbound and has from_name, use it.
+     *  4. Otherwise use the table name.
+     *    - If it's in `scalar` mode, append the column name. `table_name (column_name)`.
+     *
+     * Returned object has `value`, `unformatted`, and `isHTML` properties.
+     */
+    get displayname(): DisplayName;
+    /**
+     * Could be used as tooltip to provide more information about the facetColumn
+     */
+    get comment(): CommentType;
+    /**
+     * Whether client should hide the null choice.
+     *
+     * Before going through the logic, it's good to know the following:
+     * -`null` filter could mean any of the following:
+     *   - Scalar value being `null`. In terms of ermrest, a simple col::null:: query
+     *   - No value exists in the given path (checking presence of a value in the path). In terms of ermrest,
+     *     we have to construct an outer join. For performance we're going to use right outer join.
+     *     Because of ermrest limitation, we cannot have more than two right outer joins and therefore
+     *     two such null checks cannot co-exist.
+     * - Since we're not going to show two different options for these two meanings,
+     *   we have to make sure to offer `null` option when only one of these two meanings would make sense.
+     * - There are some cases when the `null` is not even possible based on the model. So we shouldn't offer this option.
+     * - Due to ermrest and our parse limitations, facets with filter cannot support null.
+     *
+     * Therefore, the following is the logic for this function:
+     *   1. If the facet already has `null` filter, return `false`.
+     *   2. If facet has `"hide_null_choice": true`, return `true`.
+     *   3. If facet has filer, return `true` as our parse can't handle it.
+     *   4. If it's a local column,
+     *     4.1. if it's not-null, return `true`.
+     *     4.2. if it's nullable, return `false`.
+     *   5. If it's an all-outbound path where all the columns in the path are not-null,
+     *     5.1. If the end column is nullable, return `false` as null value only means scalar value being null.
+     *     5.2. If the end column is not-null, return `true` as null value is not possible.
+     *   6. For any other paths, if the end column is nullable, `null` filter could mean both scalar and path. so return `true`.
+     *   7. Facets with only one hop where the column used in foreignkey is the same column for faceting.
+     *      In this case, we can completely ignore the foreignkey path and just do a value check on main table. so return `false`.
+     *   8. any other cases (facet with arbiarty path),
+     *    8.1. if other facets have `null` filter, return `true` as we cannot support multiple right outer joins.
+     *    8.2. otherwise, return `false`.
+     *
+     * NOTE this function used to check for select access as well as versioned catalog,
+     * but we decided to remove them since it's not the desired behavior:
+     * https://github.com/informatics-isi-edu/ermrestjs/issues/888
+     */
+    get hideNullChoice(): boolean;
+    /**
+     * Whether client should hide the not-null choice. The logic is as follows:
+     * - `false` if facet has not-null filter.
+     * - `true` if facet has hide_not_null_choice in it's definition
+     * - `true` if facet is from the same table and it's not-nullable.
+     * - `true` if facet is all outbound not null.
+     * - otherwise `false`
+     */
+    get hideNotNullChoice(): boolean;
+    /**
+     * Whether we should hide the number of Occurrences column
+     */
+    get hideNumOccurrences(): boolean;
+    /**
+     * Returns the sortColumns when we're sorting this facet in scalar mode
+     * - uses row_order if defined.
+     * - otherwise it will be descending of num_occurrences and column order of base column.
+     */
+    get sortColumns(): any[];
+    private _determineSortable;
+    /**
+     * An {@link ERMrest.AttributeGroupReference} object that can be used to get
+     * the available scalar values of this facet. This will use the sortColumns, and hideNumOccurrences APIs.
+     * It will throw an error if it's used in entity-mode.
+     */
+    get scalarValuesReference(): AttributeGroupReference_2;
+    get fastFilterSourceObjectWrapper(): SourceObjectWrapper | null;
+    /**
+     * When presenting the applied choice filters, the displayname might be differnt from the value.
+     * This only happens in case of entity-picker. Othercases we can just return the list of fitleres as is.
+     * In case of entity-picker, we should get the displayname of the choices.
+     * Therefore heuristic is as follows:
+     *  - If no fitler -> resolve with empty list.
+     *  - If in scalar mode -> resolve with list of filters (don't change their displaynames.)
+     *  - Otherwise (entity-mode) -> generate an ermrest request to get the displaynames.
+     *
+     * NOTE This function will not return the null filter.
+     * NOTE the request might not return any result for a given filter (because of user access or missing data),
+     *      in this case, we will return the raw value instead.
+     *
+     * @param contextHeaderParams object that we want to be logged with the request
+     * @return A promise resolved with list of objects that have `uniqueId`, and `displayname`.
+     */
+    getChoiceDisplaynames(contextHeaderParams: any): Promise<FacetChoiceDisplayName[]>;
+    /**
+     * Return JSON presentation of the filters. This will be used in the location.
+     * Anything that we want to leak to the url should be here.
+     * It will be in the following format:
+     *
+     * ```
+     * {
+     *    "source": <data-source>,
+     *    "choices": [v, ...],
+     *    "ranges": [{"min": v1, "max": v2}, ...],
+     *    "search": [v, ...],
+     *    "not_null": true
+     * }
+     * ```
+     */
+    toJSON(): any;
+    /**
+     * Given an object will create list of filters.
+     *
+     * NOTE: if we have not_null, other filters except =null are not relevant.
+     * That means if we saw not_null:
+     * 1. If =null exist, then set the filters to empty array.
+     * 2. otherwise set the filter to just the not_null
+     *
+     * Expected object format format:
+     * ```
+     * {
+     *    "source": <data-source>,
+     *    "choices": [v, ...],
+     *    "ranges": [{"min": v1, "max": v2}, ...],
+     *    "search": [v, ...],
+     *    "not_null": true
+     * }
+     * ```
+     *
+     * @param json JSON representation of filters
+     */
+    private _setFilters;
+    /**
+     * Returns true if the not-null filter exists.
+     */
+    get hasNotNullFilter(): boolean;
+    /**
+     * Returns true if choice null filter exists.
+     */
+    get hasNullFilter(): boolean;
+    /**
+     * search filters
+     * NOTE ASSUMES that filters is immutable
+     */
+    get searchFilters(): SearchFacetFilter[];
+    /**
+     * choice filters
+     * NOTE ASSUMES that filters is immutable
+     */
+    get choiceFilters(): ChoiceFacetFilter[];
+    /**
+     * range filters
+     * NOTE ASSUMES that filters is immutable
+     */
+    get rangeFilters(): RangeFacetFilter[];
+    /**
+     * Create a new Reference with appending a new Search filter to current FacetColumn
+     * @param term the term for search
+     * @return the Reference with the new filter
+     */
+    addSearchFilter(term: string): Reference;
+    /**
+     * Create a new Reference with appending a list of choice filters to current FacetColumn
+     * @return the reference with the new filter
+     */
+    addChoiceFilters(values: unknown[]): Reference;
+    /**
+     * Create a new Reference with replacing choice facet filters by the given input
+     * This will also remove NotNullFacetFilter
+     * @return the reference with the new filter
+     */
+    replaceAllChoiceFilters(values: unknown[]): Reference;
+    /**
+     * Given a term, it will remove any choice filter with that term (if any).
+     * @param terms array of terms
+     * @return the reference with the new filter
+     */
+    removeChoiceFilters(terms: unknown[]): Reference;
+    /**
+     * Create a new Reference with appending a new range filter to current FacetColumn
+     * @param min minimum value. Can be null or undefined.
+     * @param minExclusive whether the minimum boundary is exclusive or not.
+     * @param max maximum value. Can be null or undefined.
+     * @param maxExclusive whether the maximum boundary is exclusive or not.
+     * @return the reference with the new filter
+     */
+    addRangeFilter(min?: unknown, minExclusive?: boolean, max?: unknown, maxExclusive?: boolean): FacetFilterResult | false;
+    /**
+     * Create a new Reference with removing any range filter that has the given min and max combination.
+     * @param min minimum value. Can be null or undefined.
+     * @param minExclusive whether the minimum boundary is exclusive or not.
+     * @param max maximum value. Can be null or undefined.
+     * @param maxExclusive whether the maximum boundary is exclusive or not.
+     * @return the reference with the new filter
+     */
+    removeRangeFilter(min?: unknown, minExclusive?: boolean, max?: unknown, maxExclusive?: boolean): FacetFilterResult;
+    /**
+     * Create a new Reference with removing all the filters and adding a not-null filter.
+     * NOTE based on current usecases this is currently removing all the previous filters.
+     * We might need to change this behavior in the future. I could change the behavior of
+     * this function to only add the filter, and then in the client first remove all and thenadd
+     * addNotNullFilter, but since the code is not very optimized that would result on a heavy
+     * operation.
+     */
+    addNotNullFilter(): Reference;
+    /**
+     * Create a new Reference without any filters.
+     */
+    removeNotNullFilter(): Reference;
+    /**
+     * Create a new Reference by removing all the filters from current facet.
+     * @return the reference with the new filter
+     */
+    removeAllFilters(): Reference;
+    /**
+     * Create a new Reference by removing a filter from current facet.
+     * @param index index of element that we want to remove from list
+     * @return the reference with the new filter
+     */
+    removeFilter(index: number): Reference;
+    /**
+     * Given an array of {@link ERMrest.FacetFilter}, will return a new
+     * {@link ERMrest.Reference} with the applied filters to the current FacetColumn
+     * @private
+     * @param filters array of filters
+     * @return the reference with the new filter
+     */
+    private _applyFilters;
+}
+
+declare abstract class FacetFilter {
+    _column: Column;
+    term: unknown;
+    uniqueId: unknown;
+    facetFilterKey?: string;
+    constructor(term: unknown, column: Column);
+    /**
+     * String representation of filter
+     */
+    toString(): string | null;
+    /**
+     * JSON representation of filter
+     */
+    toJSON(): any;
+}
+
+declare interface FacetFilterResult {
+    reference: Reference;
+    filter?: FacetFilter;
+}
+
+declare type FilterPropsType = {
+    /**
+     * whether the filter is processed or not
+     */
+    isFilterProcessed: boolean;
+    /**
+     * whether there's any filter applied to the root (the first node)
+     */
+    hasRootFilter: boolean;
+    /**
+     * whether there's any filter applied to the nodes in between
+     * (i.e. not the root and not the leaf)
+     */
+    hasFilterInBetween: boolean;
+    /**
+     * the leaf filter string
+     */
+    leafFilterString: string;
+};
+
+/**
+ * converts a string to an URI encoded string
+ */
+export declare function fixedEncodeURIComponent(str: string): string;
+
+export declare class ForbiddenError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+/**
+ * @class
+ * @param {Reference} reference column's reference
+ * @param {ForeignKeyRef} fk the foreignkey
+ * @desc
+ * Constructor for ForeignKeyPseudoColumn. This class is a wrapper for {@link ForeignKeyRef}.
+ * This class extends the {@link ReferenceColumn}
+ */
+declare class ForeignKeyPseudoColumn extends ReferenceColumn {
+    /**
+     * @type {boolean}
+     * @desc indicates that this object represents a PseudoColumn.
+     */
+    isPseudo: boolean;
+    /**
+     * @type {boolean}
+     * @desc Indicates that this ReferenceColumn is a Foreign key.
+     */
+    isForeignKey: boolean;
+    /**
+     * @type {Reference}
+     * @desc The reference object that represents the table of this PseudoColumn
+     */
+    reference: Reference;
+    /**
+     * @type {ForeignKeyRef}
+     * @desc The Foreign key object that this PseudoColumn is created based on
+     */
+    foreignKey: ForeignKeyRef;
+    /**
+     * the table that this fk refers to
+     */
+    table: Table_2;
+    /**
+     * the concatenate version of names
+     * TODO should we rename this? or change it to private?
+     */
+    _constraintName: string;
+    private _hasDomainFilter?;
+    private _domainFilterUsedColumns?;
+    private _domainFilterRawString?;
+    private _defaultValues?;
+    private _defaultReference?;
+    constructor(reference: Reference, fk: ForeignKeyRef, sourceObjectWrapper?: SourceObjectWrapper, name?: string);
+    /**
+     * Given the available tuple data, generate the uniqueId for the selected row from the table this pseudo column points to
+     *
+     * @param {Object} linkedData key-value pairs of column values of the table this pseudocolumn points to
+     */
+    generateUniqueId(linkedData: any): string;
+    /**
+     * This function takes in a tuple and generates a reference that is
+     * constrained based on the domain_filter_pattern annotation. If this
+     * annotation doesn't exist, it returns this (reference)
+     * `this` is the same as column.reference
+     * @param {ReferenceColumn} column - column that `this` is based on
+     * @param {Object} data - tuple data with potential constraints
+     * @returns {Reference} the constrained reference
+     */
+    filteredRef(data: any, linkedData: any): Reference;
+    getDefaultDisplay(rowValues: any): any;
+    _determineDefaultValue(): void;
+    formatPresentation(data: any, context?: string, templateVariables?: any, options?: any): any;
+    sourceFormatPresentation(templateVariables: any, columnValue: any, mainTuple: Tuple): any;
+    _determineSortable(): void;
+    get hasDomainFilter(): boolean;
+    get domainFilterUsedColumns(): any[];
+    get domainFilterRawString(): string;
+    get defaultValues(): any;
+    get defaultReference(): Reference | null;
+    get name(): string;
+    get RID(): string | undefined;
+    get displayname(): DisplayName;
+    get default(): any;
+    /**
+     * use the underlying column comment if available, otherwise get it from the foreign key
+     * (similar to displayname logic)
+     */
+    get comment(): CommentType;
+    get display(): any;
+    get compressedDataSource(): any;
+    get nullok(): boolean;
+}
+
+export { _formatUtils }
+
+export { getElapsedTime }
+
+/**
+ * Constructs the Google Dataset metadata for the given tuple.
+ * The given metadata must be valid and have the appropriate variables.
+ */
+declare class GoogleDatasetMetadata {
+    private _reference;
+    private _table;
+    private _gdsMetadataAnnotation;
+    constructor(reference: Reference, gdsMetadataAnnotation: any);
+    /**
+     * Given the templateVariables variables, will generate the metadata.
+     * @param tuple - the tuple object that this metadata is based on
+     * @param templateVariables - if it's not an object, we will use the tuple templateVariables
+     * @return if the returned template for required attributes are empty or invalid, it will return null.
+     */
+    compute(tuple: Tuple, templateVariables?: any): any | null;
+    private setMetadataFromTemplate;
+}
+
+declare class HandlebarsService {
+    private static _setupDone;
+    private static _handlebarsHelpersHash;
+    private static _handlebarsCompiledTemplates;
+    static get handlebars(): typeof default_3;
+    /**
+     * @function
+     * @public
+     * @param template The template string to transform
+     * @param keyValues The key-value pair of object to be used for template tags replacement.
+     * @param catalog The catalog object created by ermrestJS representing the current catalog from the url
+     * @param options Configuration options.
+     * @return {string} A string produced after templating
+     * @desc Calls the private function to return a string produced as a result of templating using `Handlebars`.
+     */
+    static render(template: string, keyValues: Record<string, any>, catalog: Catalog_2 | {
+        id: string;
+    }, options: any): string | null;
+    /**
+     * Returns true if all the used keys have values.
+     *
+     * NOTE:
+     * This implementation is very limited and if conditional Handlebar statements
+     * of the form {{#if }}{{/if}} or {{^if VARNAME}}{{/if}} or {{#unless VARNAME}}{{/unless}} or {{^unless }}{{/unless}} found then it won't check
+     * for null values and will return true.s
+     *
+     * @param  template       mustache template
+     * @param  keyValues      key-value pairs
+     * @param  catalog        the catalog object
+     * @param  ignoredColumns the columns that should be ignored (optional)
+     * @return true if all the used keys have values
+     */
+    static validate(template: string, keyValues: Record<string, any>, catalog: any, ignoredColumns?: string[]): boolean;
+    private static _injectCustomHandlebarHelpers;
+}
+
+export declare class HistoryService {
+    /**
+     * convert ISO datetime string to snapshot version string
+     * @throws {Error} Might throw some errors if the input is invalid
+     */
+    static datetimeISOToSnapshot(value: string): string;
+    /**
+     * convert snapshot version string to ISO datetime string
+     * @param {string} snapshot - the snapshot version string
+     * @param {boolean} dontThrowError - if true, will return empty string instead of throwing error
+     *                                   when the input is invalid
+     * @returns {string} the ISO datetime string
+     * @throws {Error} Might throw some errors if the input is invalid
+     */
+    static snapshotToDatetimeISO(snapshot: string, dontThrowError?: boolean): string;
+    /**
+     * Return microseconds-since-epoch integer for given ISO datetime string
+     */
+    static datetimeEpochUs(isoString: string): bigint;
+    /**
+     * Encode integer as per ERMrest's base-32 snapshot encoding
+     */
+    static urlb32Encode(i: bigint): string;
+    /**
+     * Decode base-32 snapshot encoding back to integer
+     */
+    static urlb32Decode(encoded: string): bigint;
+    /**
+     * Convert microseconds-since-epoch back to ISO datetime string
+     */
+    static epochUsToIso(epochUs: bigint): string;
+}
+
+declare class HTTPService {
+    private static _http401Handler;
+    private static _onHTTPSuccess;
+    /**
+     * A flag to determine whether emrest authorization error has occured
+     * as well as to determine the login flow is currently in progress to avoid
+     * calling the _http401Handler callback again
+     */
+    private static _encountered401Error;
+    /**
+     * All the calls that were paused because of 401 error are added to this array
+     * Once the _encountered401Error is false, all of them will be resolved/restarted
+     */
+    private static _authorizationDefers;
+    private static _onHttpAuthFlowFn;
+    /**
+     * Given an object will make sure it's safe for header.
+     */
+    private static _encodeHeaderContent;
+    static setHTTP401Handler(fn: () => Promise<boolean>): void;
+    static setOnHTTPSuccess(fn: () => void): void;
+    /**
+     * Given a respone object from http module, will return the headers
+     * This is to ensure angularjs and axios behave the same way.
+     * In case of angularjs' $http the headers is a function while for axios
+     * it's an object.
+     *
+     * The response is always going to be an object
+     */
+    static getResponseHeader(response: any): any;
+    static wrapHTTP(http: any): any;
+    /**
+     * Given a header object, will encode and if neccessary truncate it.
+     * Maximum allowed length of a header after encoding: 6500 characters.
+     * The logic is as follows:
+     *  1. If the encoded string is not lengthy, return it.
+     *  2. otherwise,
+     *    2.1. Return an empty object if the minimal header (defined below) goes over the limit.
+     *    2.2. Otherwise start truncating `stack` object by doing the following. In each step,
+     *         if the encoded and truncated header goes below the length limit, return it.
+     *         - replace all foreign key constraints with their RIDs (if RID is defined for all of them).
+     *         - replace values (`choices`, `ranges`, `search`) in the filters with the number of values.
+     *         - replace all `filters.and` with the number of filters.
+     *         - replace all source paths with the number of path nodes.
+     *         - use replace stack value with the number of stack nodes.
+     *         If after performing all these steps, the header is still lengthy, return the minimal header.
+     *
+     * A minimal header will have the following attributes:
+     *  - cid, pid, wid, action, schema_table, catalog, t:1
+     * And might have these optional attributes:
+     *  - elapsed_ms, cqp, ppid, pcid
+     *
+     */
+    static certifyContextHeader(header: any): string | Record<string, unknown>;
+}
+
+/**
+ * @class
+ * @param {Reference} reference column's reference
+ * @param {Reference} relatedReference the related reference
+ * @desc
+ * Constructor for InboundForeignKeyPseudoColumn. This class is a wrapper for {@link ForeignKeyRef}.
+ * This is a bit different than the {@link ForeignKeyPseudoColumn}, as that was for foreign keys
+ * of current table. This wrapper is for inbound foreignkeys. It is actually warpping the whole reference (table).
+ *
+ * Note: The sourceObjectWrapper might include filters and therefore the relatedReference
+ *       might not be a simple path from main to related table and it could have filters.
+ *
+ * This class extends the {@link ReferenceColumn}
+ */
+declare class InboundForeignKeyPseudoColumn extends ReferenceColumn {
+    /**
+     * The reference that can be used to get the data for this pseudo-column
+     */
+    reference: RelatedReference;
+    /**
+     * The table that this pseudo-column represents
+     */
+    table: Table_2;
+    /**
+     * The {@link ForeignKeyRef} that this pseudo-column is based on.
+     */
+    foreignKey: ForeignKeyRef;
+    /**
+     * @desc indicates that this object represents a PseudoColumn.
+     */
+    isPseudo: boolean;
+    /**
+     * @desc Indicates that this ReferenceColumn is an inbound foreign key.
+     */
+    isInboundForeignKey: boolean;
+    isUnique: boolean;
+    private _currentRef;
+    private _constraintName;
+    constructor(reference: Reference, relatedReference: RelatedReference, sourceObjectWrapper?: SourceObjectWrapper, name?: string);
+    formatPresentation(data: any, context?: string, templateVariables?: any, options?: any): any;
+    _determineSortable(): void;
+    _determineInputDisabled(_: string): boolean | {
+        message: string;
+    };
+    get name(): string;
+    get displayname(): DisplayName;
+    get comment(): CommentType;
+    get default(): unknown;
+    get nullok(): boolean;
+    get compressedDataSource(): unknown;
+}
+
+declare type InputIframePropsType = {
+    /**
+     * the url pattern that should be used to generate the iframe url
+     */
+    urlPattern: string;
+    /**
+     * the template engine that should be used to generate the url
+     */
+    urlTemplateEngine?: string;
+    /**
+     * the columns used in the mapping
+     */
+    columns: ReferenceColumn[];
+    /**
+     * an object from field name to column.
+     */
+    fieldMapping: Record<string, ReferenceColumn>;
+    /**
+     * name of optional fields
+     */
+    optionalFieldNames: string[];
+    /**
+     * the message that we should show when user wants to submit empty.
+     */
+    emptyFieldConfirmMessage: string;
+};
+
+export declare class IntegrityConflictError extends ConflictError {
+    constructor(status: string, message: string, subMessage?: string);
+}
+
+export declare class InternalServerError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+export declare class InvalidCustomFacetOperatorError extends ERMrestError {
+    constructor(path: string, subMessage?: string);
+}
+
+export declare class InvalidFacetOperatorError extends ERMrestError {
+    constructor(path: string, subMessage?: string);
+}
+
+export declare class InvalidFilterOperatorError extends ERMrestError {
+    constructor(message: string, path: string, invalidFilter?: string);
+}
+
+export declare class InvalidInputError extends ERMrestError {
+    constructor(message: string);
+}
+
+export declare class InvalidPageCriteria extends ERMrestError {
+    constructor(message: string, path?: string);
+}
+
+export declare class InvalidServerResponse extends ERMrestError {
+    constructor(uri: string, data: any, logAction: string);
+}
+
+export declare class InvalidSortCriteria extends ERMrestError {
+    constructor(message: string, path?: string);
+}
+
+/**
+ * @class
+ * @param {Reference} reference column's reference
+ * @param {Key} key the key
+ * @desc
+ * Constructor for KeyPseudoColumn. This class is a wrapper for {@link Key}.
+ * This class extends the {@link ReferenceColumn}
+ */
+declare class KeyPseudoColumn extends ReferenceColumn {
+    /**
+     * @type {boolean}
+     * @desc indicates that this object represents a PseudoColumn.
+     */
+    isPseudo: boolean;
+    /**
+     * @type {boolean}
+     * @desc Indicates that this ReferenceColumn is a key.
+     */
+    isKey: boolean;
+    /**
+     * @type {Key}
+     * @desc The Key object that this PseudoColumn is created based on
+     */
+    key: Key;
+    /**
+     * the table that the key belongs to
+     */
+    table: Table_2;
+    /**
+     * the constraint name for the key
+     * TODO should we rename this? or change it to private?
+     */
+    _constraintName: string;
+    constructor(reference: Reference, key: Key, sourceObjectWrapper?: SourceObjectWrapper, name?: string);
+    /**
+     * Return the value that should be presented for this column.
+     * It usually is a self-link to the given row of data.
+     *
+     * The following is the logic:
+     * 1. if the key data is not present, return null.
+     * 2. Otherwise if key has markdown pattern, return it.
+     * 3. Otherwise try to generate the value in `col1:col2` format. if it resulted in empty string return null.
+     *    - If any of the constituent columnhas markdown don't add self-link, otherwise add the self-link.
+     * @param  {Object} data    given raw data for the table columns
+     * @param {String=} context the app context (optional)
+     * @param {Object=} templateVariables the template variables that should be used (optional)
+     * @param {Object=} options (optional)
+     * @return {Object} A key value pair containing value and isHTML that detemrines the presentation.
+     */
+    formatPresentation(data: any, context?: string, templateVariables?: any, options?: any): any;
+    sourceFormatPresentation(templateVariables: any, columnValue: any, mainTuple: Tuple): any;
+    _determineSortable(): void;
+    get name(): string;
+    get displayname(): DisplayName;
+    /**
+     * use the underlying column comment if available, otherwise get it from the key
+     * (similar to displayname logic)
+     */
+    get comment(): CommentType;
+    get default(): undefined;
+    get display(): any;
+}
+
+export declare const logError: typeof ErrorService.logError;
+
+export declare class MalformedURIError extends ERMrestError {
+    constructor(message: string);
+}
+
+export declare class NoConnectionError extends ERMrestError {
+    constructor(message: string);
+}
+
+export declare class NoDataChangedError extends ERMrestError {
+    constructor(message: string);
+}
+
+export declare class NotFoundError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+declare class NotNullFacetFilter {
+    facetFilterKey: string;
+    constructor();
+}
+
+export declare const onHTTPSuccess: typeof HTTPService.setOnHTTPSuccess;
+
+export { onload_2 as onload }
+
+/**
+ * Constructs a Page. A Page is a collection of Tuples. A page can contain no
+ * data, but the reference is still valid. This is useful if you want to use
+ * the reference later and need to represent a page, but you haven't read any
+ * data yet.
+ */
+declare class Page {
+    private _ref;
+    private _etag;
+    private _linkedData;
+    private _linkedDataRIDs;
+    private _data;
+    private _rightsSummary;
+    private _associationRightsSummary;
+    private _extraData?;
+    private _extraLinkedData?;
+    private _hasNext;
+    private _hasPrevious;
+    private _tuples?;
+    private _length?;
+    private _content?;
+    private _templateVariables?;
+    constructor(reference: Reference, etag: string | null, data: any[], hasPrevious: boolean, hasNext: boolean, extraData?: any);
+    get extraData(): any;
+    get extraLinkedData(): any;
+    /**
+     * The page's associated reference.
+     */
+    get reference(): Reference | RelatedReference;
+    /**
+     * An array of processed tuples. The results will be processed
+     * according to the contextualized scheme (model) of this reference.
+     *
+     * Usage:
+     * ```
+     * for (var i=0, len=page.tuples.length; i<len; i++) {
+     *   var tuple = page.tuples[i];
+     *   console.log("Tuple:", tuple.displayname.value, "has values:", tuple.values);
+     * }
+     * ```
+     */
+    get tuples(): Tuple[];
+    /**
+     * the page length (number of rows in the page)
+     */
+    get length(): number;
+    /**
+     * Whether there is more entities before this page
+     */
+    get hasPrevious(): boolean;
+    /**
+     * A reference to the previous set of results.
+     * Will return null if the sortObject of reference is missing or is invalid
+     *
+     * Usage:
+     * ```
+     * if (reference.previous) {
+     *   // more tuples in the 'previous' direction are available
+     *   reference.previous.read(10).then(
+     *     ...
+     *   );
+     * }
+     * ```
+     */
+    get previous(): Reference | null;
+    /**
+     * Whether there is more entities after this page
+     */
+    get hasNext(): boolean;
+    /**
+     * A reference to the next set of results.
+     * Will return null if the sortObject of reference is missing or is invalid
+     *
+     * Usage:
+     * ```
+     * if (reference.next) {
+     *   // more tuples in the 'next' direction are available
+     *   reference.next.read(10).then(
+     *     ...
+     *   );
+     * }
+     * ```
+     */
+    get next(): Reference | null;
+    /**
+     * Returns previous or next page
+     * Clients should not directly use this. This is used in next and previous getters.
+     * @param  next whether we want the next page or previous
+     * @private
+     */
+    private _getSiblingReference;
+    getContent(templateVariables?: any): string | null;
+    /**
+     * HTML representation of the whole page which uses table-display annotation.
+     * If markdownPattern is defined then renderTemplate is called to get the correct display.
+     * In case of no such markdownPattern is defined output is displayed in form of
+     * unordered list with displayname as text content of the list.
+     * For more info you can refer {ERM.reference.display}
+     *
+     * Usage:
+     *```
+     * var content = page.content;
+     * if (content) {
+     *    console.log(content);
+     * }
+     *```
+     *
+     * It will return:
+     * 1. the rendered page_markdown_pattern if it's defined.
+     * 2. the rendered row_markdown_pattern if it's defined.
+     * 3. list of links that point to the row. Caption is going to be the row-name.
+     */
+    get content(): string | null;
+    get templateVariables(): any[];
+}
+
+export { parse }
+
+export declare class PreconditionFailedError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+export { printf }
+
+export { processMarkdownPattern }
+
+/**
+ * If you want to create an object of this type, use the `createPseudoColumn` method.
+ * This will only be used for general purpose pseudo-columns, using that method ensures That
+ * we're creating the more specific object instead. Therefore only these cases should
+ * be using this type of object:
+ * 1. When sourceObject has aggregate
+ * 2. When sourceObject has a path that is not just an outbound fk, or it doesn't define a related
+ * entity (inbound or p&b association)
+ *
+ * @memberof ERMrest
+ * @param {Reference} reference  column's reference
+ * @param {Column} column      the column that this pseudo-column is representing
+ * @param {SourceObjectWrapper} sourceObjectWrapper the sourceObjectWrapper object (might be undefined)
+ * @param {string=} name        to avoid processing the name again, this might be undefined.
+ * @param {Tuple=} mainTuple   if the reference is referring to just one tuple, this is defined.
+ * @constructor
+ * @class
+ */
+declare class PseudoColumn extends ReferenceColumn {
+    /**
+     * indicates that this object represents a PseudoColumn.
+     */
+    isPseudo: boolean;
+    isPathColumn: boolean;
+    /**
+     * If the pseudo-column is connected via a path to the table or not.
+     */
+    hasPath: boolean;
+    /**
+     * If the pseudoColumn is in entity mode
+     */
+    isEntityMode: boolean;
+    /**
+     * If the pseudoColumn is referring to a unique row (the path is one to one)
+     */
+    isUnique: boolean;
+    /**
+     * If aggregate function is defined on the column.
+     */
+    hasAggregate: boolean;
+    baseColumn: Column;
+    constructor(reference: Reference, column: Column, sourceObjectWrapper: SourceObjectWrapper, name?: string, mainTuple?: Tuple);
+    /**
+     * Format the presentation value corresponding to this pseudo-column definition.
+     * 1. If source is not in entity mode: use the column's heuristic
+     * 2. Otherwise if it's not a path, apply the same logic as KeyPseudoColumn presentation based on the key.
+     * 2. Otherwise if path is one to one (all outbound), use the same logic as ForeignKeyPseudoColumn based on last fk.
+     * 3. Otherwise return null value.
+     *
+     * @param {Object} data the raw data of the table
+     * @param {String=} context the app context (optional)
+     * @param {Object=} templateVariables the template variables that should be used (optional)
+     * @param {Object=} options (optional)
+     * @returns {Object} A key value pair containing value and isHTML that detemrines the presentation.
+     */
+    formatPresentation(data?: any, context?: string, templateVariables?: any, options?: any): any;
+    sourceFormatPresentation(templateVariables: any, columnValue: any, mainTuple: Tuple): any;
+    /**
+     * Returns a promise that gets resolved with list of aggregated values in the same
+     * order of tuples of the page that is passed.
+     * Each returned value has the following attributes:
+     *  - value
+     *  - isHTML
+     *  - templateVariables: the template variables that the client uses to eventually pass to sourceFormatPresentation
+     *
+     * implementation Notes:
+     * 1. This function will take care of url limitation. It might generate multiple
+     * ermrest requests based on the url length, and will resolve the promise when
+     * all the requests have been succeeded. If we cannot fit all the requests, an
+     * error will be thrown.
+     * 2. Only in case of entity scalar aggregate we are going to get all the row data.
+     * In other cases, the returned data will only include the scalar value.
+     * 3. Regarding the returned value:
+     *  3.0. Null and empty string values are treated the same way as any array column.
+     *  We are going to show the special value for them.
+     *  3.1. If it's an array aggregate:
+     *      3.1.1. array_display will dictate how we should join the values (csv, olist, ulist, raw).
+     *      3.1.2. array_options will dictate the sort and length criteria.
+     *      3.1.3. Based on entity/scalar mode:
+     *          3.1.3.1. In scalar mode, only pre_format will be applied to each value.
+     *          3.1.3.2. In entity mode, we are going to return list of row_names derived from `row_name/compact`.
+     *  3.2. Otherwise we will only apply the pre_format annotation for the column.
+     *
+     * @param  {Page} page               the page object of main (current) refernece
+     * @param {Object} contextHeaderParams the object that we want to log.
+     * @return {Promise}
+     */
+    getAggregatedValue(page: Page, contextHeaderParams?: any): Promise<{
+        value: any;
+        isHTML: boolean;
+        templateVariables: any;
+    }[]>;
+    protected _determineSortable(): void;
+    protected _determineInputDisabled(context: string): boolean | {
+        message: string;
+    };
+    /**
+     * If the first foreign key is outbound, this function will return the value that this pseudo-column represents.
+     *
+     * The first fk must be outbound because the path is generated from the table that the first fk refers to. This is
+     * useful for fetching the values of wait-fors in the entry contexts. Since the main record might not be available yet,
+     * we're starting from the fk table.
+     *
+     * Ideally this and getAggregatedValue should be merged, these are the differences:
+     * - for this function agg fn is not required.
+     * - this function requires the first fk to be outbound, while getAggregatedValue doesn't.
+     * - the generated path here ignores the first hop.
+     * - if the key value for any of the rows is null, this will only ignore that row (getAggregatedValue will just give up and return empty).
+     *
+     * @param {any} data the submission data
+     * @param {Record<string, any>} contextHeaderParams
+     */
+    getFirstOutboundValue(data: any[], contextHeaderParams?: Record<string, any>): Promise<any[]>;
+    private _key?;
+    private _aggregateFn?;
+    private _reference?;
+    private _canUseScalarProjection?;
+    /**
+     * The tooltip that should be used for this column.
+     * It will return the first applicable rule:
+     * 1. comment that is defined on the sourceObject, use it.
+     * 2. if aggregate and scalar use the "<function> <col_displayname>"
+     * 3. if aggregate and entity use the "<function> <table_displayname>"
+     * 3. In entity mode, return the table's displayname.
+     * 4. In scalar return the column's displayname.
+     */
+    get comment(): CommentType;
+    /**
+     * The tooltip that should be used for this column.
+     * It will return the first applicable rule:
+     * 1. comment that is defined on the sourceObject, use it.
+     * 2. if aggregate and scalar use the "<function> <col_displayname>"
+     * 3. if aggregate and entity use the "<function> <table_displayname>"
+     * 3. In entity mode, return the table's displayname.
+     * 4. In scalar return the column's displayname.
+     */
+    get displayname(): DisplayName;
+    /**
+     * If the pseudoColumn is in entity mode will return the key that this column represents
+     */
+    get key(): Key | null;
+    get aggregateFn(): string | null;
+    /**
+     * Returns a reference to the current pseudo-column
+     * This is how it behaves:
+     * 1. If pseudo-column has no path, it will return the base reference.
+     * 3. if mainTuple is available, create the reference based on this path:
+     *      <pseudoColumnSchema:PseudoColumnTable>/<path from pseudo-column to main table>/<facets based on value of shortestkey of main table>
+     * 4. Otherwise create the path by traversing the path
+     */
+    get reference(): Reference | RelatedReference;
+    set reference(ref: Reference);
+    get default(): unknown;
+    get nullok(): boolean;
+    /**
+     * Whether we can use the raw column in the projection list or not.
+     *
+     * If we only need the value of scalar column and none of the other columns of the
+     * all-outbound path then we can simply use the scalar projection.
+     * Therefore the pseudo-column must:
+     * - be all-outbound path in scalar mode
+     * - the leaf column cannot have any column_display annotation
+     * - the leaf column cannot be sorted or doesn't have a sort based on other columns of the table.
+     */
+    get canUseScalarProjection(): boolean;
+}
+
+export declare class QueryTimeoutError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+declare class RangeFacetFilter extends FacetFilter {
+    min: unknown;
+    minExclusive: boolean;
+    max: unknown;
+    maxExclusive: boolean;
+    facetFilterKey: string;
+    constructor(min: unknown, minExclusive: boolean, max: unknown, maxExclusive: boolean, column: Column);
+    /**
+     * String representation of range filter. With the format of:
+     *
+     * - both min and max defined: `{{min}}-{{max}}`
+     * - only min defined: `> {{min}}`
+     * - only max defined: `< {{max}}`
+     */
+    toString(): string;
+    /**
+     * JSON representation of range filter.
+     */
+    toJSON(): any;
+}
+
+/**
+ * Constructs a Reference object.
+ *
+ * For most uses, maybe all, of the library, the Reference
+ * will be the main object that the client will interact with. References
+ * are immutable objects and therefore can be safely passed around and
+ * used between multiple client components without risk that the underlying
+ * reference to server-side resources could change.
+ *
+ * Usage:
+ *  Clients _do not_ directly access this constructor.
+ *  See {@link resolve}.
+ * @param location - The location object generated from parsing the URI
+ * @param catalog - The catalog object. Since location.catalog is just an id, we need the actual catalog object too.
+ */
+declare class Reference {
+    /**
+     * The members of this object are _contextualized references_.
+     *
+     * These references will behave and reflect state according to the mode.
+     * For instance, in a `record` mode on a table some columns may be
+     * hidden.
+     *
+     * Usage:
+     * ```
+     * // assumes we have an uncontextualized `Reference` object
+     * var recordref = reference.contextualize.detailed;
+     * ```
+     * The `reference` is unchanged, while `recordref` now represents a
+     * reconfigured reference. For instance, `recordref.columns` may be
+     * different compared to `reference.columns`.
+     */
+    contextualize: Contextualize;
+    /**
+     * The function that can be used to perform aggregation operations on columns in this reference.
+     */
+    aggregate: ReferenceAggregateFn;
+    private _context;
+    private _location;
+    private _server;
+    private _table;
+    private _facetBaseTable;
+    private _shortestKey;
+    private _bulkCreateForeignKeyObject?;
+    private _canCreate?;
+    private _canCreateReason?;
+    private _canRead?;
+    private _canUpdate?;
+    private _canUpdateReason?;
+    private _canDelete?;
+    private _canUseTRS?;
+    private _canUseTCRS?;
+    private _readPath?;
+    private _readAttributeGroupPathProps_cached?;
+    private _display?;
+    private _defaultExportTemplate?;
+    private _csvDownloadLink?;
+    private _searchColumns?;
+    private _cascadingDeletedItems?;
+    private _referenceColumns?;
+    private _related?;
+    private _facetColumns?;
+    private _activeList?;
+    private _citation?;
+    private _googleDatasetMetadata?;
+    protected _displayname?: DisplayName;
+    protected _comment?: CommentType | null;
+    protected _pseudoColumn?: VisibleColumn;
+    constructor(location: Location_2, catalog: Catalog, displayname?: DisplayName, comment?: CommentType, pseudoColumn?: VisibleColumn);
+    get server(): Server;
+    /**
+     * The table object for this reference
+     */
+    get table(): Table_2;
+    /**
+     * The base table object that is used for faceting,
+     * if there's a join in path, this will return a different object from .table
+     */
+    get facetBaseTable(): Table_2;
+    get shortestKey(): Column[];
+    /**
+     * the pseudo column that this reference is based on
+     *
+     */
+    get pseudoColumn(): VisibleColumn | undefined;
+    setPseudoColumn(value: VisibleColumn): void;
+    /**
+     * the reference's context
+     */
+    get context(): string;
+    /**
+     * used by Contextualize to set the context of the reference
+     */
+    setContext(value: string): void;
+    /**
+     * The display name for this reference.
+     * displayname.isHTML will return true/false
+     * displayname.value has the value
+     */
+    get displayname(): DisplayName;
+    /**
+     * The comment for this reference.
+     */
+    get comment(): CommentType | null;
+    /**
+     * The display mode configuration for this reference.
+     * This returns an object with properties for configuring how the reference should be displayed:
+     *
+     * - `type`: The display type ('table', 'markdown', or 'module')
+     * - `hideRowCount`: Whether to hide the row count
+     * - `showFaceting`: Whether faceting is enabled
+     * - `maxFacetDepth`: Maximum facet depth allowed
+     * - `facetPanelOpen`: Whether the facet panel should be open by default
+     * - `showSavedQuery`: Whether saved query UI should be shown
+     *
+     * For markdown type displays, it also includes:
+     * - `_rowMarkdownPattern`: The markdown pattern for rows
+     * - `_pageMarkdownPattern`: The markdown pattern for pages
+     * - `_separator`, `_prefix`, `_suffix`: Markdown formatting options
+     *
+     * @returns The display configuration object
+     */
+    get display(): ReferenceDisplay;
+    /**
+     * The string form of the `URI` for this reference.
+     * NOTE: It is not understandable by ermrest, and it also doesn't have the modifiers (sort, page).
+     * Should not be used for sending requests to ermrest, use this.location.ermrestCompactUri instead.
+     */
+    get uri(): string;
+    /**
+     * Location object that has uri of current reference
+     */
+    get location(): Location_2;
+    /**
+     * this is used when we want to change the location of a reference without creating a new one.
+     * it will also attach the current reference to the location object.
+     */
+    setLocation(loc: Location_2): void;
+    get readPath(): string;
+    /**
+     * This will generate a new unfiltered reference each time.
+     * Returns a reference that points to all entities of current table
+     *
+     * NOTE: This will not have any context, and always returns a Reference object (not RelatedReference or other special reference types).
+     */
+    get unfilteredReference(): Reference;
+    /**
+     * App-specific URL
+     *
+     * @throws {Error} if `_appLinkFn` is not defined.
+     */
+    get appLink(): string;
+    /**
+     * Returns a uri that will properly generate the download link for a csv document
+     * NOTE It will honor the visible columns in `export` context
+     *
+     **/
+    get csvDownloadLink(): string | null;
+    /**
+     * The default information that we want to be logged. This includes:
+     *  - catalog, schema_table
+     * TODO Evaluate whether we even need this function
+     */
+    get defaultLogInfo(): {
+        catalog: string;
+        schema_table: string;
+    };
+    /**
+     * The object that can be logged to capture the filter state of the reference.
+     * The return object can have:
+     *  - filters: the facet object.
+     *  - custom_filters:
+     *      - the filter strings that parser couldn't turn to facet.
+     *      - if we could turn the custom filter to facet, this will return `true`
+     *  - cfacet: if there's a cfacet it will be 1
+     *    - cfacet_str: if cfacet=1, it will be displayname of cfacet.
+     *    - cfacet_path: if cfacet=1, it will be ermrest path of cfacet.
+     * This function creates a new object everytime that it's called, so it
+     * can be manipulated further.
+     */
+    get filterLogInfo(): {
+        cfacet?: 1;
+        cfacet_str?: unknown;
+        cfacet_path?: string;
+        filters?: unknown;
+        custom_filters?: string | boolean;
+    };
+    /**
+     * This will ensure the ermrestCompactPath is also
+     * using the same aliases that we are going to use for allOutbounds
+     * I'm attaching this to Reference so it's cached and we don't have to
+     * compute it multiple times
+     * @private
+     */
+    get _readAttributeGroupPathProps(): any;
+    /**
+     * The array of column definitions which represent the model of
+     * the resources accessible via this reference.
+     *
+     * _Note_: in database jargon, technically everything returned from
+     * ERMrest is a 'tuple' or a 'relation'. A tuple consists of attributes
+     * and the definitions of those attributes are represented here as the
+     * array of {@link Column}s. The column definitions may be
+     * contextualized (see {@link Reference#contextualize}).
+     *
+     * Usage:
+     * ```
+     * for (var i=0, len=reference.columns.length; i<len; i++) {
+     *   var col = reference.columns[i];
+     *   console.log("Column name:", col.name, "has display name:", col.displayname);
+     * }
+     * ```
+     */
+    get columns(): VisibleColumn[];
+    /**
+     * Generate the list of columns for this reference based on context and annotations
+     */
+    generateColumnsList(tuple?: Tuple, columnsList?: any[], dontChangeReference?: boolean, skipLog?: boolean): ReferenceColumn[];
+    /**
+     * NOTE this will not map the entity choice pickers, use "generateFacetColumns" instead.
+     * so directly using this is not recommended.
+     */
+    get facetColumns(): FacetColumn[];
+    /**
+     * Returns the facets that should be represented to the user.
+     * It will return a promise resolved with the following object:
+     * {
+     *   facetColumns: <an array of FacetColumn objects>
+     *   issues: <if null it means that there wasn't any issues, otherwise will be a UnsupportedFilters object>
+     * }
+     *
+     * - If `filter` context is not defined for the table, following heuristics will be used:
+     *    - All the visible columns in compact context.
+     *    - All the related entities in detailed context.
+     * - This function will modify the Reference.location to reflect the preselected filters
+     *   per annotation as well as validation.
+     * - This function will validate the facets in the url, by doing the following (any invalid filter will be ignored):
+     *   - Making sure given `source` or `sourcekey` are valid
+     *   - If `source_domain` is passed,
+     *       - Making sure `source_domain.table` and `source_domain.schema` are valid
+     *       - Using `source_domain.column` instead of end column in case of scalars
+     *   - Sending request to fetch the rows associated with the entity choices,
+     *     and ignoring the ones that don't return any result.
+     * - The valid filters in the url will either be matched with an existing facet,
+     *   or result in a new facet column.
+     * Usage:
+     * ```
+     *  reference.generateFacetColumns().then((result) => {
+     *      var newRef = result.facetColumns[0].addChoiceFilters(['value']);
+     *      var newRef2 = newRef.facetColumns[1].addSearchFilter('text 1');
+     *      var newRef3 = newRef2.facetColumns[2].addRangeFilter(1, 2);
+     *      var newRef4 = newRef3.facetColumns[3].removeAllFilters();
+     *      for (var i=0, len=newRef4.facetColumns.length; i<len; i++) {
+     *          var fc = reference.facetColumns[i];
+     *          console.log("Column name:", fc.column.name, "has following facets:", fc.filters);
+     *      }
+     * });
+     * ```
+     */
+    generateFacetColumns(): Promise<{
+        facetColumns: FacetColumn[];
+        issues: UnsupportedFilters | null;
+    }>;
+    /**
+     * This is only added so _applyFilters in facet-column can use it.
+     * SHOULD NOT be used outside of this library.
+     */
+    manuallySetFacetColumns(facetCols: FacetColumn[]): void;
+    /**
+     * The "related" references. Relationships are defined by foreign key
+     * references between {@link Table}s. Those references can be
+     * considered "outbound" where the table has FKRs to other entities or
+     * "inbound" where other entities have FKRs to this entity. Finally,
+     * entities can be "associated" by means of associative entities. Those
+     * are entities in another table that establish _many-to-many_
+     * relationships between entities. If this help `A <- B -> C` where
+     * entities in `B` establish relationships between entities in `A` and
+     * `C`. Thus entities in `A` and `C` may be associated and we may
+     * ignore `B` and think of this relationship as `A <-> C`, unless `B`
+     * has other moderating attributes, for instance that indicate the
+     * `type` of relationship, but this is a model-depenent detail.
+     *
+     * NOTE: This API should not be used for generating related references
+     *       since we need the main tuple data for generating related references.
+     *       Please use `generateRelatedList` or `generateActiveList` before
+     *       calling this API.
+     */
+    get related(): Array<RelatedReference>;
+    /**
+     * The function that can be used to generate .related API.
+     * The logic is as follows:
+     *
+     * 1. Get the list of visible inbound foreign keys (if annotation is not defined,
+     * it will consider all the inbound foreign keys).
+     *
+     * 2. Go through the list of visible inbound foreign keys
+     *  2.1 if it's not part of InboundForeignKeyPseudoColumn apply the generateRelatedRef logic.
+     * The logic for are sorted based on following attributes:
+     *  1. displayname
+     *  2. position of key columns that are involved in the foreignkey
+     *  3. position of columns that are involved in the foreignkey
+     *
+     * NOTE: Passing "tuple" to this function is highly recommended.
+     *       Without tuple related references will be generated by appending the compactPath with
+     *       join statements. Because of this we cannot optimize the URL and other
+     *       parts of the code cannot behave properly (e.g. getUnlinkTRS in read cannot be used).
+     *       By passing "tuple", we can create the related references by creaing a facet blob
+     *       which can be integrated with other parts of the code.
+     *
+     */
+    generateRelatedList(tuple?: Tuple): Array<RelatedReference>;
+    /**
+     * Refer to Reference.generateActiveList
+     */
+    get activeList(): ActiveList;
+    /**
+     * Generates the list of extra elements that the page might need,
+     * this should include
+     * - requests: An array of the secondary request objects which includes aggregates, entitysets, inline tables, and related tables.
+     *   Depending on the type of request it can have different attributes.
+     *   - for aggregate, entitysets, uniquefiltered, and outboundFirst (in entry):
+     *     {column: ERMrest.ReferenceColumn, <type>: true, objects: [{index: integer, column: boolean, related: boolean, inline: boolean, citation: boolean}]
+     *     where the type is aggregate`, `entity`, `entityset`, or `firstOutbound`. Each object is capturing where in the page needs this pseudo-column.
+     *   - for related and inline tables:
+     *     {<type>: true, index: integer}
+     *     where the type is `inline` or `related`.
+     * - allOutBounds: the all-outbound foreign keys (added so we can later append to the url).
+     *   ERMrest.ReferenceColumn[]
+     * - selfLinks: the self-links (so it can be added to the template variables)
+     *   ERMrest.KeyPseudoColumn[]
+     *
+     * TODO we might want to detect duplicates in allOutBounds better?
+     * currently it's done based on name, but based on the path should be enough..
+     * as long as it's entity the last column is useless...
+     * the old code was kinda handling this by just adding the multi ones,
+     * so if the fk definition is based on fkcolumn and not the RID, it would handle it.
+     *
+     * @param tuple - optional tuple parameter
+     * @private
+     */
+    generateActiveList(tuple?: Tuple): ActiveList;
+    /**
+     * List of columns that are used for search
+     * if it's false, then we're using all the columns for search
+     */
+    get searchColumns(): Array<VisibleColumn> | false;
+    /**
+     * Will return the expor templates that are available for this reference.
+     * It will validate the templates that are defined in annotations.
+     * If its `detailed` context and annotation was missing,
+     * it will return the default export template.
+     * @param useDefault whether we should use default template or not
+     */
+    getExportTemplates(useDefault?: boolean): any[];
+    /**
+     * Returns a object, that can be used as a default export template.
+     * NOTE SHOULD ONLY BE USED IN DETAILED CONTEXT
+     * It will include:
+     * - csv of the main table.
+     * - csv of all the related entities
+     * - fetch all the assets. For fetch, we need to provide url, length, and md5 (or other checksum types).
+     *   if these columns are missing from the asset annotation, they won't be added.
+     * - fetch all the assetes of related tables.
+     * @type {string}
+     */
+    get defaultExportTemplate(): any;
+    /**
+     * Find a column given its name. It will search in this order:
+     * 1. Visible columns
+     * 2. Table columns
+     * 3. search by constraint name in visible foreignkey and keys (backward compatibility)
+     * Will throw an error if column is not found
+     * @param name name of column
+     * @returns ReferenceColumn
+     */
+    getColumnByName(name: string): VisibleColumn;
+    /**
+     * Given a page, will return a reference that has
+     * - the sorting and paging of the given page.
+     * - the merged facets of the based reference and given page's facet.
+     * to match the page.
+     * NOTE: The given page must be based on the same table that this current table is based on.
+     */
+    setSamePaging(page: Page): Reference;
+    /**
+     * Remove all the filters, facets, and custom-facets from the reference
+     * @param {boolean} sameFilter By default we're removing filters, if this is true filters won't be changed.
+     * @param {boolean} sameCustomFacet By default we're removing custom-facets, if this is true custom-facets won't be changed.
+     * @param {boolean} sameFacet By default we're removing facets, if this is true facets won't be changed.
+     *
+     * @return {reference} A reference without facet filters
+     */
+    removeAllFacetFilters(sameFilter?: boolean, sameCustomFacet?: boolean, sameFacet?: boolean): Reference;
+    /**
+     * Given a list of facet and filters, will add them to the existing conjunctive facet filters.
+     *
+     * @param facetAndFilters - an array of facets that will be added
+     * @param customFacets - the custom facets object
+     */
+    addFacets(facetAndFilters: unknown[], customFacets: unknown): Reference;
+    /**
+     * Will return a reference with the same facets but hidden.
+     */
+    hideFacets(): Reference;
+    /**
+     *
+     * @param table
+     */
+    setNewTable(table: Table_2): void;
+    /**
+     * If annotation is defined and has the required attributes, will return
+     * a Citation object that can be used to generate citation.
+     */
+    get citation(): Citation | null;
+    /**
+     * If annotation is defined and has the required attributes, will return
+     * a Metadata object
+     */
+    get googleDatasetMetadata(): GoogleDatasetMetadata | null;
+    /**
+     * The related reference or tables that might be deleted as a result of deleting the current table.
+     */
+    get cascadingDeletedItems(): Array<Table_2 | RelatedReference | Reference>;
+    /**
+     * If prefill object is defined and has the required attributes, will return
+     * a BulkCreateForeignKeyObject object with the necessary objects used for a association modal picker
+     */
+    get bulkCreateForeignKeyObject(): BulkCreateForeignKeyObject | null;
+    /**
+     * Will compute and return a BulkCreateForeignKeyObject if:
+     *   - the prefillObject is defined
+     *   - there are only 2 foreign key columns for this table that are not system columns
+     *   - using the prefill object, we can determine the main column for prefilling and leaf column for bulk selection
+     *
+     * @param  prefillObject computed prefill object from chaise
+     */
+    computeBulkCreateForeignKeyObject(prefillObject: any): BulkCreateForeignKeyObject | null | undefined;
+    /**
+     * Indicates whether the client has the permission to _create_
+     * the referenced resource(s). Reporting a `true` value DOES NOT
+     * guarantee the user right since some policies may be undecidable until
+     * query execution.
+     */
+    get canCreate(): boolean;
+    /**
+     * Indicates the reason as to why a user cannot create the
+     * referenced resource(s).
+     */
+    get canCreateReason(): string;
+    /**
+     * Indicates whether the client has the permission to _read_
+     * the referenced resource(s). Reporting a `true` value DOES NOT
+     * guarantee the user right since some policies may be undecidable until
+     * query execution.
+     */
+    get canRead(): boolean;
+    /**
+     * Indicates whether the client has the permission to _update_
+     * the referenced resource(s). Reporting a `true` value DOES NOT
+     * guarantee the user right since some policies may be undecidable until
+     * query execution.
+     */
+    get canUpdate(): boolean;
+    /**
+     * Indicates the reason as to why a user cannot update the
+     * referenced resource(s).
+     */
+    get canUpdateReason(): string;
+    /**
+     * Indicates whether the client has the permission to _delete_
+     * the referenced resource(s). Reporting a `true` value DOES NOT
+     * guarantee the user right since some policies may be undecidable until
+     * query execution.
+     */
+    get canDelete(): boolean;
+    /**
+     * Returns true if
+     *  - ermrest supports trs, and
+     *  - table has dynamic acls, and
+     *  - table has RID column, and
+     *  - table is not marked non-deletable non-updatable by annotation
+     */
+    get canUseTRS(): boolean;
+    /**
+     * Returns true if
+     *  - ermrest supports tcrs, and
+     *  - table has dynamic acls, and
+     *  - table has RID column, and
+     *  - table is not marked non-updatable by annotation
+     */
+    get canUseTCRS(): boolean;
+    /**
+     * This is a private function that checks the user permissions for modifying the affiliated entity, record or table
+     * Sets a property on the reference object used by canCreate/canUpdate/canDelete
+     */
+    checkPermissions(permission: string): boolean;
+    _generateContextHeader(contextHeaderParams: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * create a new reference with the new search
+     * by copying this reference and clears previous search filters
+     * search term can be:
+     * a) A string with no space: single term or regular expression
+     * b) A single term with space using ""
+     * c) use space for conjunction of terms
+     */
+    search(term: string): Reference;
+    /**
+     * Return a new Reference with the new sorting
+     * TODO this should validate the given sort objects,
+     * but I'm not sure how much adding that validation will affect other apis and client
+     *
+     * @param sort an array of objects in the format
+     * {"column":columname, "descending":true|false}
+     * in order of priority. Undfined, null or Empty array to use default sorting.
+     *
+     */
+    sort(sort: Array<{
+        column: string;
+        descending?: boolean;
+    }> | null): Reference;
+    /**
+     *
+     * @param {ColumnAggregateFn[]} aggregateList - list of aggregate functions to apply to GET uri
+     * @return Promise contains an array of the aggregate values in the same order as the supplied aggregate list
+     */
+    getAggregates(aggregateList: ColumnAggregateFn[], contextHeaderParams?: Record<string, unknown>): Promise<unknown[]>;
+    /**
+     * Reads the referenced resources and returns a promise for a page of
+     * tuples. The `limit` parameter is required and must be a positive
+     * integer. The page of tuples returned will be described by the
+     * {@link ERMrest.Reference#columns} array of column definitions.
+     *
+     * Usage:
+     * ```
+     * // assumes the client holds a reference
+     * reference.read(10).then(
+     *   function(page) {
+     *     // we now have a page of tuples
+     *     ...
+     *   },
+     *   function(error) {
+     *     // an error occurred
+     *     ...
+     *   });
+     * ```
+     *
+     * @param {!number} limit The limit of results to be returned by the
+     * read request. __required__
+     * @param {Object} contextHeaderParams the object that we want to log.
+     * @param {Boolean=} useEntity whether we should use entity api or not (if true, we won't get foreignkey data)
+     * @param {Boolean=} dontCorrectPage whether we should modify the page.
+     * If there's a @before in url and the number of results is less than the
+     * given limit, we will remove the @before and run the read again. Setting
+     * dontCorrectPage to true, will not do this extra check.
+     * @param {Boolean=} getTRS whether we should fetch the table-level row acls (if table supports it)
+     * @param {Boolean=} getTCRS whether we should fetch the table-level and column-level row acls (if table supports it)
+     * @param {Boolean=} getUnlinkTRS whether we should fetch the acls of association
+     *                  table. Use this only if the association is based on facet syntax
+     *
+     * NOTE setting useEntity to true, will ignore any sort that is based on
+     * pseduo-columns.
+     * TODO we might want to chagne the above statement, so useEntity can
+     * be used more generally.
+     *
+     * NOTE getUnlinkTRS can only be used on related references that are generated
+     * after calling `generateRelatedReference` or `generateActiveList` with the main
+     * tuple data. As part of generating related references, if the main tuple is available
+     * we will use a facet filter and the alias is added in there. Without the main tuple,
+     * the alias is not added to the path and therefore `getUnlinkTRS` cannot be used.
+     * TODO this is a bit hacky and should be refactored
+     *
+     * @returns A promise resolved with {@link Page} of results,
+     * or rejected with any of these errors:
+     * - {@link InvalidInputError}: If `limit` is invalid.
+     * - {@link BadRequestError}: If asks for sorting based on columns that are not sortable.
+     * - {@link NotFoundError}: If asks for sorting based on columns that are not valid.
+     * - ERMrestjs corresponding http errors, if ERMrest returns http error.
+     */
+    read(limit: number, contextHeaderParams?: Record<string, unknown>, useEntity?: boolean, dontCorrectPage?: boolean, getTRS?: boolean, getTCRS?: boolean, getUnlinkTRS?: boolean): Promise<Page>;
+    /**
+     * Creates a set of tuples in the references relation. Note, this
+     * operation sets the `defaults` list according to the table
+     * specification, and not according to the contents of in the input
+     * tuple.
+     * @param data The array of data to be created as new tuples.
+     * @param contextHeaderParams the object that we want to log.
+     * @param skipOnConflict if true, it will not complain about conflict
+     * @returns A promise resolved with a object containing `successful` and `failure` attributes.
+     * Both are {@link Page} of results.
+     * or rejected with any of the following errors:
+     * - {@link InvalidInputError}: If `data` is not valid, or reference is not in `entry/create` context.
+     * - {@link InvalidInputError}: If `limit` is invalid.
+     * - ERMrestjs corresponding http errors, if ERMrest returns http error.
+     */
+    create(data: Record<string, unknown>[], contextHeaderParams?: any, skipOnConflict?: boolean): Promise<{
+        successful: Page;
+        failed: Page | null;
+        disabled: Page | null;
+    }>;
+    /**
+     * Updates a set of resources.
+     * @param tuples array of tuple objects so that the new data nd old data can be used to determine key changes.
+     * tuple.data has the new data
+     * tuple._oldData has the data before changes were made
+     * @param contextHeaderParams the object that we want to log.
+     * @returns A promise resolved with a object containing:
+     *  -  `successful`: Page of results that were stored.
+     *  -  `failed`: Page of results that failed to be stored.
+     *  -  `disabled`: Page of results that were not sent to ermrest (because of acl)
+     * or rejected with any of these errors:
+     * - {@link InvalidInputError}: If `limit` is invalid or reference is not in `entry/edit` context.
+     * - ERMrestjs corresponding http errors, if ERMrest returns http error.
+     */
+    update(tuples: Tuple[], contextHeaderParams?: any): Promise<{
+        successful: Page;
+        failed: Page | null;
+        disabled: Page | null;
+    }>;
+    /**
+     * Deletes the referenced resources or the given tuples.
+     * NOTE This will ignore the provided sort and paging on the reference, make
+     * sure you are calling this on specific set or rows (filtered).
+     *
+     * @param tuples (optional) the tuples that should be deleted
+     * @param contextHeaderParams (optional) the object that we want to log.
+     * @returns A promise resolved with empty object or rejected with any of these errors:
+     * - ERMrestjs corresponding http errors, if ERMrest returns http error.
+     */
+    delete(tuples?: Tuple[], contextHeaderParams?: any): Promise<void | BatchDeleteResponse>;
+    /**
+     * create a new instance with the same properties.
+     *
+     * you can customized the properties of the new instance by passing new ones to this function.
+     * You must pass undefined for other props that you don't want to change.
+     */
+    copy(displayname?: DisplayName, comment?: CommentType, pseudoColumn?: VisibleColumn): Reference;
+    /**
+     * return the columns that we should add to the defaults list during creation
+     * @private
+     */
+    private getDefaults;
+}
+
+/**
+ * Constructs an Aggregate Funciton object
+ *
+ * Reference Aggregate Functions is a collection of available aggregates for the
+ * particular Reference (count for the table). Each aggregate should return the string
+ * representation for querying that information.
+ *
+ * Usage:
+ *  Clients _do not_ directly access this constructor. ERMrest.Reference will
+ *  access this constructor for purposes of fetching aggregate data about the table.
+ */
+declare class ReferenceAggregateFn {
+    private _ref;
+    constructor(reference: Reference);
+    /**
+     * count aggregate representation
+     */
+    get countAgg(): string;
+}
+
+/**
+ * Constructor for ReferenceColumn. This class is a wrapper for Column.
+ */
+declare class ReferenceColumn {
+    referenceColumnType: ReferenceColumnTypes;
+    baseColumns: Column[];
+    /**
+     * the source object wrapper that this column is based on
+     */
+    sourceObjectWrapper?: SourceObjectWrapper;
+    /**
+     * the column-directive object
+     */
+    sourceObject: any;
+    /**
+     * The source object nodes
+     */
+    sourceObjectNodes?: SourceObjectNode[];
+    /**
+     * the last fk node
+     */
+    lastForeignKeyNode?: SourceObjectNode;
+    /**
+     * the first fk node
+     */
+    firstForeignKeyNode?: SourceObjectNode;
+    /**
+     * how many fks node are in the path
+     */
+    foreignKeyPathLength?: number;
+    /**
+     * whether the path is filtered
+     */
+    isFiltered: boolean;
+    /**
+     * the filter props
+     */
+    filterProps?: FilterPropsType;
+    /**
+     * whether input iframe is defined
+     */
+    isInputIframe?: boolean;
+    /**
+     * input iframe props
+     */
+    inputIframeProps?: InputIframePropsType;
+    /**
+     * whether the column is a pseudo column (differentiate between this base type and other more specific ones)
+     */
+    isPseudo: boolean;
+    isUnique: boolean;
+    /**
+     * the table that this column belongs to
+     */
+    table: Table_2;
+    protected _displayname?: DisplayName;
+    protected _RID?: string;
+    private _type?;
+    protected _nullok?: boolean;
+    protected _default?: any;
+    private _aggregate?;
+    private _groupAggregate?;
+    protected _comment?: CommentType;
+    private _hideColumnHeader?;
+    private _inputDisabled?;
+    protected _sortable?: boolean;
+    protected _sortColumns_cached?: any[];
+    protected _display_cached?: any;
+    protected _compressedDataSource?: any;
+    protected _hasWaitFor?: boolean;
+    protected _hasWaitForAggregate?: boolean;
+    protected _waitFor?: ReferenceColumn[];
+    /**
+     * the reference that this column is defined on
+     */
+    protected _baseReference: Reference;
+    protected _context: string;
+    protected _name?: string;
+    protected _mainTuple?: Tuple;
+    protected _currentTable: Table_2;
+    constructor(reference: Reference, cols: Column[], sourceObjectWrapper?: SourceObjectWrapper, name?: string, mainTuple?: Tuple);
+    /**
+     * Name of the column.
+     */
+    get name(): string;
+    /**
+     * The compressed source path from the main reference to this column
+     */
+    get compressedDataSource(): any;
+    /**
+     * Display name of the column.
+     */
+    get displayname(): DisplayName;
+    /**
+     * ERMrest generated RID for this column
+     */
+    get RID(): string | undefined;
+    /**
+     * Type of the column
+     */
+    get type(): Type;
+    /**
+     * As long as any of the base columns are nullok, the ReferenceColumn is nullok.
+     */
+    get nullok(): boolean;
+    /**
+     * Returns the default value
+     */
+    get default(): any;
+    /**
+     * Returns the aggregate function object
+     */
+    get aggregate(): ColumnAggregateFn | null;
+    /**
+     * Returns the aggregate group object
+     */
+    get groupAggregate(): ColumnGroupAggregateFn | null;
+    /**
+     * Documentation for this reference-column
+     */
+    get comment(): CommentType;
+    /**
+     * Whether the UI should hide the column header or not.
+     */
+    get hideColumnHeader(): boolean;
+    /**
+     * Indicates if the input should be disabled
+     */
+    get inputDisabled(): boolean | {
+        message: string;
+    };
+    /**
+     * Whether the column is sortable
+     */
+    get sortable(): boolean;
+    /**
+     * An array of objects that have `column` which is a Column object, and `descending` which is true/false
+     */
+    get _sortColumns(): any[];
+    /**
+     * An object which contains column display properties
+     */
+    get display(): any;
+    /**
+     * Indicates if this object is wrapping just one column or not
+     */
+    protected get _simple(): boolean;
+    /**
+     * Whether there are aggregate or entity set columns in the wait_for list of this column.
+     */
+    get hasWaitFor(): boolean;
+    /**
+     * Whether there are aggregate columns in the wait_for list of this column.
+     */
+    get hasWaitForAggregate(): boolean;
+    /**
+     * Array of columns that the current column value depends on.
+     */
+    get waitFor(): ReferenceColumn[];
+    /**
+     * Formats a value corresponding to this reference-column definition.
+     */
+    formatvalue(data: any, context?: string, options?: any): string | string[];
+    /**
+     * Formats the presentation value corresponding to this reference-column definition.
+     */
+    formatPresentation(data: any, context?: string, templateVariables?: any, options?: any): DisplayName;
+    protected _determineInputDisabled(context: string): boolean | {
+        message: string;
+    };
+    protected _determineSortable(): void;
+    protected _getNullValue(context: string): string | null;
+    /**
+     * Whether we should show the link for the foreignkey value.
+     */
+    protected _getShowForeignKeyLink(context: string): boolean;
+    sourceFormatPresentation(templateVariables: any, columnValue: any, mainTuple: Tuple): any;
+    /**
+     * This function should not be used in entry context
+     */
+    /**
+     * Render the location of iframe. will return empty string if invalid or missing.
+     */
+    renderInputIframeUrl(data: any, linkedData: any): string;
+}
+
+declare enum ReferenceColumnTypes {
+    PSEUDO = "pseudo",
+    KEY = "key",
+    ASSET = "asset",
+    FOREIGN_KEY = "foreign_key",
+    VIRTUAL = "virtual",
+    INBOUND_FOREIGN_KEY = "inbound_foreign_key",
+    GENERAL = "general"
+}
+
+declare type ReferenceDisplay = {
+    /**
+     * The display type ('table', 'markdown', or 'module')
+     */
+    type: string;
+    /**
+     * Whether to hide the row count
+     */
+    hideRowCount: boolean;
+    /**
+     * Whether faceting is enabled
+     */
+    showFaceting: boolean;
+    /**
+     * Maximum facet depth allowed
+     */
+    maxFacetDepth: number;
+    /**
+     * Whether the facet panel should be open by default
+     */
+    facetPanelOpen: boolean | null;
+    /**
+     * whether to show the saved query panel
+     */
+    showSavedQuery: boolean;
+    /**
+     * used for computing "custom display" for related tables
+     */
+    _separator: string;
+    /**
+     * used for computing "custom display" for related tables
+     */
+    _prefix: string;
+    /**
+     * used for computing "custom display" for related tables
+     */
+    _suffix: string;
+    /**
+     * how to order the rows
+     */
+    _rowOrder?: Array<{
+        column: Column_2;
+        descending: boolean;
+    } | {
+        num_occurrences: true;
+        descending: boolean;
+    }>;
+    /**
+     * default page size (25)
+     */
+    defaultPageSize?: number;
+    /**
+     * whether the column headers should be hidden (in record page)
+     */
+    hideColumnHeaders?: boolean;
+    /**
+     * whether the toc should be collapsed (in record page)
+     */
+    collapseToc?: boolean;
+    /**
+     * The template engine to use with the markdown patterns
+     */
+    templateEngine?: string;
+    /**
+     * The markdown pattern to use for the page
+     */
+    _pageMarkdownPattern?: string;
+    /**
+     * The markdown pattern to use for the row
+     */
+    _rowMarkdownPattern?: string;
+    /**
+     * the wait-fors that the markdown pattern has
+     */
+    sourceWaitFor: Array<VisibleColumn>;
+    /**
+     * whether the markdown pattern has any wait-fors
+     */
+    sourceHasWaitFor: boolean;
+    /**
+     * the markdown pattern defined on the source def
+     */
+    sourceMarkdownPattern?: string;
+    /**
+     * the template engine to use with the source markdown pattern
+     */
+    sourceTemplateEngine?: string;
+};
+
+declare class RelatedReference extends Reference {
+    private _mainTable;
+    private _mainTuple?;
+    private _origFKR;
+    private _compressedDataSource?;
+    private _derivedAssociationReference?;
+    _relatedKeyColumnPositions: number[];
+    _relatedFkColumnPositions: number[];
+    constructor(location: Location_2, catalog: Catalog, mainTable: Table_2, origFKR: ForeignKeyRef, relatedKeyColumnPositions: number[], relatedFkColumnPositions: number[], compressedDataSource?: any, mainTuple?: Tuple, displayname?: DisplayName, comment?: CommentType, pseudoColumn?: VisibleColumn);
+    /**
+     * the main table
+     * NOTE: the table that this reference represents is the related one, and
+     * it is not the same as the main table.
+     */
+    get mainTable(): Table_2;
+    /**
+     * the main tuple
+     */
+    get mainTuple(): Tuple | undefined;
+    get origFKR(): ForeignKeyRef;
+    get compressedDataSource(): any;
+    set derivedAssociationReference(ref: DerivedAssociationReference);
+    get derivedAssociationReference(): DerivedAssociationReference | undefined;
+    /**
+     * create a new instance with the same properties.
+     *
+     * you can customized the properties of the new instance by passing new ones to this function.
+     * You must pass undefined for other props that you don't want to change.
+     */
+    copy(displayname?: DisplayName, comment?: CommentType, pseudoColumn?: VisibleColumn): RelatedReference;
+    /**
+     * If the current reference is derived from an association related table and filtered, this
+     * function will delete the set of tuples included and return a set of success responses and
+     * a set of errors for the corresponding delete actions for the provided entity set from the
+     * corresponding association table denoted by the list of tuples.
+     *
+     * For example, assume
+     * Table1(K1,C1) <- AssociationTable(FK1, FK2) -> Table2(K2,C2)
+     * and the current tuples are from Table2 with k2 = "2" and k2 = "3".
+     * With origFKRData = {"k1": "1"} this function will return a set of success and error responses for
+     * delete requests to AssociationTable with FK1 = "1" as a part of the path and FK2 = "2" and FK2 = "3"
+     * as the filters that define the set and how they are related to Table1.
+     *
+     * To make sure a deletion occurs only for the tuples specified, we need to verify each reference path that
+     * is created includes a parent constraint and has one or more filters based on the other side of the association
+     * table's uniqueness constraint. Some more information about the validations that need to occur based on the above example:
+     *  - parent value has to be not null
+     *    - FK1 has to have a not null constraint
+     *  - child values have to have at least 1 value and all not null
+     *    - for FK2, all selected values are not null
+     *
+     * @param {Array} mainTuple - an ERMrest.Tuple from Table1 (from example above)
+     * @param {Array} tuples - an array of ERMrest.Tuple objects from Table2 (same as self) (from example above)
+     * @param {Object} contextHeaderParams the object that we want to log.
+     *
+     * @returns {Object} an ERMrest.BatchUnlinkResponse "error" object
+     **/
+    deleteBatchAssociationTuples(parentTuple: Tuple, tuples: Array<Tuple>, contextHeaderParams?: Record<string, unknown>): Promise<BatchUnlinkResponse>;
+}
+
+export declare const renderHandlebarsTemplate: typeof HandlebarsService.render;
+
+/**
+ * returns the rendered markdown content
+ * @param value the markdown value
+ * @param inline whether we should parse this as as inline element or not
+ * @param throwError if true, it will throw the error instead of swalloing it
+ */
+export declare function renderMarkdown(value: string, inline?: boolean, throwError?: boolean): string;
+
+export { renderMustacheTemplate }
+
+export declare const resetUserCookie: typeof ConfigService.resetUserCookie;
+
+/**
+ * This function resolves a URI reference to a {@link Reference}
+ * object. It validates the syntax of the URI and validates that the
+ * references to model elements in it are correct. This function makes a
+ * call to the ERMrest server in order to get the `schema` which it uses to
+ * validate the URI path.
+ *
+ * For a consistent behavior, always contextualize the resolved `Reference` object.
+ * See {@link Reference#contextualize} for more information.
+ *
+ * Usage:
+ * ```
+ * // This example assumes that the client has access to the module
+ * resolve('https://example.org/catalog/42/entity/s:t/k=123').then(
+ *   function(reference) {
+ *     // the uri was successfully resolved to a `Reference` object
+ *     console.log("The reference has URI", reference.uri);
+ *     console.log("It has", reference.columns.length, "columns");
+ *     console.log("Is it unique?", (reference.isUnique ? 'yes' : 'no'));
+ *     ...
+ *   },
+ *   function(error) {
+ *     // there was an error returned here
+ *     ...
+ *   });
+ * ```
+ * @param uri -  An ERMrest resource URI, such as
+ * `https://example.org/ermrest/catalog/1/entity/s:t/k=123`.
+ * @param contextHeaderParams - An optional context header parameters object. The (key, value)
+ * pairs from the object are converted to URL `key=value` query parameters
+ * and appended to every request to the ERMrest service.
+ * @return Promise when resolved passes the
+ * {@link Reference} object. If rejected, passes one of the ermrest errors
+ */
+export declare const resolve: (uri: string, contextHeaderParams?: any) => Promise<Reference>;
+
+export declare const responseToError: typeof ErrorService.responseToError;
+
+declare class SearchFacetFilter extends FacetFilter {
+    facetFilterKey: string;
+    constructor(term: unknown, column: Column);
+}
+
+export declare class ServiceUnavailableError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+export declare const setClientConfig: typeof ConfigService.setClientConfig;
+
+export declare const setClientSession: typeof AuthnService.setClientSession;
+
+export declare const setHTTP401Handler: typeof HTTPService.setHTTP401Handler;
+
+export declare const setUserCookie: typeof ConfigService.setUserCookie;
+
+/**
+ * Interface for sort column objects used in entityCounts method
+ */
+declare interface SortColumn {
+    column?: Column;
+    num_occurrences?: boolean;
+    descending?: boolean;
+}
+
+/**
+ * This is the source object node that is used to represent a source object.
+ * It can be a filter, foreign key, inbound, outbound, or path prefix.
+ */
+declare class SourceObjectNode {
+    /**
+     * the object that represents this node
+     * - if this is a filter, it will be the parsed filter node (Object)
+     * - if this is a foreign key, it will be the foreign key object (ForeignKeyRef)
+     * - if this is a path prefix, it will be the path prefix object (SourceObjectWrapper)
+     */
+    nodeObject: any;
+    /**
+     * the table that this node belongs to (the table that the previous node points to)
+     */
+    table: Table;
+    /**
+     * whether this node is a filter
+     */
+    isFilter: boolean;
+    /**
+     * whether the filter has been processed
+     * - if true, the `parsedFilterNode` will be set to the parsed filter
+     * - if false, the `parsedFilterNode` will be undefined
+     */
+    isFilterProcessed: boolean;
+    /**
+     * whether this node is a foreign key
+     */
+    isForeignKey: boolean;
+    /**
+     * whether the foreign key is inbound or outbound
+     */
+    isInbound: boolean;
+    /**
+     * whether this node is a path prefix
+     */
+    isPathPrefix: boolean;
+    /**
+     * the source key for the path prefix
+     */
+    pathPrefixSourcekey?: string;
+    /**
+     * whether this node is an alternative join
+     */
+    isAlternativeJoin: boolean;
+    /**
+     * the alias for this node
+     */
+    alias?: string;
+    /**
+     * the parsed filter node
+     */
+    private parsedFilterNode?;
+    constructor(nodeObject: any, 
+    /**
+     * the table that this node belongs to (the table that the previous node points to)
+     */
+    table: Table, isFilter: boolean, isForeignKey: boolean, isInbound: boolean, isPathPrefix: boolean, pathPrefixSourcekey: string | undefined, alias: string | undefined, 
+    /**
+     * whether this node is an alternative join
+     */
+    isAlternativeJoin: boolean, 
+    /**
+     * if set to true, the filter will not be processed
+     * this is used by Table.sourceDefinitions to skip processing filters since we still don't have the main tuple
+     */
+    skipProcessingFilters?: boolean, 
+    /**
+     * the main tuple that this node is associated with
+     * this is used to process the filter if this is a filter node
+     */
+    mainTuple?: Tuple);
+    /**
+     * Return the string representation of this node
+     * @param reverse - whether we should reverse the order (applicable to fk)
+     * @param isLeft  - whether we want to use left outer join (applicable to fk)
+     * @param outAlias - output alias
+     * @param isReverseRightJoin - whether this is a reverse right join
+     * @returns string representation
+     */
+    toString(reverse?: boolean, isLeft?: boolean, outAlias?: string, isReverseRightJoin?: boolean): string;
+    /**
+     * Process the filter for this node
+     * @param mainTuple - the main tuple to extract key values from
+     */
+    processFilter(mainTuple?: Tuple): void;
+}
+
+/**
+ * Represents a column-directive
+ */
+declare class SourceObjectWrapper {
+    /**
+     * the source object
+     */
+    sourceObject: Record<string, unknown>;
+    /**
+     * the column that this source object refers to
+     * undefined if it's a virtual column
+     */
+    column?: Column_2;
+    /**
+     * whether the source object has a prefix or not
+     */
+    hasPrefix: boolean;
+    /**
+     * whether the source object has a foreign key path or not
+     */
+    hasPath: boolean;
+    /**
+     * the length of the foreign key path
+     * this is the number of foreign key nodes in the path
+     */
+    foreignKeyPathLength: number;
+    /**
+     * whether the source object has an inbound foreign key path or not
+     */
+    hasInbound: boolean;
+    /**
+     * whether the source object has an aggregate function or not
+     */
+    hasAggregate: boolean;
+    /**
+     * whether any of the source object nodes is filtered or not
+     */
+    isFiltered: boolean;
+    filterProps?: FilterPropsType;
+    /**
+     * whether this is an entity mode or not
+     */
+    isEntityMode: boolean;
+    /**
+     * whether this represents a unique row or not
+     */
+    isUnique: boolean;
+    /**
+     * whether this is unique and filtered
+     */
+    isUniqueFiltered: boolean;
+    /**
+     * returns true if all foreign keys are outbound and all the columns involved are not null.
+     */
+    isAllOutboundNotNullPerModel: boolean;
+    /**
+     *
+     */
+    isAllOutboundNotNull: boolean;
+    lastForeignKeyNode?: SourceObjectNode;
+    firstForeignKeyNode?: SourceObjectNode;
+    name: string;
+    isHash: boolean;
+    sourceObjectNodes: SourceObjectNode[];
+    isInputIframe: boolean;
+    inputIframeProps?: InputIframePropsType;
+    /**
+     * used for facets
+     * TODO is there a better way to manage this?
+     */
+    entityChoiceFilterTuples?: Tuple[];
+    /**
+     * @param sourceObject the column directive object
+     * @param table the root (starting) table
+     * @param isFacet whether this is a facet or not
+     * @param sources already generated source (only useful for source-def generation)
+     * @param mainTuple the main tuple that is used for filters
+     * @param skipProcessingFilters whether we should skip processing filters or not
+     */
+    constructor(sourceObject: Record<string, unknown>, table?: Table, isFacet?: boolean, sources?: unknown, mainTuple?: Tuple, skipProcessingFilters?: boolean);
+    /**
+     * return a new sourceObjectWrapper that is created by merging the given sourceObject and existing object.
+     *
+     * Useful when we have an object with sourcekey and want to find the actual definition. You can then call
+     * clone on the source-def and pass the object.
+     *
+     * const myCol = {"sourcekey": "some_key"};
+     * const sd = table.sourceDefinitions.getSource(myCol.sourcekey);
+     * if (sd) {
+     *   const wrapper = sd.clone(myCol, table);
+     * }
+     *
+     * - attributes in sourceObject will override the similar ones in the current object.
+     * - "source" of sourceObject will be ignored. so "sourcekey" always has priority over "source".
+     * - mainTuple should be passed in detailed context so we can use it for filters.
+     *
+     * @param sourceObject the source object
+     * @param table the table that these sources belong to.
+     * @param isFacet whether this is for a facet or not
+     */
+    clone(sourceObject: Record<string, unknown>, table: Table, isFacet?: boolean, mainTuple?: Tuple): SourceObjectWrapper;
+    /**
+     * Parse the given sourceobject and create the attributes
+     * @param table
+     * @param isFacet  -- validation is differrent if it's a facet
+     * @param sources already generated source (only useful for source-def generation)
+     * @param mainTuple the main tuple that is used for filters
+     * @param skipProcessingFilters whether we should skip processing filters or not
+     * @returns
+     */
+    private _process;
+    /**
+     * Return the string representation of this foreignkey path
+     * returned format:
+     * if not isLeft and outAlias is not passed: ()=()/.../()=()
+     * if isLeft: left()=()/.../left()=()
+     * if outAlias defined: ()=()/.../outAlias:=()/()
+     * used in:
+     *   - export default
+     *   - column.getAggregate
+     *   - reference.read
+     * @param reverse whether we want the reverse path
+     * @param isLeft use left join
+     * @param outAlias the alias that should be added to the output
+     */
+    toString(reverse?: boolean, isLeft?: boolean, outAlias?: string, isReverseRightJoin?: boolean): string;
+    /**
+     * Turn this into a raw source path without any path prefix
+     * NOTE the returned array is not a complete path as it
+     *      doesn't include the last column
+     * currently used in two places:
+     *   - generating hashname for a sourcedef that uses path prefix
+     *   - generating the reverse path for a related entitty
+     * @param reverse
+     * @param outAlias alias that will be added to the last fk
+     *                     regardless of reversing or not
+     */
+    getRawSourcePath(reverse?: boolean, outAlias?: string): any[];
+    /**
+     * Return the reverse path as facet with the value of shortestkey
+     * currently used in two places:
+     *   - column.refernece
+     *   - reference.generateRelatedReference
+     * both are for generating the reverse related entity path
+     * @param tuple
+     * @param rootTable
+     * @param outAlias
+     */
+    getReverseAsFacet(tuple: Tuple, rootTable: Table, outAlias?: string): any;
+    /**
+     * if sourceObject has the required input_iframe properties, will attach `inputIframeProps` and `isInputIframe`
+     * to the sourceObject.
+     * The returned value of this function summarizes whether processing was successful or not.
+     *
+     * var res = processInputIframe(reference, tuple, usedColumnMapping);
+     * if (res.error) {
+     *   console.log(res.message);
+     * } else {
+     *  // success
+     * }
+     *
+     * @param reference the reference object of the parent
+     * @param usedIframeInputMappings an object capturing columns used in other mappings. used to avoid overlapping
+     * @param tuple the tuple object
+     */
+    processInputIframe(reference: Reference, usedIframeInputMappings: any, tuple?: Tuple): {
+        success?: boolean;
+        error?: boolean;
+        message?: string;
+        columns?: ReferenceColumn[];
+    };
+    /**
+     * @param mainTuple
+     * @param dontThrowError if set to true, will not throw an error if the filters are not valid
+     */
+    processFilterNodes(mainTuple?: Tuple, dontThrowError?: boolean): {
+        success: boolean;
+        error?: boolean;
+        message?: string;
+    };
+}
+
+export declare const systemColumnsHeuristicsMode: typeof ConfigService.setSystemColumnsHeuristicsMode;
+
+export declare class TimedOutError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+/**
+ * Constructs a new Tuple. In database jargon, a tuple is a row in a
+ * relation. This object represents a row returned by a query to ERMrest.
+ *
+ * Usage:
+ *  Clients _do not_ directly access this constructor.
+ *  See {@link Page#tuples}.
+ */
+declare class Tuple {
+    private _pageRef;
+    private _page;
+    private _data;
+    private _linkedData;
+    private _linkedDataRIDs;
+    private _rightsSummary;
+    private _associationRightsSummary;
+    _oldData?: Record<string, any>;
+    private _ref?;
+    private _canUpdate?;
+    private _canUpdateReason?;
+    private _canDelete?;
+    private _canUnlink?;
+    private _values?;
+    private _isHTML?;
+    private _canUpdateValues?;
+    private _displayname?;
+    private _rowName?;
+    private _uniqueId?;
+    private _templateVariables?;
+    private _selfTemplateVariable?;
+    constructor(pageReference: Reference, page: Page, data?: Record<string, any>, linkedData?: Record<string, any>, linkedDataRIDs?: Record<string, any>, rightsSummary?: Record<string, any>, associationRightsSummary?: Record<string, any>);
+    /**
+     * This is the reference of the Tuple
+     */
+    get reference(): Reference;
+    /**
+     * This is the page of the Tuple
+     */
+    get page(): Page;
+    /**
+     * Foreign key data.
+     * During the read we get extra information about the foreign keys,
+     * client could use these extra information for different purposes.
+     * One of these usecases is domain_filter_pattern which they can
+     * include foreignkey data in the pattern language.
+     */
+    get linkedData(): Record<string, any>;
+    /**
+     * Foreign key data RID names.
+     * Map of `column.name` keys with the `column.RID` as the value so RIDs
+     * can be used in cases that require safe strings
+     */
+    get linkedDataRIDs(): Record<string, any>;
+    /**
+     * Used for getting the current set of data for the reference.
+     * This stores the original data in the _oldData object to preserve
+     * it before any changes are made and those values can be properly
+     * used in update requests.
+     *
+     * Notably, if a key value is changed, the old value needs to be kept
+     * track of so that the column projections for the uri can be properly created
+     * and both the old and new value for the modified key are submitted together
+     * for proper updating.
+     */
+    get data(): Record<string, any>;
+    checkPermissions(permission: string, colName?: string, isAssoc?: boolean): boolean;
+    /**
+     * Indicates whether the client can update this tuple. Reporting a `true`
+     * value DOES NOT guarantee the user right since some policies may be
+     * undecidable until query execution.
+     *
+     * Usage:
+     * ```
+     * if (tuple.canUpdate) {
+     *   console.log(tuple.displayname, "may be updated by this client");
+     * }
+     * else {
+     *   console.log(tuple.displayname, "cannot be updated by this client");
+     * }
+     * ```
+     */
+    get canUpdate(): boolean;
+    /**
+     * Indicates the reason as to why a user cannot update this tuple.
+     */
+    get canUpdateReason(): string | undefined;
+    /**
+     * Indicates whether the client can delete this tuple. Reporting a `true`
+     * value DOES NOT guarantee the user right since some policies may be
+     * undecidable until query execution.
+     *
+     * Usage:
+     * ```
+     * if (tuple.canDelete) {
+     *   console.log(tuple.displayname, "may be deleted by this client");
+     * }
+     * else {
+     *   console.log(tuple.displayname, "cannot be deleted by this client");
+     * }
+     * ```
+     */
+    get canDelete(): boolean;
+    get canUnlink(): boolean;
+    /**
+     * The array of formatted/raw values of this tuple on basis of context "edit".
+     * The ordering of the values in the array matches the ordering of the columns
+     * in the reference (see {@link ERMrest.Reference#columns}).
+     *
+     * Usage (iterating over all values in the tuple):
+     * ```
+     * for (var i=0; len=reference.columns.length; i<len; i++) {
+     *   console.log(tuple.displayname, "has a", ref.columns[i].displayname,
+     *       "with value", tuple.values[i]);
+     * }
+     * ```
+     *
+     * Usage (getting a specific value by column position):
+     * ```
+     * var column = reference.columns[8]; // the 8th column in this refernece
+     * console.log(tuple.displayname, "has a", column.displayname,
+     *     "with value", tuple.values[column.position]);
+     * ```
+     */
+    get values(): string[];
+    /**
+     * The array of boolean values of this tuple speicifying the value is HTML or not. The ordering of the
+     * values in the array matches the ordering of the columns in the
+     * reference (see {@link ERMrest.Reference#columns}).
+     *
+     * Usage (iterating over all values in the tuple):
+     * ```
+     * for (var i=0; len=reference.columns.length; i<len; i++) {
+     *   console.log(tuple.displayname, tuple.isHTML[i] ? " has an HTML value" : " does not has an HTML value");
+     * }
+     * ```
+     */
+    get isHTML(): boolean[];
+    /**
+     * currently only populated in entry context
+     */
+    get canUpdateValues(): boolean[];
+    /**
+     * The _display name_ of this tuple. For example, if this tuple is a
+     * row from a table, then the display name is defined by the
+     * row_markdown_pattern annotation for the _row_name/title_ context
+     * or by the heuristics (title, name, id(text), SHORTESTKEY Concatenation using ':')
+     *
+     * Usage:
+     * ```
+     * console.log("This tuple has a displayable name of ", tuple.displayname.value);
+     * ```
+     */
+    get displayname(): DisplayName;
+    /**
+     * The row name_ of this tuple. For example, if this tuple is a
+     * row from a table, then the display name is defined by the
+     * row_markdown_pattern annotation for the _row_name_ context
+     * or by the heuristics (title, name, id(text), SHORTESTKEY Concatenation using ':')
+     *
+     * Usage:
+     * ```
+     * console.log("This tuple has a displayable name of ", tuple.rowName.value);
+     * ```
+     */
+    get rowName(): DisplayName;
+    /**
+     * The unique identifier for this tuple composed of the values for each
+     * of the shortest key columns concatenated together by an '_'
+     */
+    get uniqueId(): string;
+    /**
+     * An object of what is available in templating environment for this tuple
+     * it has the following attributes:
+     * - values
+     * - rowName
+     * - uri
+     */
+    get templateVariables(): any;
+    /**
+     * Should be used for populating $self for this tuple in templating environments
+     * It will have,
+     * - rowName
+     * - uri
+     */
+    get selfTemplateVariable(): any;
+    /**
+     * If the Tuple is derived from an association related table,
+     * this function will return a reference to the corresponding
+     * entity of this tuple's association table.
+     *
+     * For example, assume
+     * Table1(K1,C1) <- AssocitaitonTable(FK1, FK2) -> Table2(K2,C2)
+     * and current tuple is from Table2 with k2 = "2".
+     * With origFKRData = {"k1": "1"} this function will return a reference
+     * to AssocitaitonTable with FK1 = "1"" and FK2 = "2".
+     */
+    getAssociationRef(origTableData: Record<string, any>): Reference | null;
+    /**
+     * @desc
+     * This function takes the current Tuple (this) and creates a shallow copy of it while de-referencing
+     * the _data attribute. This way _data can be modified in chaise without changing the originating Tuple
+     * @returns a shallow copy of _this_ tuple with it's _data de-referenced
+     */
+    copy(): Tuple;
+}
+
+export declare class UnauthorizedError extends ERMrestError {
+    constructor(status: string, message: string);
+}
+
+export declare class UnsupportedFilters extends ERMrestError {
+    constructor(discardedFacets: any, partialyDiscardedFacets: any);
+}
+
+export { Upload }
+
+export { validateJSONLD }
+
+export { _validateMustacheTemplate }
+
+/**
+ *  A pseudo-column without any actual source definition behind it.
+ * This constructor assumes that the sourceObject has markdown_name and display.markdown_pattern.
+ *
+ * The name is currently generated by the visible columns logic. It will use the
+ * "$<markdown_name>" pattern and if a column with this name already exists in the table,
+ * it will append "-<integer>" to it.
+ */
+declare class VirtualColumn extends ReferenceColumn {
+    isPseudo: boolean;
+    isVirtualColumn: boolean;
+    constructor(reference: Reference, sourceObjectWrapper: SourceObjectWrapper, name: string, mainTuple?: Tuple);
+}
+
+declare type VisibleColumn = ReferenceColumn | PseudoColumn | VirtualColumn | ForeignKeyPseudoColumn | InboundForeignKeyPseudoColumn | ForeignKeyPseudoColumn | AssetPseudoColumn;
+
+export { }