@jsforce/jsforce-node 0.0.1 → 3.0.0-next.2

package/lib/soap.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @file Manages method call to SOAP endpoint
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+import HttpApi from './http-api';
+import Connection from './connection';
+import { Schema, HttpResponse, HttpRequest, SoapSchema, SoapSchemaDef } from './types';
+/**
+ *
+ */
+export declare function castTypeUsingSchema(value: unknown, schema?: SoapSchema | SoapSchemaDef, schemaDict?: {
+    [name: string]: SoapSchemaDef;
+}): any;
+/**
+ *
+ */
+export type SOAPOptions = {
+    endpointUrl: string;
+    xmlns?: string;
+};
+/**
+ * Class for SOAP endpoint of Salesforce
+ *
+ * @protected
+ * @class
+ * @constructor
+ * @param {Connection} conn - Connection instance
+ * @param {Object} options - SOAP endpoint setting options
+ * @param {String} options.endpointUrl - SOAP endpoint URL
+ * @param {String} [options.xmlns] - XML namespace for method call (default is "urn:partner.soap.sforce.com")
+ */
+export declare class SOAP<S extends Schema> extends HttpApi<S> {
+    _endpointUrl: string;
+    _xmlns: string;
+    constructor(conn: Connection<S>, options: SOAPOptions);
+    /**
+     * Invoke SOAP call using method and arguments
+     */
+    invoke(method: string, args: object, schema?: SoapSchema | SoapSchemaDef, schemaDict?: {
+        [name: string]: SoapSchemaDef;
+    }): Promise<any>;
+    /** @override */
+    beforeSend(request: HttpRequest & {
+        _message: object;
+    }): void;
+    /** @override **/
+    isSessionExpired(response: HttpResponse): boolean;
+    /** @override **/
+    parseError(body: string): {
+        errorCode: string | undefined;
+        message: string | undefined;
+    };
+    /** @override **/
+    getResponseBody(response: HttpResponse): Promise<unknown>;
+    /**
+     * @private
+     */
+    _createEnvelope(message: object): string;
+}
+export default SOAP;

package/lib/soap.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOAP = exports.castTypeUsingSchema = void 0;
+/**
+ * @file Manages method call to SOAP endpoint
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+const http_api_1 = __importDefault(require("./http-api"));
+const function_1 = require("./util/function");
+const get_body_size_1 = require("./util/get-body-size");
+/**
+ *
+ */
+function getPropsSchema(schema, schemaDict) {
+    if (schema.extends && schemaDict[schema.extends]) {
+        const extendSchema = schemaDict[schema.extends];
+        return {
+            ...getPropsSchema(extendSchema, schemaDict),
+            ...schema.props,
+        };
+    }
+    return schema.props;
+}
+function isNillValue(value) {
+    return (value == null ||
+        ((0, function_1.isMapObject)(value) &&
+            (0, function_1.isMapObject)(value.$) &&
+            value.$['xsi:nil'] === 'true'));
+}
+/**
+ *
+ */
+function castTypeUsingSchema(value, schema, schemaDict = {}) {
+    if (Array.isArray(schema)) {
+        const nillable = schema.length === 2 && schema[0] === '?';
+        const schema_ = nillable ? schema[1] : schema[0];
+        if (value == null) {
+            return nillable ? null : [];
+        }
+        return (Array.isArray(value) ? value : [value]).map((v) => castTypeUsingSchema(v, schema_, schemaDict));
+    }
+    else if ((0, function_1.isMapObject)(schema)) {
+        // if schema is Schema Definition, not schema element
+        if ('type' in schema && 'props' in schema && (0, function_1.isMapObject)(schema.props)) {
+            const props = getPropsSchema(schema, schemaDict);
+            return castTypeUsingSchema(value, props, schemaDict);
+        }
+        const nillable = '?' in schema;
+        const schema_ = '?' in schema ? schema['?'] : schema;
+        if (nillable && isNillValue(value)) {
+            return null;
+        }
+        const obj = (0, function_1.isMapObject)(value) ? value : {};
+        return Object.keys(schema_).reduce((o, k) => {
+            const s = schema_[k];
+            const v = obj[k];
+            const nillable = (Array.isArray(s) && s.length === 2 && s[0] === '?') ||
+                ((0, function_1.isMapObject)(s) && '?' in s) ||
+                (typeof s === 'string' && s[0] === '?');
+            if (typeof v === 'undefined' && nillable) {
+                return o;
+            }
+            return {
+                ...o,
+                [k]: castTypeUsingSchema(v, s, schemaDict),
+            };
+        }, obj);
+    }
+    else {
+        const nillable = typeof schema === 'string' && schema[0] === '?';
+        const type = typeof schema === 'string'
+            ? nillable
+                ? schema.substring(1)
+                : schema
+            : 'any';
+        switch (type) {
+            case 'string':
+                return isNillValue(value) ? (nillable ? null : '') : String(value);
+            case 'number':
+                return isNillValue(value) ? (nillable ? null : 0) : Number(value);
+            case 'boolean':
+                return isNillValue(value)
+                    ? nillable
+                        ? null
+                        : false
+                    : value === 'true';
+            case 'null':
+                return null;
+            default: {
+                if (schemaDict[type]) {
+                    const cvalue = castTypeUsingSchema(value, schemaDict[type], schemaDict);
+                    const isEmpty = (0, function_1.isMapObject)(cvalue) && Object.keys(cvalue).length === 0;
+                    return isEmpty && nillable ? null : cvalue;
+                }
+                return value;
+            }
+        }
+    }
+}
+exports.castTypeUsingSchema = castTypeUsingSchema;
+/**
+ * @private
+ */
+function lookupValue(obj, propRegExps) {
+    const regexp = propRegExps.shift();
+    if (!regexp) {
+        return obj;
+    }
+    if ((0, function_1.isMapObject)(obj)) {
+        for (const prop of Object.keys(obj)) {
+            if (regexp.test(prop)) {
+                return lookupValue(obj[prop], propRegExps);
+            }
+        }
+        return null;
+    }
+}
+/**
+ * @private
+ */
+function toXML(name, value) {
+    if ((0, function_1.isObject)(name)) {
+        value = name;
+        name = null;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => toXML(name, v)).join('');
+    }
+    else {
+        const attrs = [];
+        const elems = [];
+        if ((0, function_1.isMapObject)(value)) {
+            for (const k of Object.keys(value)) {
+                const v = value[k];
+                if (k[0] === '@') {
+                    const kk = k.substring(1);
+                    attrs.push(kk + '="' + v + '"');
+                }
+                else {
+                    elems.push(toXML(k, v));
+                }
+            }
+            value = elems.join('');
+        }
+        else {
+            value = String(value)
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&apos;');
+        }
+        const startTag = name
+            ? '<' + name + (attrs.length > 0 ? ' ' + attrs.join(' ') : '') + '>'
+            : '';
+        const endTag = name ? '</' + name + '>' : '';
+        return startTag + value + endTag;
+    }
+}
+/**
+ * Class for SOAP endpoint of Salesforce
+ *
+ * @protected
+ * @class
+ * @constructor
+ * @param {Connection} conn - Connection instance
+ * @param {Object} options - SOAP endpoint setting options
+ * @param {String} options.endpointUrl - SOAP endpoint URL
+ * @param {String} [options.xmlns] - XML namespace for method call (default is "urn:partner.soap.sforce.com")
+ */
+class SOAP extends http_api_1.default {
+    _endpointUrl;
+    _xmlns;
+    constructor(conn, options) {
+        super(conn, options);
+        this._endpointUrl = options.endpointUrl;
+        this._xmlns = options.xmlns || 'urn:partner.soap.sforce.com';
+    }
+    /**
+     * Invoke SOAP call using method and arguments
+     */
+    async invoke(method, args, schema, schemaDict) {
+        const res = await this.request({
+            method: 'POST',
+            url: this._endpointUrl,
+            headers: {
+                'Content-Type': 'text/xml',
+                SOAPAction: '""',
+            },
+            _message: { [method]: args },
+        });
+        return schema ? castTypeUsingSchema(res, schema, schemaDict) : res;
+    }
+    /** @override */
+    beforeSend(request) {
+        request.body = this._createEnvelope(request._message);
+        const headers = request.headers || {};
+        const bodySize = (0, get_body_size_1.getBodySize)(request.body, request.headers);
+        if (request.method === 'POST' &&
+            !('transfer-encoding' in headers) &&
+            !('content-length' in headers) &&
+            !!bodySize) {
+            this._logger.debug(`missing 'content-length' header, setting it to: ${bodySize}`);
+            headers['content-length'] = String(bodySize);
+        }
+        request.headers = headers;
+    }
+    /** @override **/
+    isSessionExpired(response) {
+        return (response.statusCode === 500 &&
+            /<faultcode>[a-zA-Z]+:INVALID_SESSION_ID<\/faultcode>/.test(response.body));
+    }
+    /** @override **/
+    parseError(body) {
+        const error = lookupValue(body, [/:Envelope$/, /:Body$/, /:Fault$/]);
+        return {
+            errorCode: error.faultcode,
+            message: error.faultstring,
+        };
+    }
+    /** @override **/
+    async getResponseBody(response) {
+        const body = await super.getResponseBody(response);
+        return lookupValue(body, [/:Envelope$/, /:Body$/, /.+/]);
+    }
+    /**
+     * @private
+     */
+    _createEnvelope(message) {
+        const header = {};
+        const conn = this._conn;
+        if (conn.accessToken) {
+            header.SessionHeader = { sessionId: conn.accessToken };
+        }
+        if (conn._callOptions) {
+            header.CallOptions = conn._callOptions;
+        }
+        return [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"',
+            ' xmlns:xsd="http://www.w3.org/2001/XMLSchema"',
+            ' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">',
+            '<soapenv:Header xmlns="' + this._xmlns + '">',
+            toXML(header),
+            '</soapenv:Header>',
+            '<soapenv:Body xmlns="' + this._xmlns + '">',
+            toXML(message),
+            '</soapenv:Body>',
+            '</soapenv:Envelope>',
+        ].join('');
+    }
+}
+exports.SOAP = SOAP;
+exports.default = SOAP;

package/lib/sobject.d.ts

@@ -0,0 +1,258 @@
+/// <reference types="node" />
+/**
+ *
+ */
+import { Logger } from './util/logger';
+import { Record, DescribeLayoutResult, DescribeCompactLayoutsResult, DescribeApprovalLayoutsResult, Optional, DmlOptions, SaveResult, UpsertResult, RetrieveOptions, Schema, SObjectNames, SObjectRecord, SObjectInputRecord, SObjectUpdateRecord, SObjectFieldNames, FieldProjectionConfig, FieldPathSpecifier, FieldPathScopedProjection } from './types';
+import Connection from './connection';
+import RecordReference from './record-reference';
+import Query, { QueryOptions, QueryField, QueryCondition, QueryConfig } from './query';
+import QuickAction from './quick-action';
+import { CachedFunction } from './cache';
+import { Readable } from 'stream';
+export type FindOptions<S extends Schema, N extends SObjectNames<S>> = Partial<QueryOptions & Pick<QueryConfig<S, N>, 'sort' | 'includes'> & {
+    limit: number;
+    offset: number;
+}>;
+/**
+ * A class for organizing all SObject access
+ */
+export declare class SObject<S extends Schema, N extends SObjectNames<S>, FieldNames extends SObjectFieldNames<S, N> = SObjectFieldNames<S, N>, RetrieveRecord extends SObjectRecord<S, N, '*'> = SObjectRecord<S, N, '*'>, InputRecord extends SObjectInputRecord<S, N> = SObjectInputRecord<S, N>, UpdateRecord extends SObjectUpdateRecord<S, N> = SObjectUpdateRecord<S, N>> {
+    static _logger: Logger;
+    type: N;
+    _conn: Connection<S>;
+    _logger: Logger;
+    layouts$: CachedFunction<(ln?: string) => Promise<DescribeLayoutResult>>;
+    layouts$$: CachedFunction<(ln?: string) => DescribeLayoutResult>;
+    compactLayouts$: CachedFunction<() => Promise<DescribeCompactLayoutsResult>>;
+    compactLayouts$$: CachedFunction<() => DescribeCompactLayoutsResult>;
+    approvalLayouts$: CachedFunction<() => Promise<DescribeApprovalLayoutsResult>>;
+    approvalLayouts$$: CachedFunction<() => DescribeApprovalLayoutsResult>;
+    /**
+     *
+     */
+    constructor(conn: Connection<S>, type: N);
+    /**
+     * Create records
+     */
+    create(records: InputRecord[], options?: DmlOptions): Promise<SaveResult[]>;
+    create(records: InputRecord, options?: DmlOptions): Promise<SaveResult>;
+    create(records: InputRecord | InputRecord[], options?: DmlOptions): Promise<SaveResult | SaveResult[]>;
+    /**
+     * Synonym of SObject#create()
+     */
+    insert: {
+        (records: InputRecord[], options?: DmlOptions): Promise<SaveResult[]>;
+        (records: InputRecord, options?: DmlOptions): Promise<SaveResult>;
+        (records: InputRecord | InputRecord[], options?: DmlOptions): Promise<SaveResult | SaveResult[]>;
+    };
+    /**
+     * Retrieve specified records
+     */
+    retrieve(ids: string[], options?: RetrieveOptions): Promise<RetrieveRecord[]>;
+    retrieve(ids: string, options?: RetrieveOptions): Promise<RetrieveRecord>;
+    retrieve(ids: string | string[], options?: RetrieveOptions): Promise<RetrieveRecord | RetrieveRecord[]>;
+    /**
+     * Update records
+     */
+    update(records: UpdateRecord[], options?: DmlOptions): Promise<SaveResult[]>;
+    update(records: UpdateRecord, options?: DmlOptions): Promise<SaveResult>;
+    update(records: UpdateRecord | UpdateRecord[], options?: DmlOptions): Promise<SaveResult | SaveResult[]>;
+    /**
+     * Upsert records
+     */
+    upsert(records: InputRecord[], extIdField: FieldNames, options?: DmlOptions): Promise<UpsertResult[]>;
+    upsert(records: InputRecord, extIdField: FieldNames, options?: DmlOptions): Promise<UpsertResult>;
+    upsert(records: InputRecord | InputRecord[], extIdField: FieldNames, options?: DmlOptions): Promise<UpsertResult | UpsertResult[]>;
+    /**
+     * Delete records
+     */
+    destroy(ids: string[], options?: DmlOptions): Promise<SaveResult[]>;
+    destroy(ids: string, options?: DmlOptions): Promise<SaveResult>;
+    destroy(ids: string | string[], options?: DmlOptions): Promise<SaveResult | SaveResult[]>;
+    /**
+     * Synonym of SObject#destroy()
+     */
+    delete: {
+        (ids: string[], options?: DmlOptions): Promise<SaveResult[]>;
+        (ids: string, options?: DmlOptions): Promise<SaveResult>;
+        (ids: string | string[], options?: DmlOptions): Promise<SaveResult | SaveResult[]>;
+    };
+    /**
+     * Synonym of SObject#destroy()
+     */
+    del: {
+        (ids: string[], options?: DmlOptions): Promise<SaveResult[]>;
+        (ids: string, options?: DmlOptions): Promise<SaveResult>;
+        (ids: string | string[], options?: DmlOptions): Promise<SaveResult | SaveResult[]>;
+    };
+    /**
+     * Call Bulk#load() to execute bulkload, returning batch object
+     */
+    bulkload(operation: 'insert' | 'update' | 'upsert' | 'delete' | 'hardDelete', optionsOrInput?: Object | Record[] | Readable | string, input?: Record[] | Readable | string): import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Bulkly insert input data using bulk API
+     */
+    createBulk(input?: Record[] | Readable | string): import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Synonym of SObject#createBulk()
+     */
+    insertBulk: (input?: Record[] | Readable | string) => import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Bulkly update records by input data using bulk API
+     */
+    updateBulk(input?: Record[] | Readable | string): import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Bulkly upsert records by input data using bulk API
+     */
+    upsertBulk(input?: Record[] | Readable | string, extIdField?: string): import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Bulkly delete records specified by input data using bulk API
+     */
+    destroyBulk(input?: Record[] | Readable | string): import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Synonym of SObject#destroyBulk()
+     */
+    deleteBulk: (input?: Record[] | Readable | string) => import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Bulkly hard delete records specified in input data using bulk API
+     */
+    destroyHardBulk(input: Record[] | Readable): import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Synonym of SObject#destroyHardBulk()
+     */
+    deleteHardBulk: (input: Record[] | Readable) => import("./api/bulk").Batch<S, "insert" | "update" | "upsert" | "delete" | "hardDelete">;
+    /**
+     * Describe SObject metadata
+     */
+    describe(): Promise<import("./types").DescribeSObjectResult>;
+    /**
+     *
+     */
+    describe$(): Promise<import("./types").DescribeSObjectResult>;
+    /**
+     *
+     */
+    describe$$(): import("./types").DescribeSObjectResult;
+    /**
+     * Get record representation instance by given id
+     */
+    record(id: string): RecordReference<S, N>;
+    /**
+     * Retrieve recently accessed records
+     */
+    recent(): Promise<Record[]>;
+    /**
+     * Retrieve the updated records
+     */
+    updated(start: string | Date, end: string | Date): Promise<import("./types").UpdatedResult>;
+    /**
+     * Retrieve the deleted records
+     */
+    deleted(start: string | Date, end: string | Date): Promise<import("./types").DeletedResult>;
+    /**
+     * Describe layout information for SObject
+     */
+    layouts(layoutName?: string): Promise<DescribeLayoutResult>;
+    /**
+     * @typedef {Object} CompactLayoutInfo
+     * @prop {Array.<Object>} compactLayouts - Array of compact layouts
+     * @prop {String} defaultCompactLayoutId - ID of default compact layout
+     * @prop {Array.<Object>} recordTypeCompactLayoutMappings - Array of record type mappings
+     */
+    /**
+     * Describe compact layout information defined for SObject
+     *
+     * @param {Callback.<CompactLayoutInfo>} [callback] - Callback function
+     * @returns {Promise.<CompactLayoutInfo>}
+     */
+    compactLayouts(): Promise<DescribeCompactLayoutsResult>;
+    /**
+     * Describe compact layout information defined for SObject
+     *
+     * @param {Callback.<ApprovalLayoutInfo>} [callback] - Callback function
+     * @returns {Promise.<ApprovalLayoutInfo>}
+     */
+    approvalLayouts(): Promise<DescribeApprovalLayoutsResult>;
+    /**
+     * Find and fetch records which matches given conditions
+     */
+    find<R extends Record = Record>(conditions?: Optional<QueryCondition<S, N>>): Query<S, N, SObjectRecord<S, N, '*', R>, 'Records'>;
+    find<R extends Record = Record, FP extends FieldPathSpecifier<S, N> = FieldPathSpecifier<S, N>, FPC extends FieldProjectionConfig = FieldPathScopedProjection<S, N, FP>>(conditions: Optional<QueryCondition<S, N>>, fields?: Optional<QueryField<S, N, FP>>, options?: FindOptions<S, N>): Query<S, N, SObjectRecord<S, N, FPC, R>, 'Records'>;
+    /**
+     * Fetch one record which matches given conditions
+     */
+    findOne<R extends Record = Record>(conditions?: Optional<QueryCondition<S, N>>): Query<S, N, SObjectRecord<S, N, '*', R>, 'SingleRecord'>;
+    findOne<R extends Record = Record, FP extends FieldPathSpecifier<S, N> = FieldPathSpecifier<S, N>, FPC extends FieldProjectionConfig = FieldPathScopedProjection<S, N, FP>>(conditions: Optional<QueryCondition<S, N>>, fields?: Optional<QueryField<S, N, FP>>, options?: FindOptions<S, N>): Query<S, N, SObjectRecord<S, N, FPC, R>, 'SingleRecord'>;
+    /**
+     * Find and fetch records only by specifying fields to fetch.
+     */
+    select<R extends Record = Record, FP extends FieldPathSpecifier<S, N> = FieldPathSpecifier<S, N>, FPC extends FieldProjectionConfig = FieldPathScopedProjection<S, N, FP>>(fields: QueryField<S, N, FP>): Query<S, N, SObjectRecord<S, N, FPC, R>, 'Records'>;
+    /**
+     * Count num of records which matches given conditions
+     */
+    count(conditions?: Optional<QueryCondition<S, N>>): Query<S, N, SObjectRecord<S, N, "*" | FieldPathScopedProjection<S, N, Extract<keyof S["SObjects"][N]["Fields"], string>> | FieldPathScopedProjection<S, N, { [K in Extract<keyof S["SObjects"][N]["ParentReferences"], string>]?: "*" | ("*" | Extract<keyof Extract<S["SObjects"][N]["ParentReferences"][K], import("./types").SObjectDefinition<string>>["Fields"], string> | { [K_1 in Extract<keyof Extract<S["SObjects"][N]["ParentReferences"][K], import("./types").SObjectDefinition<string>>["ParentReferences"], string>]?: "*" | ("*" | Extract<keyof Extract<Extract<S["SObjects"][N]["ParentReferences"][K], import("./types").SObjectDefinition<string>>["ParentReferences"][K_1], import("./types").SObjectDefinition<string>>["Fields"], string> | { [K_2 in Extract<keyof Extract<Extract<S["SObjects"][N]["ParentReferences"][K], import("./types").SObjectDefinition<string>>["ParentReferences"][K_1], import("./types").SObjectDefinition<string>>["ParentReferences"], string>]?: "*" | ("*" | Extract<keyof Extract<Extract<Extract<S["SObjects"][N]["ParentReferences"][K], import("./types").SObjectDefinition<string>>["ParentReferences"][K_1], import("./types").SObjectDefinition<string>>["ParentReferences"][K_2], import("./types").SObjectDefinition<string>>["Fields"], string>[])[] | undefined; })[] | undefined; })[] | undefined; }>, Record, {}>, "Count">;
+    /**
+     * Returns the list of list views for the SObject
+     *
+     * @param {Callback.<ListViewsInfo>} [callback] - Callback function
+     * @returns {Promise.<ListViewsInfo>}
+     */
+    listviews(): import("./util/promise").StreamPromise<unknown>;
+    /**
+     * Returns the list view info in specifed view id
+     *
+     * @param {String} id - List view ID
+     * @returns {ListView}
+     */
+    listview(id: string): ListView;
+    /**
+     * Returns all registered quick actions for the SObject
+     *
+     * @param {Callback.<Array.<QuickAction~QuickActionInfo>>} [callback] - Callback function
+     * @returns {Promise.<Array.<QuickAction~QuickActionInfo>>}
+     */
+    quickActions(): import("./util/promise").StreamPromise<unknown>;
+    /**
+     * Get reference for specified quick aciton in the SObject
+     *
+     * @param {String} actionName - Name of the quick action
+     * @returns {QuickAction}
+     */
+    quickAction(actionName: string): QuickAction<S>;
+}
+/**
+ * A class for organizing list view information
+ *
+ * @protected
+ * @class ListView
+ * @param {Connection} conn - Connection instance
+ * @param {SObject} type - SObject type
+ * @param {String} id - List view ID
+ */
+declare class ListView {
+    _conn: Connection;
+    type: string;
+    id: string;
+    /**
+     *
+     */
+    constructor(conn: Connection, type: string, id: string);
+    /**
+     * Executes query for the list view and returns the resulting data and presentation information.
+     */
+    results(): import("./util/promise").StreamPromise<unknown>;
+    /**
+     * Returns detailed information about a list view
+     */
+    describe(options?: {
+        headers?: {
+            [name: string]: string;
+        };
+    }): import("./util/promise").StreamPromise<unknown>;
+    /**
+     * Explain plan for executing list view
+     */
+    explain(): import("./util/promise").StreamPromise<any>;
+}
+export default SObject;