@types/jsforce

Version 1.11.5
Published 1 year ago
70.4 kB
1 dependency
MIT license

Install

npm i @types/jsforce

yarn add @types/jsforce

pnpm add @types/jsforce

Overview

TypeScript definitions for jsforce

Index

Classes

class Analytics

class Analytics {}

method dashboard

dashboard: (id: string) => Promise<Dashboard>;

method dashboards

dashboards: (callback?: Callback<DashboardInfo[]>) => Promise<DashboardInfo[]>;

method report

report: (id: string) => Promise<Report>;

method reports

reports: (callback?: Callback<ReportInfo[]>) => Promise<ReportInfo[]>;

class Apex

class Apex {}

constructor

constructor(conn: Connection);

method del

del: {
    <T>(
        path: string,
        options: RestApiOptions,
        callback?: Callback<T>
    ): Promise<T>;
    <T>(path: string, callback?: Callback<T>): Promise<T>;
};

method delete

delete: {
    <T>(
        path: string,
        options: RestApiOptions,
        callback?: Callback<T>
    ): Promise<T>;
    <T>(path: string, callback?: Callback<T>): Promise<T>;
};

method get

get: {
    <T>(
        path: string,
        options: RestApiOptions,
        callback?: Callback<T>
    ): Promise<T>;
    <T>(path: string, callback?: Callback<T>): Promise<T>;
};

method patch

patch: {
    <T>(
        path: string,
        body: object,
        options: RestApiOptions,
        callback?: Callback<T>
    ): Promise<T>;
    <T>(path: string, body: object, callback?: Callback<T>): Promise<T>;
    <T>(path: string, callback?: Callback<T>): Promise<T>;
};

method post

post: {
    <T>(
        path: string,
        body: object,
        options: RestApiOptions,
        callback?: Callback<T>
    ): Promise<T>;
    <T>(path: string, body: object, callback?: Callback<T>): Promise<T>;
    <T>(path: string, callback?: Callback<T>): Promise<T>;
};

method put

put: {
    <T>(
        path: string,
        body: object,
        options: RestApiOptions,
        callback?: Callback<T>
    ): Promise<T>;
    <T>(path: string, body: object, callback?: Callback<T>): Promise<T>;
    <T>(path: string, callback?: Callback<T>): Promise<T>;
};

class AsyncResultLocator

class AsyncResultLocator<T> extends EventEmitter implements PromiseLike<T> {}

method check

check: (callback?: Callback<T>) => Promise<T>;

method complete

complete: (callback?: Callback<T>) => Promise<T>;

method finally

finally: (onfinally?: () => void) => Promise<T>;

method poll

poll: (interval: number, timeout: number) => void;

method then

then: <TResult1, TResult2>(
    onfulfilled?: (value: T) => PromiseLike<TResult1> | TResult1,
    onrejected?: (reason: any) => PromiseLike<TResult2> | TResult2
) => Promise<TResult1 | TResult2>;

class BaseConnection

abstract class BaseConnection extends EventEmitter {}

the methods exposed here are done so that a client can use 'declaration augmentation' to get intellisense on their own projects. for example, given a type
interface Foo { thing: string; yes: boolean; }
you can write
declare module "jsforce" { interface Connection { sobject(type: 'Foo'): SObject } }
to ensure that you have the correct data types for the various collection names.

property describe$

describe$: {
    (
        type: string | DescribeSObjectOptions,
        callback?: (err: Error, result: DescribeSObjectResult) => void
    ): DescribeSObjectResult;
    clear(): void;
};

property describeGlobal$

describeGlobal$: {
    (
        callback?: (err: Error, result: DescribeGlobalResult) => void
    ): DescribeGlobalResult;
    clear(): void;
};

method batchDescribe

batchDescribe: (
    options: BatchDescribeSObjectOptions,
    callback?: (err: Error, result: DescribeSObjectResult[]) => void
) => Promise<DescribeSObjectResult[]>;

method create

create: {
    <T>(
        type: string,
        records: Record<T> | Array<Record<T>>,
        options?: RestApiOptions,
        callback?: (err: Error, result: RecordResult | RecordResult[]) => void
    ): Promise<RecordResult | RecordResult[]>;
    <T>(
        records: Record<T> | Record<T>[],
        options?: RestApiOptions,
        callback?: (err: Error, result: RecordResult | RecordResult[]) => void
    ): Promise<RecordResult | RecordResult[]>;
};

method del

del: <T>(
    type: string,
    ids: string | string[],
    options?: RestApiOptions,
    callback?: (err: Error, result: RecordResult | RecordResult[]) => void
) => Promise<RecordResult | RecordResult[]>;

method delete

delete: <T>(
    type: string,
    ids: string | string[],
    options?: RestApiOptions,
    callback?: (err: Error, result: RecordResult | RecordResult[]) => void
) => Promise<RecordResult | RecordResult[]>;

method describe

describe: (
    type: string | DescribeSObjectOptions,
    callback?: (err: Error, result: DescribeSObjectResult) => void
) => Promise<DescribeSObjectResult>;

method describeGlobal

describeGlobal: <T>(
    callback?: (err: Error, result: DescribeGlobalResult) => void
) => Promise<DescribeGlobalResult>;

method destroy

destroy: <T>(
    type: string,
    ids: string | string[],
    options?: RestApiOptions,
    callback?: (err: Error, result: RecordResult | RecordResult[]) => void
) => Promise<RecordResult | RecordResult[]>;

method insert

insert: <T>(
    type: string,
    records: Record<T> | Array<Record<T>>,
    options?: RestApiOptions,
    callback?: (err: Error, result: RecordResult | RecordResult[]) => void
) => Promise<RecordResult | RecordResult[]>;

method query

query: <T>(
    soql: string,
    options?: ExecuteOptions,
    callback?: (err: Error, result: QueryResult<T>) => void
) => Query<QueryResult<T>>;

method queryMore

queryMore: <T>(
    locator: string,
    options?: ExecuteOptions,
    callback?: (err: Error, result: QueryResult<T>) => void
) => Promise<QueryResult<T>>;

method recent

recent: {
    (callback?: (err: Error, result: RecordResult[]) => void): Promise<
        RecordResult[]
    >;
    (
        param: string | number,
        callback?: (err: Error, result: RecordResult[]) => void
    ): Promise<RecordResult[]>;
    (
        type: string,
        limit: number,
        callback?: (err: Error, result: RecordResult[]) => void
    ): Promise<RecordResult[]>;
};

method request

request: <T = object>(
    info: RequestInfo | string,
    options?: HttpApiOptions,
    callback?: (err: Error, Object: T) => void
) => Promise<T>;

method retrieve

retrieve: <T>(
    type: string,
    ids: string | string[],
    options?: RestApiOptions,
    callback?: (err: Error, result: Record<T> | Array<Record<T>>) => void
) => Promise<Record<T> | Array<Record<T>>>;

method search

search: <T>(
    sosl: string,
    callback?: (err: Error, result: SearchResult<T>) => void
) => Promise<SearchResult<T>>;

method sobject

sobject: <T = object>(resource: string) => SObject<T>;

method update

update: {
    <T>(
        type: string,
        records: Record<T> | Array<Record<T>>,
        options?: RestApiOptions,
        callback?: (err: Error, result: RecordResult | Array<Record<T>>) => void
    ): Promise<RecordResult | RecordResult[]>;
    <T>(
        records: Record<T> | Record<T>[],
        options?: RestApiOptions,
        callback?: (err: Error, result: RecordResult | Record<T>[]) => void
    ): Promise<RecordResult | RecordResult[]>;
};

method upsert

upsert: {
    <T>(
        type: string,
        records: Record<T> | Array<Record<T>>,
        extIdField: string,
        options?: RestApiOptions,
        callback?: (err: Error, result: RecordResult | RecordResult[]) => void
    ): Promise<RecordResult | RecordResult[]>;
    <T>(
        records: Record<T> | Record<T>[],
        extIdField: string,
        options?: RestApiOptions,
        callback?: (err: Error, result: RecordResult | RecordResult[]) => void
    ): Promise<RecordResult | RecordResult[]>;
};

class Batch

class Batch extends Writable {}

method check

check: (callback?: (batchInfo: BatchInfo) => void) => Promise<BatchInfo>;

method execute

execute: (
    input?: Record[] | Stream | string,
    callback?: (err: Error, result: RecordResult[] | BatchResultInfo[]) => void
) => Batch;

method poll

poll: (interval: number, timeout: number) => void;

method result

result: (resultId: string) => Parsable<any>;

method retrieve

retrieve: (
    callback?: (batchInfo: BatchInfo) => void
) => Promise<RecordResult[] | BatchResultInfo[]>;

method then

then: () => Promise<any>;

method thenAll

thenAll: (callback: (data: any) => void) => void;

class Bulk

class Bulk {}

constructor

constructor(connection: Connection);

property pollInterval

pollInterval: number;

property pollTimeout

pollTimeout: number;

method createJob

createJob: (type: string, operation: string, options?: BulkOptions) => Job;

method job

job: (id: string) => Job;

method load

load: (
    type: string,
    operation: BulkLoadOperation,
    options?: BulkOptions,
    input?: Record[] | Stream | string,
    callback?: (err: Error, result: RecordResult[] | BatchResultInfo[]) => void
) => Batch;

method query

query: (soql: string) => any;

class Cache

class Cache {}

method clear

clear: (key?: string) => void;

Clear cache entries prefix matching given key
Parameter key
Key prefix of cache entry to clear

method get

get: <T>(key?: string) => CacheEntry<T>;

Retrieve cache entry, or create if not exists
Parameter key
Key of cache entry

class CacheEntry

class CacheEntry<T> extends EventEmitter {}

method clear

clear: () => void;

method get

get: (callback?: (err: Error, result: T) => void) => T | undefined;

method set

set: (value: T) => void;

class Channel

class Channel {}

constructor

constructor(streaming: Streaming, name: string);

class Chatter

class Chatter {}

constructor

constructor(conn: Connection);

method batch

batch: (
    callback?: Callback<BatchRequestResults>
) => Promise<BatchRequestResults>;

method request

request: (
    params: RequestParams,
    callback?: Callback<Request<RequestResult>>
) => Request<RequestResult>;

method resource

resource: (url: string, queryParams?: object) => Resource<RequestResult>;

class Connection

class Connection extends BaseConnection {}

constructor

constructor(params: ConnectionOptions);

property accessToken

accessToken: string;

property analytics

analytics: Analytics;

property apex

apex: Apex;

property bulk

bulk: Bulk;

property cache

cache: Cache;

property chatter

chatter: Chatter;

property instanceUrl

instanceUrl: string;

property limitInfo

limitInfo?: LimitInfo;

property metadata

metadata: Metadata;

property oauth2

oauth2: OAuth2;

property refreshToken

refreshToken?: string;

property soap

soap: SoapApi;

property streaming

streaming: Streaming;

property tooling

tooling: Tooling;

property userInfo

userInfo?: UserInfo;

property version

version: string;

method authorize

authorize: (
    code: string,
    callback?: (err: Error, res: UserInfo) => void
) => Promise<UserInfo>;

method identity

identity: (
    callback?: (err: Error, res: IdentityInfo) => void
) => Promise<IdentityInfo>;

method initialize

initialize: (options?: ConnectionOptions) => void;

method limits

limits: (callback?: (err: Error, res: undefined) => void) => Promise<LimitsInfo>;

login: (
    user: string,
    password: string,
    callback?: (err: Error, res: UserInfo) => void
) => Promise<UserInfo>;

method loginByOAuth2

loginByOAuth2: (
    user: string,
    password: string,
    callback?: (err: Error, res: UserInfo) => void
) => Promise<UserInfo>;

method loginBySoap

loginBySoap: (
    user: string,
    password: string,
    callback?: (err: Error, res: UserInfo) => void
) => Promise<UserInfo>;

method logout

logout: {
    (
        revoke: boolean,
        callback?: (err: Error, res: undefined) => void
    ): Promise<void>;
    (callback?: (err: Error, res: undefined) => void): Promise<void>;
};

method logoutByOAuth2

logoutByOAuth2: {
    (
        revoke: boolean,
        callback?: (err: Error, res: undefined) => void
    ): Promise<void>;
    (callback?: (err: Error, res: undefined) => void): Promise<void>;
};

method logoutBySoap

logoutBySoap: {
    (
        revoke: boolean,
        callback?: (err: Error, res: undefined) => void
    ): Promise<void>;
    (callback?: (err: Error, res: undefined) => void): Promise<void>;
};

method queryAll

queryAll: <T>(
    soql: string,
    options?: object,
    callback?: (err: Error, result: QueryResult<T>) => void
) => Query<QueryResult<T>>;

method requestPost

requestPost: {
    <T = object>(
        url: string,
        body: object,
        options_callback?: HttpApiOptions | ((err: Error, Object: T) => void)
    ): Promise<T>;
    <T = object>(
        url: string,
        body: object,
        options?: HttpApiOptions,
        callback?: (err: Error, Object: T) => void
    ): Promise<T>;
};

class Dashboard

class Dashboard {}

method clone

clone: (
    name: string | object,
    folderid: string,
    callback?: Callback<object>
) => Promise<any>;

method components

components: (
    componentIds: string[] | string | Callback<object>,
    callback?: Callback<object>
) => Promise<any>;

method del

del: (callback?: Callback<object>) => Promise<any>;

method delete

delete: (callback?: Callback<object>) => Promise<any>;

method describe

describe: (callback?: Callback<object>) => Promise<any>;

method destory

destory: (callback?: Callback<object>) => Promise<any>;

method refresh

refresh: (callback?: Callback<object>) => Promise<any>;

method status

status: (callback?: Callback<object>) => Promise<any>;

class DeployResultLocator

class DeployResultLocator<T> extends AsyncResultLocator<T> {}

class ExplainInfo

class ExplainInfo {}

class Job

class Job extends EventEmitter {}

constructor

constructor(
    bulk: Bulk,
    type?: string,
    operation?: string,
    options?: BulkOptions,
    jobId?: string
);

method abort

abort: (callback?: (err: Error, jobInfo: JobInfo) => void) => Promise<any>;

method batch

batch: (batchId: string) => Batch;

method check

check: (callback?: (err: Error, jobInfo: JobInfo) => void) => Promise<JobInfo>;

method close

close: (callback?: (err: Error, jobInfo: JobInfo) => void) => Promise<JobInfo>;

method createBatch

createBatch: () => Batch;

method info

info: (callback?: (err: Error, jobInfo: JobInfo) => void) => Promise<JobInfo>;

method list

list: (
    callback?: (err: Error, jobInfo: BatchInfo) => void
) => Promise<BatchInfo[]>;

method open

open: (callback?: (err: Error, jobInfo: JobInfo) => void) => Promise<JobInfo>;

class ListView

class ListView {}

constructor

constructor(connection: Connection, type: string, id: string);

class ListViewsInfo

class ListViewsInfo {}

class Metadata

class Metadata {}

constructor

constructor(conn: Connection);

property pollInterval

pollInterval: number;

property pollTimeout

pollTimeout: number;

method checkDeployStatus

checkDeployStatus: (
    id: string,
    includeDetails?: boolean,
    callback?: Callback<DeployResult>
) => Promise<DeployResult>;

method checkRetrieveStatus

checkRetrieveStatus: (
    id: string,
    callback?: Callback<RetrieveResult>
) => Promise<RetrieveResult>;

method checkStatus

checkStatus: (
    ids: string | string[],
    callback?: Callback<AsyncResult | AsyncResult[]>
) => AsyncResultLocator<AsyncResult | AsyncResult[]>;

method create

create: (
    type: string,
    metadata: MetadataInfo | MetadataInfo[],
    callback?: Callback<SaveResult | SaveResult[]>
) => Promise<SaveResult | SaveResult[]>;

method createAsync

createAsync: (
    type: string,
    metadata: MetadataInfo | MetadataInfo[],
    callback?: Callback<SaveResult | SaveResult[]>
) => Promise<SaveResult | SaveResult[]>;

method createSync

createSync: (
    type: string,
    metadata: MetadataInfo | MetadataInfo[],
    callback?: Callback<SaveResult | SaveResult[]>
) => Promise<SaveResult | SaveResult[]>;

method delete

delete: (
    type: string,
    fullNames: string | string[],
    callback?: Callback<SaveResult | SaveResult[]>
) => Promise<SaveResult | SaveResult[]>;

method deleteAsync

deleteAsync: (
    type: string,
    metadata: string | string[] | MetadataInfo | MetadataInfo[],
    callback?: Callback<AsyncResult | AsyncResult[]>
) => AsyncResultLocator<AsyncResult | AsyncResult[]>;

method deleteSync

deleteSync: (
    type: string,
    fullNames: string | string[],
    callback?: Callback<SaveResult | SaveResult[]>
) => Promise<SaveResult | SaveResult[]>;

method deploy

deploy: (
    zipInput: Stream | Buffer | string,
    options: DeployOptions,
    callback?: Callback<AsyncResult>
) => DeployResultLocator<AsyncResult>;

method describe

describe: (
    version?: string,
    callback?: Callback<DescribeMetadataResult>
) => Promise<DescribeMetadataResult>;

method list

list: (
    queries: ListMetadataQuery | ListMetadataQuery[],
    version?: string,
    callback?: Callback<FileProperties[]>
) => Promise<FileProperties[]>;

method read

read: (
    type: string,
    fullNames: string | string[],
    callback?: Callback<MetadataInfo | MetadataInfo[]>
) => Promise<MetadataInfo | MetadataInfo[]>;

method readSync

readSync: (
    type: string,
    fullNames: string | string[],
    callback?: Callback<MetadataInfo | MetadataInfo[]>
) => Promise<MetadataInfo | MetadataInfo[]>;

method rename

rename: (
    type: string,
    oldFullName: string,
    newFullName: string,
    callback?: Callback<SaveResult>
) => Promise<SaveResult>;

method retrieve

retrieve: (
    request: RetrieveRequest,
    callback?: Callback<AsyncResult>
) => RetrieveResultLocator<AsyncResult>;

method update

update: (
    type: string,
    updateMetadata: MetadataInfo | MetadataInfo[],
    callback?: Callback<SaveResult | SaveResult[]>
) => Promise<SaveResult | SaveResult[]>;

method updateAsync

updateAsync: (
    type: string,
    updateMetadata: MetadataInfo,
    callback?: Callback<AsyncResult | AsyncResult[]>
) => AsyncResultLocator<AsyncResult | AsyncResult[]>;

method updateSync

updateSync: (
    type: string,
    updateMetadata: MetadataInfo | MetadataInfo[],
    callback?: Callback<SaveResult | SaveResult[]>
) => Promise<SaveResult | SaveResult[]>;

method upsert

upsert: (
    type: string,
    metadata: MetadataInfo | MetadataInfo[],
    callback?: Callback<UpsertResult | UpsertResult[]>
) => Promise<UpsertResult | UpsertResult[]>;

class OAuth2

class OAuth2 {}

constructor

constructor(options?: OAuth2Options);

property authzServiceUrl

authzServiceUrl: string;

property clientId

clientId: string;

property clientSecret

clientSecret: string;

property loginUrl

loginUrl: string;

property redirectUri

redirectUri: string;

property revokeServiceUrl

revokeServiceUrl: string;

property tokenServiceUrl

tokenServiceUrl: string;

method authenticate

authenticate: (
    username: string,
    password: string,
    callback?: (err: Error, tokenResponse: TokenResponse) => void
) => Promise<TokenResponse>;

method getAuthorizationUrl

getAuthorizationUrl: (params: {
    scope?: string | undefined;
    state?: string | undefined;
}) => string;

method refreshToken

refreshToken: (
    code: string,
    callback?: (err: Error, tokenResponse: TokenResponse) => void
) => Promise<TokenResponse>;

method requestToken

requestToken: (
    code: string,
    callback?: (err: Error, tokenResponse: TokenResponse) => void
) => Promise<TokenResponse>;

method revokeToken

revokeToken: (
    accessToken: string,
    callback?: (err: Error) => void
) => Promise<undefined>;

class Parsable

class Parsable<T> extends RecordStream<T> {}

method stream

stream: (type?: string) => Readable;

class Promise

class Promise {}

property thenCall

thenCall: (cb: () => void) => void;

class Query

class Query<T> extends Readable implements Promise<T> {}

property [Symbol.toStringTag]

[Symbol.toStringTag]: string;

method catch

catch: <TResult>(
    onrejected?: (reason: any) => PromiseLike<TResult> | TResult
) => Promise<T | TResult>;

method del

del: {
    (type?: string, callback?: (err: Error, ret: RecordResult) => void): any;
    (callback?: (err: Error, ret: RecordResult) => void): any;
};

method delete

delete: {
    (type?: string, callback?: (err: Error, ret: RecordResult) => void): any;
    (callback?: (err: Error, ret: RecordResult) => void): any;
};

method destroy

destroy: {
    (type?: string, callback?: (err: Error, ret: RecordResult) => void): Promise<
        RecordResult[]
    >;
    (callback?: (err: Error, ret: RecordResult) => void): Promise<
        RecordResult[]
    >;
    (error?: Error): this;
};

method end

end: () => Query<T>;

method exec

exec: (
    options?: ExecuteOptions,
    callback?: (err: Error, records: T[]) => void
) => Query<T>;

method execute

execute: (
    options?: ExecuteOptions,
    callback?: (err: Error, records: T[]) => void
) => Query<T>;

method explain

explain: (
    callback?: (err: Error, info: ExplainInfo) => void
) => Promise<ExplainInfo>;

method filter

filter: (filter: Object) => Query<T>;

method finally

finally: () => Promise<T>;

method hint

hint: (hint: Object) => Query<T>;

method include

include: (include: string) => Query<T>;

method limit

limit: (value: number) => Query<T>;

method map

map: (callback: (currentValue: Object) => void) => Promise<any>;

method maxFetch

maxFetch: (value: number) => Query<T>;

method offset

offset: (value: number) => Query<T>;

method run

run: (
    options?: ExecuteOptions,
    callback?: (err: Error, records: T[]) => void
) => Query<T>;

method scanAll

scanAll: (value: boolean) => Query<T>;

method select

select: (fields: Object | string[] | string) => Query<T>;

method skip

skip: (value: number) => Query<T>;

method sort

sort: (
    keyOrList: string | Object[] | Object,
    direction?: 'ASC' | 'DESC' | number
) => Query<T>;

method then

then: <TResult1, TResult2>(
    onfulfilled?: (value: T) => PromiseLike<TResult1> | TResult1,
    onrejected?: (reason: any) => PromiseLike<TResult2> | TResult2
) => Promise<TResult1 | TResult2>;

method thenCall

thenCall: (callback?: (err: Error, records: T) => void) => Query<T>;

method toSOQL

toSOQL: (callback: (err: Error, soql: string) => void) => Promise<string>;

method update

update: {
    (
        mapping: any,
        type: string,
        callback?: (err: Error, records: RecordResult[]) => void
    ): Promise<RecordResult[]>;
    (
        mapping: any,
        callback?: (err: Error, records: RecordResult[]) => void
    ): Promise<RecordResult[]>;
};

method where

where: (conditions: Object | string) => Query<T>;

class QuickAction

class QuickAction {}

method defaultValues

defaultValues: {
    (contextId: string, callback?: Callback<Record>): Promise<Record>;
    (callback?: Callback<any>): Promise<any>;
};

Retrieve default field values in the action for the given record
Parameter contextId
Id of record
Parameter callback
Callback function
Retrieve default field values in the action

method describe

describe: (
    callback?: Callback<QuickActionDescribeInfo>
) => Promise<QuickActionDescribeInfo>;

Describe the action's information (including layout, etc.)
Parameter callback
Callback function

method execute

execute: <T>(
    contextId: string,
    record: Record<T>,
    callback?: Callback<QuickActionResult>
) => Promise<QuickActionResult>;

Execute the action for given context id and record information
Parameter contextId
Context record ID of the action
Parameter record
Input record information for the action
Parameter callback
Callback function

class RecordReference

class RecordReference<T = any> {}

constructor

constructor(conn: Connection, type: string, id: string);

method blob

blob: (fieldName: string) => Stream;

method del

del: (
    options?: Object,
    callback?: (err: Error, result: RecordResult) => void
) => Promise<RecordResult>;

method delete

delete: (
    options?: Object,
    callback?: (err: Error, result: RecordResult) => void
) => Promise<RecordResult>;

method destroy

destroy: (
    options?: Object,
    callback?: (err: Error, result: RecordResult) => void
) => Promise<RecordResult>;

method retrieve

retrieve: (
    options?: Object,
    callback?: (err: Error, record: Record<T>) => void
) => Promise<Record<T>>;

method update

update: (
    record: Partial<T>,
    options?: Object,
    callback?: (err: Error, result: RecordResult) => void
) => Promise<RecordResult>;

class RecordStream

class RecordStream<T> extends Transform {}

constructor

constructor();

method filter

filter: {
    (fn: (record: Record<T>) => boolean): Serializable<T>;
    (fn: (record: Record<T>) => boolean): RecordStream<T>;
};

method map

map: {
    (fn: (record: Record<T>) => Record<T>): Serializable<T>;
    (fn: (record: Record<T>) => Record<T>): RecordStream<T>;
};

method recordMapStream

recordMapStream: (record: Record<T>, noeval?: boolean) => Serializable<T>;

class Report

class Report {}

method clone

clone: (
    name: string,
    callback?: Callback<ReportResult>
) => Promise<ReportResult>;

method del

del: (callback?: Callback<ReportResult>) => Promise<ReportResult>;

method delete

delete: (callback?: Callback<ReportResult>) => Promise<ReportResult>;

method describe

describe: (callback?: Callback<ReportMetadata>) => Promise<ReportMetadata>;

method destory

destory: (callback?: Callback<ReportResult>) => Promise<ReportResult>;

method exec

exec: (
    options: object | Callback<ReportResult>,
    callback?: Callback<ReportResult>
) => Promise<ReportResult>;

method execute

execute: (
    options: object | Callback<ReportResult>,
    callback?: Callback<ReportResult>
) => Promise<ReportResult>;

method executeAsync

executeAsync: (
    options: object | Callback<ReportInstanceAttrs>,
    callback?: Callback<ReportInstanceAttrs>
) => Promise<ReportInstanceAttrs>;

method explain

explain: (callback?: Callback<ExplainInfo>) => Promise<ExplainInfo>;

method instance

instance: (id: string) => ReportInstance;

method instances

instances: (callback?: Callback<ReportInstance[]>) => Promise<ReportInstance[]>;

method run

run: (
    options: object | Callback<ReportResult>,
    callback?: Callback<ReportResult>
) => Promise<ReportResult>;

class ReportInstance

class ReportInstance {}

constructor

constructor(report: Report, id: string);

method retrieve

retrieve: (callback: Callback<ReportResult>) => Promise<ReportResult>;

class Request

class Request<T> implements PromiseLike<T> {}

constructor

constructor(chatter: Chatter, params: RequestParams);

method batchParams

batchParams: () => BatchRequestParams;

method finally

finally: (onfinally?: () => void) => Promise<T>;

method promise

promise: () => Promise<T>;

method stream

stream: () => Stream;

method then

then: <TResult1, TResult2>(
    onfulfilled?: (value: T) => PromiseLike<TResult1> | TResult1,
    onrejected?: (reason: any) => PromiseLike<TResult2> | TResult2
) => Promise<TResult1 | TResult2>;

method thenCall

thenCall: (callback?: (err: Error, records: T) => void) => Query<T>;

class RequestResult

class RequestResult {}

class Resource

class Resource<T> extends Request<T> {}

constructor

constructor(chatter: Chatter, url: string, queryParams?: {});

method create

create: (data: object | string, callback?: Callback<T>) => Request<T>;

method del

del: (callback?: Callback<T>) => Request<T>;

method delete

delete: (callback?: Callback<T>) => Request<T>;

method retrieve

retrieve: (callback?: Callback<T>) => Request<T>;

method update

update: (data: object, callback?: Callback<T>) => Request<T>;

class RestApi

abstract class RestApi {}

method del

del: (path: string, options: object, callback: () => object) => Promise<object>;

method get

get: (path: string, options: object, callback: () => object) => Promise<object>;

method patch

patch: (
    path: string,
    body: object,
    options: object,
    callback: () => object
) => Promise<object>;

method post

post: (
    path: string,
    body: object,
    options: object,
    callback: () => object
) => Promise<object>;

method put

put: (
    path: string,
    body: object,
    options: object,
    callback: () => object
) => Promise<object>;

class RetrieveResultLocator

class RetrieveResultLocator<T> extends AsyncResultLocator<T> {}

class Serializable

class Serializable<T> extends RecordStream<T> {}

method stream

stream: (type?: string, options?: SerializeOptions) => Readable;

class SfDate

class SfDate {}

constructor

constructor(str: string);

method parseDate

static parseDate: (str: string) => Date;

method toDateLiteral

static toDateLiteral: (date: Date | string | number) => SfDate;

method toDateTimeLiteral

static toDateTimeLiteral: (date: Date | string | number) => SfDate;

class SoapApi

class SoapApi {}

constructor

constructor(conn: Connection);

method convertLead

convertLead: (
    leadConverts: LeadConvert | LeadConvert[],
    callback?: Callback<LeadConvertResult | LeadConvertResult[]>
) => Promise<LeadConvertResult | LeadConvertResult[]>;

method create

create: (
    sObjects: Object[],
    callback?: Callback<SoapSaveResult>
) => Promise<SoapSaveResult>;

method delete

delete: (
    ids: Object[],
    callback?: Callback<SoapDeleteResult>
) => Promise<SoapDeleteResult>;

method describeTabs

describeTabs: (
    callback?: Callback<DescribeTabSetResult[]>
) => Promise<DescribeTabSetResult[]>;

method emptyRecycleBin

emptyRecycleBin: (
    ids: string[],
    callback?: Callback<EmptyRecycleBinResult[]>
) => Promise<EmptyRecycleBinResult[]>;

method getServerTimestamp

getServerTimestamp: (
    callback?: Callback<ServerTimestampResult>
) => Promise<ServerTimestampResult>;

method getUserInfo

getUserInfo: (callback?: Callback<UserInfoResult>) => Promise<UserInfoResult>;

method merge

merge: (
    mergeRequests: MergeRequest | MergeRequest[],
    callback?: Callback<MergeResult | MergeResult[]>
) => Promise<MergeResult | MergeResult[]>;

method setPassword

setPassword: (
    userId: string,
    password: string,
    callback?: Callback<string>
) => Promise<ResetPasswordResult>;

method update

update: (
    sObjects: Object[],
    callback?: Callback<SoapSaveResult>
) => Promise<SoapSaveResult>;

method upsert

upsert: (
    externalIdFieldName: string,
    sObjects: Object[],
    callback?: Callback<SoapUpsertResult>
) => Promise<SoapUpsertResult>;

class SObject

class SObject<T> {}

property approvalLayouts$

approvalLayouts$: {
    (callback?: Callback<ApprovalLayoutInfo>): ApprovalLayoutInfo;
    clear(): void;
};

property compactLayouts$

compactLayouts$: {
    (callback?: Callback<CompactLayoutInfo>): CompactLayoutInfo;
    clear(): void;
};

property describe$

describe$: {
    (callback?: Callback<DescribeSObjectResult>): DescribeSObjectResult;
    clear(): void;
};

property layouts$

layouts$: {
    (layoutName?: string, callback?: Callback<LayoutInfo>): LayoutInfo;
    clear(): void;
};

Returns a value from the cache if it exists, otherwise calls SObject.layouts

method approvalLayouts

approvalLayouts: (
    callback?: Callback<ApprovalLayoutInfo>
) => Promise<ApprovalLayoutInfo>;

method bulkload

bulkload: (
    operation: string,
    options?: { extIdField?: string | undefined },
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method compactLayouts

compactLayouts: (
    callback?: Callback<CompactLayoutInfo>
) => Promise<CompactLayoutInfo>;

method count

count: (
    conditions?: object | string,
    callback?: Callback<number>
) => Query<number>;

method create

create: {
    (
        record: T,
        options?: RestApiOptions,
        callback?: Callback<RecordResult>
    ): Promise<RecordResult>;
    (record: T, callback?: Callback<RecordResult>): Promise<RecordResult>;
    (
        record: T[],
        options?: RestApiOptions,
        callback?: Callback<RecordResult[]>
    ): Promise<RecordResult[]>;
    (record: T[], callback?: Callback<RecordResult[]>): Promise<RecordResult[]>;
};

method createBulk

createBulk: (
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method del

del: {
    (id: string, callback?: Callback<RecordResult>): Promise<RecordResult>;
    (ids: string[], callback?: Callback<RecordResult[]>): Promise<
        RecordResult[]
    >;
};

method delete

delete: {
    (id: string, callback?: Callback<RecordResult>): Promise<RecordResult>;
    (ids: string[], callback?: Callback<RecordResult[]>): Promise<
        RecordResult[]
    >;
};

method deleteBulk

deleteBulk: (
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method deleted

deleted: (
    start: Date | string,
    end: Date | string,
    callback?: Callback<DeletedRecordsInfo>
) => Promise<DeletedRecordsInfo>;

method deleteHardBulk

deleteHardBulk: (
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method describe

describe: (
    callback?: Callback<DescribeSObjectResult>
) => Promise<DescribeSObjectResult>;

method destroy

destroy: {
    (id: string, callback?: Callback<RecordResult>): Promise<RecordResult>;
    (ids: string[], callback?: Callback<RecordResult[]>): Promise<
        RecordResult[]
    >;
};

method destroyBulk

destroyBulk: (
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method destroyHardBulk

destroyHardBulk: (
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method find

find: {
    <T>(query?: object | string, callback?: Callback<Array<Record<T>>>): Query<
        Array<Record<T>>
    >;
    <T>(
        query?: string | object,
        fields?: string | Object | string[],
        callback?: Callback<Record<T>[]>
    ): Query<Record<T>[]>;
    <T>(
        query?: string | object,
        fields?: string | Object | string[],
        options?: FindOptions,
        callback?: Callback<Record<T>[]>
    ): Query<Record<T>[]>;
};

method findOne

findOne: {
    <T>(
        query?: object | string,
        callback?: Callback<Record<T>>
    ): Query<Record<T> | null>;
    <T>(
        query?: string | object,
        fields?: string | Object | string[],
        callback?: Callback<Record<T>>
    ): Query<Record<T>>;
    <T>(
        query?: string | object,
        fields?: string | Object | string[],
        options?: FindOptions,
        callback?: Callback<Record<T>>
    ): Query<Record<T>>;
};

method insert

insert: {
    (
        record: Record<T>,
        callback?: Callback<RecordResult>
    ): Promise<RecordResult>;
    (records: Record<T>[], callback?: Callback<RecordResult[]>): Promise<
        RecordResult[]
    >;
};

method insertBulk

insertBulk: (
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method layouts

layouts: (
    layoutName?: string,
    callback?: Callback<LayoutInfo>
) => Promise<LayoutInfo>;

method listview

listview: (id: string) => ListView;

method listviews

listviews: (callback?: Callback<ListViewsInfo>) => Promise<ListViewsInfo>;

method quickAction

quickAction: (actionName: string) => QuickAction;

method quickActions

quickActions: (
    callback?: Callback<QuickActionInfo[]>
) => Promise<QuickActionInfo[]>;

method recent

recent: (callback?: Callback<RecordResult[]>) => Promise<RecordResult[]>;

method record

record: (id: SalesforceId) => RecordReference<T>;

method retrieve

retrieve: {
    (id: SalesforceId, callback?: Callback<Record<T>>): Promise<Record<T>>;
    (id: string, options?: object, callback?: Callback<Record<T>>): Promise<
        Record<T>
    >;
    (ids: string[], callback?: Callback<Record<T>[]>): Promise<Record<T>[]>;
    (ids: string[], options?: object, callback?: Callback<Record<T>[]>): Promise<
        Record<T>[]
    >;
};

method select

select: {
    (callback?: Callback<T[]>): Query<T[]>;
    (
        fields?: { [P in keyof T]: boolean } | keyof T | (keyof T)[],
        callback?: Callback<Partial<T>[]>
    ): Query<Partial<T>[]>;
};

method update

update: {
    (
        record: Partial<T>,
        callback?: Callback<RecordResult>
    ): Promise<RecordResult>;
    (
        record: Partial<T>,
        options?: RestApiOptions,
        callback?: Callback<RecordResult>
    ): Promise<RecordResult>;
    (records: Partial<T>[], callback?: Callback<RecordResult[]>): Promise<
        RecordResult[]
    >;
    (
        records: Partial<T>[],
        options?: RestApiOptions,
        callback?: Callback<RecordResult[]>
    ): Promise<RecordResult[]>;
};

method updateBulk

updateBulk: (
    input?: Record[] | stream.Stream | string,
    callback?: Callback<RecordResult[]>
) => Batch;

method updated

updated: (
    start: string | Date,
    end: string | Date,
    callback?: Callback<UpdatedRecordsInfo>
) => Promise<UpdatedRecordsInfo>;

method upsert

upsert: {
    (
        records: Record<T>,
        extIdField: string,
        callback?: Callback<RecordResult>
    ): Promise<RecordResult>;
    (
        records: Record<T>,
        extIdField: string,
        options?: RestApiOptions,
        callback?: Callback<RecordResult>
    ): Promise<RecordResult>;
    (
        records: Record<T>[],
        extIdField: string,
        callback?: Callback<RecordResult[]>
    ): Promise<RecordResult[]>;
    (
        records: Record<T>[],
        extIdField: string,
        options?: RestApiOptions,
        callback?: Callback<RecordResult[]>
    ): Promise<RecordResult[]>;
};

method upsertBulk

upsertBulk: (
    input?: Array<Record<T>> | stream.Stream | string,
    callback?: Callback<RecordResult[] | BatchResultInfo[]>
) => Batch;

class Streaming

class Streaming extends EventEmitter {}

constructor

constructor(connection: Connection);

method channel

channel: (channelId: string) => Channel;

method createClient

createClient: (extensions?: any[]) => any;

subscribe: (name: string, listener: StreamingMessage) => any;

method topic

topic: (name: string) => Topic;

method unsubscribe

unsubscribe: (name: string, listener: StreamingMessage) => Streaming;

class Tooling

class Tooling extends BaseConnection {}

method executeAnonymous

executeAnonymous: (
    body: string,
    callback?: (err: Error, res: any) => void
) => Promise<ExecuteAnonymousResult>;

class Topic

class Topic {}

constructor

constructor(streaming: Streaming, name: string);

subscribe: (listener: (streamingMessage: StreamingMessage) => void) => any;

method unsubscribe

unsubscribe: (listener: (streamingMessage: StreamingMessage) => void) => Topic;

Interfaces

interface ActionOverride

interface ActionOverride {}

property formFactor

formFactor: string;

property isAvailableInTouch

isAvailableInTouch: boolean;

property name

name: string;

property pageId

pageId: string;

property url

url?: maybe<string> | undefined;

interface ApprovalLayoutInfo

interface ApprovalLayoutInfo {}

property approvalLayouts

approvalLayouts: Object[];

interface AsyncResult

interface AsyncResult {}

property done

done: boolean;

property id

id: string;

property message

message?: string | undefined;

property state

state: string;

property statusCode

statusCode?: string | undefined;

interface BatchDescribeSObjectOptions

interface BatchDescribeSObjectOptions {}

property autofetch

autofetch?: boolean | undefined;

property maxConcurrentRequests

maxConcurrentRequests?: number | undefined;

property types

types: string[];

interface BatchInfo

interface BatchInfo {}

property id

id: string;

property jobId

jobId: string;

property numberRecordsFailed

numberRecordsFailed: string;

property numberRecordsProcessed

numberRecordsProcessed: string;

property state

state: string;

property stateMessage

stateMessage: string;

property totalProcessingTime

totalProcessingTime: string;

interface BatchRequestParams

interface BatchRequestParams extends RequestParams {}

property method

method: string;

property richInput

richInput?: string | undefined;

property url

url: string;

interface BatchRequestResult

interface BatchRequestResult {}

property result

result: RequestResult;

property statusCode

statusCode: string;

interface BatchRequestResults

interface BatchRequestResults {}

property hasError

hasError: boolean;

property results

results: BatchRequestResult[];

interface BatchResultInfo

interface BatchResultInfo {}

property batchId

batchId?: string | undefined;

property errors

errors?: string[] | undefined;

property id

id: string;

property jobId

jobId?: string | undefined;

property success

success?: boolean | undefined;

interface BulkOptions

interface BulkOptions {}

property concurrencyMode

concurrencyMode?: 'Serial' | 'Parallel' | undefined;

property extIdField

extIdField: string;

interface ChildRelationship

interface ChildRelationship {}

property cascadeDelete

cascadeDelete: boolean;

property childSObject

childSObject: string;

property deprecatedAndHidden

deprecatedAndHidden: boolean;

property field

field: string;

property junctionIdListNames

junctionIdListNames: string[];

property junctionReferenceTo

junctionReferenceTo: string[];

property relationshipName

relationshipName?: maybe<string> | undefined;

property restrictedDelete

restrictedDelete: boolean;

interface CompactLayoutInfo

interface CompactLayoutInfo {}

property compactLayouts

compactLayouts: Object[];

property defaultCompactLayoutId

defaultCompactLayoutId: string;

property recordTypeCompactLayoutMappings

recordTypeCompactLayoutMappings: Object[];

interface ConnectionOptions

interface ConnectionOptions extends PartialOAuth2Options {}

property accessToken

accessToken?: string | undefined;

property callOptions

callOptions?: Object | undefined;

property httpProxy

httpProxy?: string | undefined;

property instanceUrl

instanceUrl?: string | undefined;

property loginUrl

loginUrl?: string | undefined;

property logLevel

logLevel?: string | undefined;

property maxRequest

maxRequest?: number | undefined;

property oauth2

oauth2?: Partial<PartialOAuth2Options> | undefined;

property proxyUrl

proxyUrl?: string | undefined;

property redirectUri

redirectUri?: string | undefined;

property refreshFn

refreshFn?:
    | ((
          conn: Connection,
          callback: (
              err: Error | null,
              accessToken: string,
              res?: unknown
          ) => void
      ) => unknown)
    | undefined;

property refreshToken

refreshToken?: string | undefined;

property serverUrl

serverUrl?: string | undefined;

property sessionId

sessionId?: string | undefined;

property signedRequest

signedRequest?: string | Object | undefined;

property version

version?: string | undefined;

interface CSVStreamConverterOptions

interface CSVStreamConverterOptions {}

property headers

headers?: string[];

property nullValue

nullValue?: string;

interface DailyApiRequests

interface DailyApiRequests extends Limit {}

property "Chatter Desktop"

'Chatter Desktop': Limit;

property "Chatter Mobile for BlackBerry"

'Chatter Mobile for BlackBerry': Limit;

property "Salesforce Files"

'Salesforce Files': Limit;

property "Salesforce for Android"

'Salesforce for Android': Limit;

property "Salesforce for iOS"

'Salesforce for iOS': Limit;

property "Salesforce Marketing Cloud"

'Salesforce Marketing Cloud': Limit;

property "SalesforceA"

SalesforceA: Limit;

interface DashboardInfo

interface DashboardInfo {}

interface DeletedRecord

interface DeletedRecord {}

property deletedDate

deletedDate: string;

property id

id: string;

interface DeletedRecordsInfo

interface DeletedRecordsInfo {}

property deletedRecords

deletedRecords: DeletedRecord[];

property earliestDateAvailable

earliestDateAvailable: string;

property latestDateCovered

latestDateCovered: string;

interface DeployOptions

interface DeployOptions {}

property allowMissingFiles

allowMissingFiles?: boolean | undefined;

property autoUpdatePackage

autoUpdatePackage?: boolean | undefined;

property checkOnly

checkOnly?: boolean | undefined;

property ignoreWarnings

ignoreWarnings?: boolean | undefined;

property performRetrieve

performRetrieve?: boolean | undefined;

property purgeOnDelete

purgeOnDelete?: boolean | undefined;

property rollbackOnError

rollbackOnError?: boolean | undefined;

property runAllTests

runAllTests?: boolean | undefined;

property runTests

runTests?: string[] | undefined;

property singlePackage

singlePackage?: boolean | undefined;

interface DeployResult

interface DeployResult {}

property checkOnly

checkOnly: boolean;

property completedDate

completedDate: string;

property createdDate

createdDate: string;

property details

details?: object[] | undefined;

property done

done: boolean;

property errorMessage

errorMessage?: string | undefined;

property errorStatusCode

errorStatusCode?: string | undefined;

property id

id: string;

property ignoreWarnings

ignoreWarnings?: boolean | undefined;

property lastModifiedDate

lastModifiedDate: string;

property numberComponentErrors

numberComponentErrors: number;

property numberComponentsDeployed

numberComponentsDeployed: number;

property numberComponentsTotal

numberComponentsTotal: number;

property numberTestErrors

numberTestErrors: number;

property numberTestsCompleted

numberTestsCompleted: number;

property numberTestsTotal

numberTestsTotal: number;

property rollbackOnError

rollbackOnError?: boolean | undefined;

property startDate

startDate: string;

property status

status: string;

property success

success: boolean;

interface DescribeGlobalResult

interface DescribeGlobalResult {}

property encoding

encoding: string;

property maxBatchSize

maxBatchSize: number;

property sobjects

sobjects: DescribeGlobalSObjectResult[];

interface DescribeGlobalSObjectResult

interface DescribeGlobalSObjectResult {}

property activateable

activateable: boolean;

property createable

createable: boolean;

property custom

custom: boolean;

property customSetting

customSetting: boolean;

property deletable

deletable: boolean;

property deprecatedAndHidden

deprecatedAndHidden: boolean;

property feedEnabled

feedEnabled: boolean;

property hasSubtypes

hasSubtypes: boolean;

property isSubtype

isSubtype: boolean;

property keyPrefix

keyPrefix: string | null;

property label

label: string;

property labelPlural

labelPlural: string;

property layoutable

layoutable: boolean;

property mergeable

mergeable: boolean;

property mruEnabled

mruEnabled: boolean;

property name

name: string;

property queryable

queryable: boolean;

property replicateable

replicateable: boolean;

property retrieveable

retrieveable: boolean;

property searchable

searchable: boolean;

property triggerable

triggerable: boolean;

property undeletable

undeletable: boolean;

property updateable

updateable: boolean;

property urls

urls: Record<string, string>;

interface DescribeMetadataResult

interface DescribeMetadataResult {}

property metadataObjects

metadataObjects: MetadataObject[];

property organizationNamespace

organizationNamespace: string;

property partialSaveAllowed

partialSaveAllowed: boolean;

property testRequired

testRequired: boolean;

interface DescribeSObjectOptions

interface DescribeSObjectOptions {}

property ifModifiedSince

ifModifiedSince?: string | undefined;

property type

type: string;

interface DescribeSObjectResult

interface DescribeSObjectResult {}

property actionOverrides

actionOverrides?: maybe<ActionOverride[]> | undefined;

property activateable

activateable: boolean;

property childRelationships

childRelationships: ChildRelationship[];

property compactLayoutable

compactLayoutable: boolean;

property createable

createable: boolean;

property custom

custom: boolean;

property customSetting

customSetting: boolean;

property deletable

deletable: boolean;

property deprecatedAndHidden

deprecatedAndHidden: boolean;

property feedEnabled

feedEnabled: boolean;

property fields

fields: Field[];

property keyPrefix

keyPrefix?: maybe<string> | undefined;

property label

label: string;

property labelPlural

labelPlural: string;

property layoutable

layoutable: boolean;

property listviewable

listviewable?: maybe<boolean> | undefined;

property lookupLayoutable

lookupLayoutable?: maybe<boolean> | undefined;

property mergeable

mergeable: boolean;

property mruEnabled

mruEnabled: boolean;

property name

name: string;

property namedLayoutInfos

namedLayoutInfos: NamedLayoutInfo[];

property networkScopeFieldName

networkScopeFieldName?: maybe<string> | undefined;

property queryable

queryable: boolean;

property recordTypeInfos

recordTypeInfos: RecordTypeInfo[];

property replicateable

replicateable: boolean;

property retrieveable

retrieveable: boolean;

property searchable

searchable: boolean;

property searchLayoutable

searchLayoutable: boolean;

property supportedScopes

supportedScopes: ScopeInfo[];

property triggerable

triggerable: boolean;

property undeletable

undeletable: boolean;

property updateable

updateable: boolean;

property urlDetail

urlDetail?: string | undefined;

property urlEdit

urlEdit?: string | undefined;

property urlNew

urlNew?: string | undefined;

property urls

urls: Record<string, string>;

interface DescribeTab

interface DescribeTab {}

property colors

colors: Object[];

property custom

custom: boolean;

property icons

icons: Object[];

property iconUrl

iconUrl: Object[];

property label

label: string;

property miniIconUrl

miniIconUrl: string;

property name

name: string;

property sobjectName

sobjectName: string;

property url

url: string;

interface DescribeTabSetResult

interface DescribeTabSetResult {}

property label

label: string;

property logoUrl

logoUrl: string;

property namespace

namespace: string;

property selected

selected: boolean;

property tabs

tabs: DescribeTab[];

interface EmptyRecycleBinResult

interface EmptyRecycleBinResult {}

property errors

errors: Object[];

property id

id: string;

property success

success: boolean;

interface Error

interface Error {}

property fields

fields: string[];

property message

message: string;

property statusCode

statusCode: string;

interface ErrorResult

interface ErrorResult {}

property errors

errors: Error[];

property success

success: false;

interface ExecuteAnonymousResult

interface ExecuteAnonymousResult {}

property column

column: number;

property compiled

compiled: boolean;

property compileProblem

compileProblem: string;

property exceptionMessage

exceptionMessage: string;

property exceptionStackTrace

exceptionStackTrace: string;

property line

line: number;

property success

success: boolean;

interface ExecuteOptions

interface ExecuteOptions {}

property autoFetch

autoFetch?: boolean | undefined;

property headers

headers?: object | undefined;

property maxFetch

maxFetch?: number | undefined;

property scanAll

scanAll?: boolean | undefined;

interface Field

interface Field {}

property aggregatable

aggregatable: boolean;

property aiPredictionField

aiPredictionField?: maybe<boolean> | undefined;

property autoNumber

autoNumber: boolean;

property byteLength

byteLength: number;

property calculated

calculated: boolean;

property calculatedFormula

calculatedFormula?: maybe<string> | undefined;

property cascadeDelete

cascadeDelete: boolean;

property caseSensitive

caseSensitive: boolean;

property compoundFieldName

compoundFieldName?: maybe<string> | undefined;

property controllerName

controllerName?: maybe<string> | undefined;

property createable

createable: boolean;

property custom

custom: boolean;

property defaultedOnCreate

defaultedOnCreate: boolean;

property defaultValue

defaultValue?: maybe<string | boolean> | undefined;

property defaultValueFormula

defaultValueFormula?: maybe<string> | undefined;

property dependentPicklist

dependentPicklist: boolean;

property deprecatedAndHidden

deprecatedAndHidden: boolean;

property digits

digits?: maybe<number> | undefined;

property displayLocationInDecimal

displayLocationInDecimal?: maybe<boolean> | undefined;

property encrypted

encrypted?: maybe<boolean> | undefined;

property externalId

externalId: boolean;

property extraTypeInfo

extraTypeInfo?: maybe<ExtraTypeInfo> | undefined;

property filterable

filterable: boolean;

property filteredLookupInfo

filteredLookupInfo?: maybe<FilteredLookupInfo> | undefined;

property formula

formula?: maybe<string> | undefined;

property formulaTreatNullNumberAsZero

formulaTreatNullNumberAsZero?: maybe<boolean> | undefined;

property groupable

groupable: boolean;

property highScaleNumber

highScaleNumber?: maybe<boolean> | undefined;

property htmlFormatted

htmlFormatted: boolean;

property idLookup

idLookup: boolean;

property inlineHelpText

inlineHelpText?: maybe<string> | undefined;

property label

label: string;

property length

length: number;

property mask

mask?: maybe<string> | undefined;

property maskType

maskType?: maybe<string> | undefined;

property name

name: string;

property nameField

nameField: boolean;

property namePointing

namePointing: boolean;

property nillable

nillable: boolean;

property permissionable

permissionable: boolean;

property picklistValues

picklistValues?: maybe<PicklistEntry[]> | undefined;

property polymorphicForeignKey

polymorphicForeignKey: boolean;

property precision

precision?: maybe<number> | undefined;

property queryByDistance

queryByDistance: boolean;

property referenceTargetField

referenceTargetField?: maybe<string> | undefined;

property referenceTo

referenceTo?: maybe<string[]> | undefined;

property relationshipName

relationshipName?: maybe<string> | undefined;

property relationshipOrder

relationshipOrder?: maybe<number> | undefined;

property restrictedDelete

restrictedDelete?: maybe<boolean> | undefined;

property restrictedPicklist

restrictedPicklist: boolean;

property scale

scale: number;

property searchPrefilterable

searchPrefilterable: boolean;

property soapType

soapType: SOAPType;

property sortable

sortable: boolean;

property type

type: FieldType;

property unique

unique: boolean;

property updateable

updateable: boolean;

property writeRequiresMasterRead

writeRequiresMasterRead?: maybe<boolean> | undefined;

interface FileProperties

interface FileProperties {}

property createdById

createdById: string;

property createdByName

createdByName: string;

property createdDate

createdDate: string;

property fileName

fileName: string;

property fullName

fullName: string;

property id

id: string;

property lastModifiedById

lastModifiedById: string;

property lastModifiedByName

lastModifiedByName: string;

property lastModifiedDate

lastModifiedDate: string;

property manageableState

manageableState?: string | undefined;

property namespacePrefix

namespacePrefix?: string | undefined;

property type

type: string;

interface FilteredLookupInfo

interface FilteredLookupInfo {}

property controllingFields

controllingFields: string[];

property dependent

dependent: boolean;

property optionalFilter

optionalFilter: boolean;

interface FindOptions

interface FindOptions {}

property limit

limit?: number | undefined;

property offset

offset?: number | undefined;

property skip

skip?: number | undefined;

interface IdentityInfo

interface IdentityInfo {}

property active

active: boolean;

property addr_city

addr_city: string | null;

property addr_country

addr_country: string | null;

property addr_state

addr_state: string | null;

property addr_street

addr_street: string | null;

property addr_zip

addr_zip: string | null;

property asserted_user

asserted_user: boolean;

property display_name

display_name: string;

property email

email: string;

property email_verified

email_verified: boolean;

property first_name

first_name: string | null;

property id

id: string;

property is_app_installed

is_app_installed: boolean;

property is_lightning_login_user

is_lightning_login_user: boolean;

property language

language: string;

property last_modified_date

last_modified_date: Date;

property last_name

last_name: string;

property locale

locale: string;

property mobile_phone

mobile_phone: string | null;

property mobile_phone_verified

mobile_phone_verified: boolean;

property nick_name

nick_name: string;

property organization_id

organization_id: string;

property photos

photos: {
    picture: string;
    thumbnail: string;
};

property status

status: {
    created_date: Date | null;
    body: string | null;
};

property timezone

timezone: string;

property urls

urls: {
    enterprise: string;
    metadata: string;
    partner: string;
    rest: string;
    sobjects: string;
    search: string;
    query: string;
    recent: string;
    tooling_soap: string;
    tooling_rest: string;
    profile: string;
    feeds: string;
    groups: string;
    users: string;
    feed_items: string;
    feed_elements: string;
    custom_domain?: string | undefined;
};

property user_id

user_id: string;

property user_type

user_type: string;

property username

username: string;

property utcOffset

utcOffset: number;

index signature

[key: string]: any;

interface JobInfo

interface JobInfo {}

property id

id: string;

property object

object: string;

property operation

operation: string;

property state

state: string;

interface LayoutInfo

interface LayoutInfo {}

property layouts

layouts: Object[];

property recordTypeMappings

recordTypeMappings: Object[];

interface LeadConvert

interface LeadConvert {}

property accountId

accountId?: string | undefined;

property contactId

contactId?: string | undefined;

property convertedStatus

convertedStatus: string;

property doNotCreateOpportunity

doNotCreateOpportunity?: boolean | undefined;

property leadId

leadId: string;

property opportunityName

opportunityName?: string | undefined;

property overwriteLeadSource

overwriteLeadSource?: boolean | undefined;

property ownerId

ownerId?: string | undefined;

property sendNotificationEmail

sendNotificationEmail?: boolean | undefined;

interface LeadConvertResult

interface LeadConvertResult {}

property accountId

accountId?: string | undefined;

property contactId

contactId?: string | undefined;

property errors

errors: Object[];

property leadId

leadId: string;

property opportunityId

opportunityId?: string | undefined;

property success

success: boolean;

interface Limit

interface Limit {}

property Max

Max: number;

property Remaining

Remaining: number;

interface LimitInfo

interface LimitInfo {}

property apiUsage

apiUsage: {
    used: number;
    limit: number;
};

interface LimitsInfo

interface LimitsInfo {}

property ConcurrentAsyncGetReportInstances

ConcurrentAsyncGetReportInstances: Limit;

property ConcurrentSyncReportRuns

ConcurrentSyncReportRuns: Limit;

property DailyAnalyticsDataflowJobExecutions

DailyAnalyticsDataflowJobExecutions: Limit;

property DailyApiRequests

DailyApiRequests: DailyApiRequests;

property DailyAsyncApexExecutions

DailyAsyncApexExecutions: Limit;

property DailyBulkApiRequests

DailyBulkApiRequests: DailyApiRequests;

property DailyDurableGenericStreamingApiEvents

DailyDurableGenericStreamingApiEvents: Limit;

property DailyDurableStreamingApiEvents

DailyDurableStreamingApiEvents: Limit;

property DailyGenericStreamingApiEvents

DailyGenericStreamingApiEvents: DailyApiRequests;

property DailyStreamingApiEvents

DailyStreamingApiEvents: DailyApiRequests;

property DailyWorkflowEmails

DailyWorkflowEmails: Limit;

property DataStorageMB

DataStorageMB: Limit;

property DurableStreamingApiConcurrentClients

DurableStreamingApiConcurrentClients: Limit;

property FileStorageMB

FileStorageMB: Limit;

property HourlyAsyncReportRuns

HourlyAsyncReportRuns: Limit;

property HourlyDashboardRefreshes

HourlyDashboardRefreshes: Limit;

property HourlyDashboardResults

HourlyDashboardResults: Limit;

property HourlyDashboardStatuses

HourlyDashboardStatuses: Limit;

property HourlyODataCallout

HourlyODataCallout: Limit;

property HourlySyncReportRuns

HourlySyncReportRuns: Limit;

property HourlyTimeBasedWorkflow

HourlyTimeBasedWorkflow: Limit;

property MassEmail

MassEmail: Limit;

property MonthlyPlatformEvents

MonthlyPlatformEvents: Limit;

property Package2VersionCreates

Package2VersionCreates: Limit;

property PermissionSets

PermissionSets: PermissionSets;

property SingleEmail

SingleEmail: Limit;

property StreamingApiConcurrentClients

StreamingApiConcurrentClients: Limit;

interface ListMetadataQuery

interface ListMetadataQuery {}

property folder

folder?: string | undefined;

property type

type: string;

interface MergeRequest

interface MergeRequest {}

property masterRecord

masterRecord: Object;

property recordToMergeIds

recordToMergeIds: string[];

interface MergeResult

interface MergeResult {}

property errors

errors?: Object[] | undefined;

property id

id: string;

property mergedRecordIds

mergedRecordIds?: string[] | undefined;

property success

success: boolean;

property updatedRelatedIds

updatedRelatedIds?: string[] | undefined;

interface MetadataInfo

interface MetadataInfo {}

property fullName

fullName: string;

interface MetadataObject

interface MetadataObject {}

property childXmlNames

childXmlNames?: string[] | undefined;

property directoryName

directoryName?: string | undefined;

property inFolder

inFolder?: boolean | undefined;

property metaFile

metaFile?: boolean | undefined;

property suffix

suffix?: string | undefined;

property xmlName

xmlName: string;

interface NamedLayoutInfo

interface NamedLayoutInfo {}

property name

name: string;

property urls

urls: Record<string, string>;

interface OAuth2Options

interface OAuth2Options {}

property authCode

authCode?: string | undefined;

property authzServiceUrl

authzServiceUrl?: string | undefined;

property clientId

clientId?: string | undefined;

property clientSecret

clientSecret?: string | undefined;

property httpProxy

httpProxy?: string | undefined;

property loginUrl

loginUrl?: string | undefined;

property privateKey

privateKey?: string | undefined;

property privateKeyFile

privateKeyFile?: string | undefined;

property proxyUrl

proxyUrl?: string | undefined;

property redirectUri

redirectUri?: string | undefined;

property refreshToken

refreshToken?: string | undefined;

property revokeServiceUrl

revokeServiceUrl?: string | undefined;

property tokenServiceUrl

tokenServiceUrl?: string | undefined;

interface Package

interface Package {}

property apiAccessLevel

apiAccessLevel?: 'Unrestricted' | 'Restricted' | undefined;

property description

description?: string | undefined;

property fullName

fullName?: string | undefined;

property namespacePrefix

namespacePrefix?: string | undefined;

property objectPermissions

objectPermissions?: ProfileObjectPermissions[] | undefined;

property postInstallClass

postInstallClass?: string | undefined;

property setupWeblink

setupWeblink?: string | undefined;

property types

types: PackageTypeMembers[];

property uninstallClass

uninstallClass?: string | undefined;

property version

version: string;

interface PackageTypeMembers

interface PackageTypeMembers {}

property members

members: string[];

property name

name: string;

interface PartialOAuth2Options

interface PartialOAuth2Options {}

property authzServiceUrl

authzServiceUrl?: string | undefined;

property clientId

clientId?: string | undefined;

property clientSecret

clientSecret?: string | undefined;

property loginUrl

loginUrl?: string | undefined;

property redirectUri

redirectUri?: string | undefined;

property tokenServiceUrl

tokenServiceUrl?: string | undefined;

interface PermissionSets

interface PermissionSets extends Limit {}

property CreateCustom

CreateCustom: Limit;

interface PicklistEntry

interface PicklistEntry {}

property active

active: boolean;

property defaultValue

defaultValue: boolean;

property label

label?: maybe<string> | undefined;

property validFor

validFor?: maybe<string> | undefined;

property value

value: string;

interface ProfileObjectPermissions

interface ProfileObjectPermissions {}

property allowCreate

allowCreate?: boolean | undefined;

property allowDelete

allowDelete?: boolean | undefined;

property allowEdit

allowEdit?: boolean | undefined;

property allowRead

allowRead?: boolean | undefined;

property modifyAllRecords

modifyAllRecords?: boolean | undefined;

property object

object: string;

property viewAllRecords

viewAllRecords?: boolean | undefined;

interface QueryResult

interface QueryResult<T> {}

property done

done: boolean;

property nextRecordsUrl

nextRecordsUrl?: string | undefined;

property records

records: T[];

property totalSize

totalSize: number;

interface RecordAttributes

interface RecordAttributes {}

property type

type: string;

property url

url: string;

interface RecordTypeInfo

interface RecordTypeInfo {}

property available

available: boolean;

property defaultRecordTypeMapping

defaultRecordTypeMapping: boolean;

property developerName

developerName?: maybe<string> | undefined;

property master

master: boolean;

property name

name: string;

property recordTypeId

recordTypeId: string;

property urls

urls: Record<string, string>;

interface ReportInfo

interface ReportInfo {}

interface ReportInstanceAttrs

interface ReportInstanceAttrs {}

interface ReportMetadata

interface ReportMetadata {}

interface ReportResult

interface ReportResult {}

interface RequestInfo

interface RequestInfo {}

property body

body?: string | undefined;

property headers

headers?: object | undefined;

property method

method?: string | undefined;

property url

url?: string | undefined;

interface RequestParams

interface RequestParams {}

property body

body?: string | undefined;

property method

method: string;

property url

url: string;

interface ResetPasswordResult

interface ResetPasswordResult {}

property password

password: string;

interface RestApiOptions

interface RestApiOptions {}

property allOrNone

allOrNone?: boolean | undefined;

property allowRecursive

allowRecursive?: boolean | undefined;

property headers

headers?: { [x: string]: string } | undefined;

interface RetrieveMessage

interface RetrieveMessage {}

property fileName

fileName: string;

property problem

problem: string;

interface RetrieveRequest

interface RetrieveRequest {}

property apiVersion

apiVersion?: string | undefined;

property packageNames

packageNames?: string[] | undefined;

property singlePackage

singlePackage?: boolean | undefined;

property specificFiles

specificFiles?: string[] | undefined;

property unpackaged

unpackaged?: Package | undefined;

interface RetrieveResult

interface RetrieveResult {}

property fileProperties

fileProperties: FileProperties[];

property id

id: string;

property messages

messages: RetrieveMessage[];

property zipFile

zipFile: string;

interface SaveError

interface SaveError {}

property fields

fields: string | string[];

property message

message: string;

property statusCode

statusCode: string;

interface SaveResult

interface SaveResult {}

property errors

errors?: SaveError | SaveError[] | undefined;

property fullName

fullName: string;

property success

success: boolean;

interface ScopeInfo

interface ScopeInfo {}

property label

label: string;

property name

name: string;

interface SearchResult

interface SearchResult<T> {}

property searchRecords

searchRecords: Array<Record<T>>;

interface ServerTimestampResult

interface ServerTimestampResult {}

property timestamp

timestamp: string;

interface SoapDeleteResult

interface SoapDeleteResult {}

property errors

errors: Object[];

property id

id: string;

property success

success: boolean;

interface SoapSaveResult

interface SoapSaveResult {}

property errors

errors: Object[];

property id

id: string;

property success

success: boolean;

interface SoapUpsertResult

interface SoapUpsertResult {}

property created

created: boolean;

property errors

errors: Object[];

property id

id: string;

property success

success: boolean;

interface StreamingMessage

interface StreamingMessage {}

property event

event: {
    type: string;
    createdDate: string;
    replayId?: number | undefined;
};

property sobject

sobject: Record;

interface SuccessResult

interface SuccessResult {}

property id

id: SalesforceId;

property success

success: true;

interface TokenResponse

interface TokenResponse {}

property access_token

access_token: string;

property refresh_token

refresh_token: string;

interface UpdatedRecordsInfo

interface UpdatedRecordsInfo {}

property ids

ids: string[];

property latestDateCovered

latestDateCovered: string;

interface UpdateMetadataInfo

interface UpdateMetadataInfo {}

property currentName

currentName: string;

property metadata

metadata: MetadataInfo;

interface UpsertResult

interface UpsertResult {}

property created

created: boolean;

property fullName

fullName: string;

property success

success: boolean;

interface UserInfo

interface UserInfo {}

property id

id: string;

property organizationId

organizationId: string;

property url

url: string;

interface UserInfoResult

interface UserInfoResult {}

property accessibilityMode

accessibilityMode: boolean;

property currencySymbol

currencySymbol: string;

property organizationId

organizationId: string;

property organizationMultiCurrency

organizationMultiCurrency: boolean;

property organizationName

organizationName: string;

property orgAttachmentFileSizeLimit

orgAttachmentFileSizeLimit: number;

property orgDefaultCurrencyIsoCode

orgDefaultCurrencyIsoCode: string;

property orgDisallowHtmlAttachments

orgDisallowHtmlAttachments: string;

property orgHasPersonAccounts

orgHasPersonAccounts: boolean;

property profileId

profileId: string;

property roleId

roleId: string;

property sessionSecondsValid

sessionSecondsValid: number;

property userDefaultCurrencyIsoCode

userDefaultCurrencyIsoCode: string;

property userEmail

userEmail: string;

property userFullName

userFullName: string;

property userId

userId: string;

property userLanguage

userLanguage: string;

property userLocale

userLocale: string;

property userName

userName: string;

property userTimeZone

userTimeZone: string;

property userType

userType: string;

property userUiSkin

userUiSkin: string;

Enums

enum Date

enum Date {
    YESTERDAY,
    TODAY,
    TOMORROW,
    LAST_WEEK,
    THIS_WEEK,
    NEXT_WEEK,
    LAST_MONTH,
    THIS_MONTH,
    NEXT_MONTH,
    LAST_90_DAYS,
    NEXT_90_DAYS,
    LAST_N_DAYS,
    NEXT_N_DAYS,
    NEXT_N_WEEKS,
    LAST_N_WEEKS,
    NEXT_N_MONTHS,
    LAST_N_MONTHS,
    THIS_QUARTER,
    LAST_QUARTER,
    NEXT_QUARTER,
    NEXT_N_QUARTERS,
    LAST_N_QUARTERS,
    THIS_YEAR,
    LAST_YEAR,
    NEXT_YEAR,
    NEXT_N_YEARS,
    LAST_N_YEARS,
    THIS_FISCAL_QUARTER,
    LAST_FISCAL_QUARTER,
    NEXT_FISCAL_QUARTER,
    NEXT_N_FISCAL_QUARTERS,
    LAST_N_FISCAL_QUARTERS,
    THIS_FISCAL_YEAR,
    LAST_FISCAL_YEAR,
    NEXT_FISCAL_YEAR,
    NEXT_N_FISCAL_YEARS,
    LAST_N_FISCAL_YEARS,
}

member LAST_90_DAYS

LAST_90_DAYS

member LAST_FISCAL_QUARTER

LAST_FISCAL_QUARTER

member LAST_FISCAL_YEAR

LAST_FISCAL_YEAR

member LAST_MONTH

LAST_MONTH

member LAST_N_DAYS

LAST_N_DAYS

member LAST_N_FISCAL_QUARTERS

LAST_N_FISCAL_QUARTERS

member LAST_N_FISCAL_YEARS

LAST_N_FISCAL_YEARS

member LAST_N_MONTHS

LAST_N_MONTHS

member LAST_N_QUARTERS

LAST_N_QUARTERS

member LAST_N_WEEKS

LAST_N_WEEKS

member LAST_N_YEARS

LAST_N_YEARS

member LAST_QUARTER

LAST_QUARTER

member LAST_WEEK

LAST_WEEK

member LAST_YEAR

LAST_YEAR

member NEXT_90_DAYS

NEXT_90_DAYS

member NEXT_FISCAL_QUARTER

NEXT_FISCAL_QUARTER

member NEXT_FISCAL_YEAR

NEXT_FISCAL_YEAR

member NEXT_MONTH

NEXT_MONTH

member NEXT_N_DAYS

NEXT_N_DAYS

member NEXT_N_FISCAL_QUARTERS

NEXT_N_FISCAL_QUARTERS

member NEXT_N_FISCAL_YEARS

NEXT_N_FISCAL_YEARS

member NEXT_N_MONTHS

NEXT_N_MONTHS

member NEXT_N_QUARTERS

NEXT_N_QUARTERS

member NEXT_N_WEEKS

NEXT_N_WEEKS

member NEXT_N_YEARS

NEXT_N_YEARS

member NEXT_QUARTER

NEXT_QUARTER

member NEXT_WEEK

NEXT_WEEK

member NEXT_YEAR

NEXT_YEAR

member THIS_FISCAL_QUARTER

THIS_FISCAL_QUARTER

member THIS_FISCAL_YEAR

THIS_FISCAL_YEAR

member THIS_MONTH

THIS_MONTH

member THIS_QUARTER

THIS_QUARTER

member THIS_WEEK

THIS_WEEK

member THIS_YEAR

THIS_YEAR

member TODAY

TODAY

member TOMORROW

TOMORROW

member YESTERDAY

YESTERDAY

Type Aliases

type BulkLoadOperation

type BulkLoadOperation = 'insert' | 'update' | 'upsert' | 'delete' | 'hardDelete';

type Callback

type Callback<T> = (err: Error | null, result: T) => void;

type ConnectionEvent

type ConnectionEvent = 'refresh';

type ExtraTypeInfo

type ExtraTypeInfo =
    | 'imageurl'
    | 'personname'
    | 'plaintextarea'
    | 'richtextarea'
    | 'switchablepersonname'
    | 'externallookup'
    | 'indirectlookup';

type FieldType

type FieldType =
    | 'string'
    | 'boolean'
    | 'int'
    | 'double'
    | 'date'
    | 'datetime'
    | 'base64'
    | 'id'
    | 'reference'
    | 'currency'
    | 'textarea'
    | 'percent'
    | 'phone'
    | 'url'
    | 'email'
    | 'combobox'
    | 'picklist'
    | 'multipicklist'
    | 'anyType'
    | 'location'
    // the following are not found in official documentation, but still occur when describing an sobject
    | 'time'
    | 'encryptedstring'
    | 'address'
    | 'complexvalue';

type maybe

type maybe<T> = T | null | undefined;

type Record

type Record<T = any> = {
    Id?: SalesforceId | undefined;
    attributes?: RecordAttributes | undefined;
} & T;

type RecordResult

type RecordResult = SuccessResult | ErrorResult;

type SalesforceId

type SalesforceId = string;

type SerializeOptions

type SerializeOptions = CSVStreamConverterOptions;

type SOAPType

type SOAPType =
    | 'tns:ID'
    | 'xsd:anyType'
    | 'xsd:base64Binary'
    | 'xsd:boolean'
    | 'xsd:date'
    | 'xsd:dateTime'
    | 'xsd:double'
    | 'xsd:int'
    | 'xsd:string'
    // the following are not found in official documentation, but still occur when describing an sobject
    | 'xsd:time'
    | 'urn:address'
    | 'urn:JunctionIdListNames'
    | 'urn:location'
    | 'urn:RecordTypesSupported'
    | 'urn:RelationshipReferenceTo'
    | 'urn:SearchLayoutButtonsDisplayed'
    | 'urn:SearchLayoutFieldsDisplayed';

Namespaces

namespace StreamingExtension

namespace StreamingExtension {}

class AuthFailure

class AuthFailure {}

constructor

constructor(failureCallback: () => any);

class Replay

class Replay {}

constructor

constructor(channel: string, replayId: number);

Dependencies (1)

@types/node

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/jsforce.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/jsforce)

HTML

<a href="https://www.jsdocs.io/package/@types/jsforce"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 9976 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/jsforce

Install

Overview

Index

Classes

Interfaces

Enums

Type Aliases

Namespaces

Classes

class Analytics

method dashboard

method dashboards

method report

method reports

class Apex

method del

method delete

method get

method patch

method post

method put

class AsyncResultLocator

method check

method complete

method finally

method poll

method then

class BaseConnection

property describe$

property describeGlobal$

method batchDescribe

method create

method del

method delete

method describe

method describeGlobal

method destroy

method insert

method query

method queryMore

method recent

method request

method retrieve

method search

method sobject

method update

method upsert

class Batch

method check

method execute

method poll

method result

method retrieve

method then

method thenAll

class Bulk

property pollInterval

property pollTimeout

method createJob

method job

method load

method query

class Cache

method clear

Parameter key

method get

Parameter key

class CacheEntry

method clear

method get

method set

class Channel

class Chatter

method batch

method request

method resource

class Connection

property accessToken

property analytics