@cerios/salesforce-sobjectly 0.0.0-stage → 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,2451 @@
+import { A as TransportRequest, C as SalesforceErrorCode, D as HttpMethod, E as AuthProvider, O as HttpTransport, S as KnownSalesforceErrorCode, T as AuthContext, _ as SalesforceGeolocation, a as FieldDescribe, b as UpsertResult, c as RecordTypeInfo, d as DeleteResult, f as GenericRecord, g as SalesforceAddress, h as RestError, i as DescribeSObjectResult, j as TransportResponse, k as StreamingTransportResponse, l as SObjectBasicInfo, m as RecordAttributes, n as DescribeGlobalResult, o as FieldType, p as QueryResponse, r as DescribeGlobalSObject, s as PicklistEntry, t as ChildRelationship, u as ApiVersion, v as SaveError, w as AccessToken, x as WithAttributes, y as SaveResult } from "./describe-Dj3J8o-x.mjs";
+//#region src/http/connection.d.ts
+type QueryParamValue = string | number | boolean | Date | null | undefined | readonly (string | number | boolean)[];
+type ResponseType = "auto" | "json" | "text" | "binary";
+interface RestRequest {
+  /** Defaults to `GET`. */
+  method?: HttpMethod;
+  /**
+   * - `"/limits"` or `"limits"`: relative to `/services/data/{apiVersion}`.
+   * - `"/services/apexrest/..."`: any path under `/services/` is used as-is on the instance.
+   * - `"https://..."`: absolute URLs must be on the instance origin or in `allowedOrigins`.
+   */
+  path: string;
+  /** Query string parameters. Arrays are joined with commas; `undefined`/`null` are skipped. */
+  query?: Record<string, QueryParamValue>;
+  /** Objects are sent as JSON. Strings, `Uint8Array` and `URLSearchParams` are sent as-is. */
+  body?: unknown;
+  headers?: Record<string, string>;
+  /** How to read the response body. `auto` (default) goes by `Content-Type`. */
+  responseType?: ResponseType;
+  signal?: AbortSignal;
+  /** Overrides the client timeout for this request. */
+  timeoutMs?: number;
+  /** Allow retries (see `RetryOptions`) for this request even when the method is not idempotent. */
+  retry?: boolean;
+}
+interface RestResponse<T> {
+  status: number;
+  headers: Headers;
+  data: T;
+}
+interface RetryOptions {
+  /** How many times to retry. Defaults to 2. */
+  retries?: number;
+  /** Statuses that trigger a retry. Defaults to 429, 502, 503 and 504. */
+  statusCodes?: number[];
+  /** Methods that are retried automatically. Defaults to `GET` and `HEAD`; others need `retry: true` per request. */
+  methods?: HttpMethod[];
+  /** Backoff base delay. Defaults to 500 ms. `Retry-After` takes precedence. */
+  baseDelayMs?: number;
+  /** Maximum delay between attempts. Defaults to 30 s. */
+  maxDelayMs?: number;
+  /**
+   * Salesforce error codes that trigger a retry for **any** method, e.g. `["UNABLE_TO_LOCK_ROW"]`.
+   * Salesforce rolls the failed request back, so retrying is safe even for mutations.
+   */
+  errorCodes?: SalesforceErrorCode[];
+}
+interface RequestEvent {
+  method: HttpMethod;
+  url: string;
+  /** Request headers with `Authorization` redacted. */
+  headers: Record<string, string>;
+  attempt: number;
+}
+interface ResponseEvent extends RequestEvent {
+  status: number;
+  durationMs: number;
+  /** Response headers without `set-cookie`. */
+  responseHeaders: Record<string, string>;
+}
+/** Observability hooks, e.g. for logging in test reports. Tokens are never passed to hooks. */
+interface RequestHooks {
+  onRequest?(event: RequestEvent): void;
+  onResponse?(event: ResponseEvent): void;
+}
+interface ApiUsage {
+  used: number;
+  max: number;
+}
+interface ConnectionOptions {
+  auth: AuthProvider;
+  transport: HttpTransport;
+  /** The REST API version, e.g. `"v66.0"`. Required. */
+  apiVersion: ApiVersion;
+  /** Per-request timeout in milliseconds. Defaults to 120 000. Use `0` to disable. */
+  timeoutMs?: number;
+  /** Opt-in retries on 429/5xx for idempotent requests. Disabled by default. */
+  retry?: RetryOptions | boolean;
+  /** Extra origins (besides the instance URL) that absolute URLs may point to. */
+  allowedOrigins?: string[];
+  /** Headers sent with every request, e.g. `{ "Sforce-Call-Options": "client=my-app" }`. */
+  headers?: Record<string, string>;
+  hooks?: RequestHooks;
+}
+/** Low-level request executor: auth, URL resolution, encoding, timeouts, retries and errors. */
+export declare class SalesforceConnection {
+  readonly apiVersion: ApiVersion;
+  private readonly _auth;
+  private readonly _transport;
+  private readonly _timeoutMs;
+  private readonly _retry;
+  private readonly _allowedOrigins;
+  private readonly _headers;
+  private readonly _hooks;
+  private _apiUsage;
+  constructor(options: ConnectionOptions);
+  /** API usage as reported by the last response's `Sforce-Limit-Info` header. */
+  get apiUsage(): ApiUsage | undefined;
+  get transport(): HttpTransport;
+  /** Returns the instance URL of the current token (authenticating if needed). */
+  instanceUrl(signal?: AbortSignal): Promise<string>;
+  /** Sends a request and returns the parsed body. Throws `SalesforceError` for non-2xx responses. */
+  request<T>(request: RestRequest): Promise<T>;
+  /** Sends a request and returns status, headers and the parsed body. */
+  send<T>(request: RestRequest): Promise<RestResponse<T>>;
+  /** Gets a token, bounded by the caller's signal and the request timeout. */
+  private getToken;
+  private reauthenticate;
+  /** Resolves a request path against the instance URL, enforcing the origin allowlist. */
+  resolveUrl(path: string, instanceUrl: string, query?: Record<string, QueryParamValue>): URL;
+  private sendOnce;
+  private prepare;
+  private afterResponse;
+  private toResult;
+  private errorFor;
+  /**
+   * Sends a GET request and returns the body as a stream of chunks, when the transport supports
+   * streaming (`fetchTransport` does). Returns `undefined` otherwise, so callers can fall back to
+   * `send`. Non-2xx responses throw `SalesforceError`; the request is re-authenticated once on 401.
+   */
+  stream(request: RestRequest): Promise<StreamingTransportResponse | undefined>;
+  /**
+   * Opens a streamed response. The timeout only covers waiting for the response headers, so a
+   * consumer that reads a large body slowly is not cut off.
+   */
+  private openStream;
+  private shouldRetry;
+  /**
+   * Network failures and per-attempt timeouts (the transport threw) are retried for idempotent
+   * requests when retries are enabled; a caller abort never is.
+   */
+  private canRetryFailure;
+  private retryDelay;
+  private trackApiUsage;
+}
+//#endregion
+//#region src/registry.d.ts
+/** Field kinds the TypeScript type alone can't tell apart. */
+type FieldKindName = "date" | "datetime" | "time" | "multipicklist";
+/**
+ * The shape of one entry in a generated `SObjectRegistry`:
+ * - `read`: every field as returned by Salesforce;
+ * - `create` / `update`: the fields a client may set;
+ * - `parents`: child-to-parent relationship name -> parent sObject name (e.g. `{ Account: "Account" }`);
+ * - `children`: parent-to-child relationship name -> child sObject name (e.g. `{ Cases: "Case" }`);
+ * - `externalIds` (optional): fields usable for upsert / lookup by external id;
+ * - `fieldKinds` (optional): date, datetime, time and multipicklist fields;
+ * - `recordTypes` (optional): record type DeveloperNames;
+ * - `polymorphicParents` (optional): polymorphic lookups -> possible targets (e.g. `{ Owner: "Group" | "User" }`).
+ */
+interface SObjectRegistryEntry {
+  read: object;
+  create: object;
+  update: object;
+  parents: object;
+  children: object;
+  externalIds?: string;
+  fieldKinds?: object;
+  recordTypes?: string;
+  polymorphicParents?: object;
+}
+/**
+ * The registry used when no generated registry is supplied: any sObject name, any field.
+ * Run the `sobjectly` codegen to get a typed one.
+ */
+interface GenericRegistry {
+  [sobjectName: string]: {
+    read: GenericRecord;
+    create: GenericRecord;
+    update: GenericRecord;
+    parents: Record<string, string>;
+    children: Record<string, string>;
+    externalIds: string;
+    recordTypes: string;
+    polymorphicParents: Record<string, string>;
+  };
+}
+/** Every sObject API name in registry `R`. */
+type SObjectName<R> = keyof R & string;
+/** The full record type of sObject `K`. */
+type SObjectRecord<R, K extends SObjectName<R>> = R[K] extends {
+  read: infer T extends object;
+} ? T : GenericRecord;
+/** The create input type of sObject `K`. */
+type SObjectCreateInput<R, K extends SObjectName<R>> = R[K] extends {
+  create: infer T extends object;
+} ? T : GenericRecord;
+/** The update input type of sObject `K`. */
+type SObjectUpdateInput<R, K extends SObjectName<R>> = R[K] extends {
+  update: infer T extends object;
+} ? T : GenericRecord;
+/** Every field name of sObject `K`. */
+type SObjectFieldName<R, K extends SObjectName<R>> = keyof SObjectRecord<R, K> & string;
+/** Fields of `K` usable for upsert and lookup by external id (all fields when the registry doesn't say). */
+type ExternalIdField<R, K extends SObjectName<R>> = R[K] extends {
+  externalIds: infer E extends string;
+} ? E : SObjectFieldName<R, K>;
+/** The kind of field `F` (`"date"`, `"datetime"`, `"time"`, `"multipicklist"`), or `undefined` for any other field. */
+type FieldKind<R, K extends SObjectName<R>, F extends string> = R[K] extends {
+  fieldKinds: infer M;
+} ? F extends keyof M ? M[F] : undefined : undefined;
+/** Fields of `K` that are multi-select picklists (all fields when the registry doesn't say). */
+type MultiPicklistField<R, K extends SObjectName<R>> = R[K] extends {
+  fieldKinds: infer M;
+} ? { [F in keyof M & string]: M[F] extends "multipicklist" ? F : never; }[keyof M & string] : SObjectFieldName<R, K>;
+/** Record type DeveloperNames of `K` (any string when the registry doesn't say). */
+type RecordTypeName<R, K extends SObjectName<R>> = R[K] extends {
+  recordTypes: infer T extends string;
+} ? T : string;
+/** Child-to-parent relationship names of sObject `K` (e.g. `"Account"` on `Contact`). */
+type ParentRelationshipName<R, K extends SObjectName<R>> = R[K] extends {
+  parents: infer P;
+} ? keyof P & string : never;
+/** The sObject name a parent relationship points to. */
+type ParentSObjectName<R, K extends SObjectName<R>, Rel extends string> = R[K] extends {
+  parents: infer P;
+} ? Rel extends keyof P ? P[Rel] & SObjectName<R> : never : never;
+/** Polymorphic relationship names of sObject `K` (e.g. `"Owner"` on `Case`, `"What"` on `Task`). */
+type PolymorphicRelationshipName<R, K extends SObjectName<R>> = R[K] extends {
+  polymorphicParents: infer P;
+} ? keyof P & string : never;
+/** The possible target sObject names of a polymorphic relationship. */
+type PolymorphicTargets<R, K extends SObjectName<R>, Rel extends string> = R[K] extends {
+  polymorphicParents: infer P;
+} ? Rel extends keyof P ? P[Rel] & string : never : never;
+/** Parent-to-child relationship names of sObject `K` (e.g. `"Contacts"` on `Account`). */
+type ChildRelationshipName<R, K extends SObjectName<R>> = R[K] extends {
+  children: infer C;
+} ? keyof C & string : never;
+/** The sObject name a child relationship points to. */
+type ChildSObjectName<R, K extends SObjectName<R>, Rel extends string> = R[K] extends {
+  children: infer C;
+} ? Rel extends keyof C ? C[Rel] & SObjectName<R> : never : never;
+/** `PreviousDepth[n]` is the depth left after one more hop; depth 1 allows exactly one hop. */
+type PreviousDepth = [never, never, 1, 2, 3, 4];
+/**
+ * Child-to-parent paths from `K`, e.g. `"Account"` or `"Account.Owner"`. `Depth` caps the number
+ * of hops (default 3) to keep compile times low on large registries; Salesforce allows 5.
+ */
+type ParentPath<R, K extends SObjectName<R>, Depth extends number = 3> = [Depth] extends [never] ? never : { [Rel in ParentRelationshipName<R, K>]: Rel | `${Rel}.${ParentPath<R, ParentSObjectName<R, K, Rel>, PreviousDepth[Depth]>}`; }[ParentRelationshipName<R, K>];
+/** The sObject name at the end of a parent path. */
+type ParentPathTarget<R, K extends SObjectName<R>, P extends string> = P extends `${infer H}.${infer T}` ? ParentPathTarget<R, ParentSObjectName<R, K, H>, T> : ParentSObjectName<R, K, P>;
+//#endregion
+//#region src/types/api.d.ts
+interface ApiVersionInfo {
+  label: string;
+  url: string;
+  version: string;
+}
+interface LimitInfo {
+  Max: number;
+  Remaining: number;
+  /** Some limits nest per-app sub-limits, e.g. `DailyApiRequests["Salesforce CLI"]`. */
+  [subLimit: string]: number | {
+    Max: number;
+    Remaining: number;
+  };
+}
+/** The `/limits` response, keyed by limit name (e.g. `DailyApiRequests`, `DataStorageMB`). */
+type KnownOrgLimit = "ActiveScratchOrgs" | "ConcurrentAsyncGetReportInstances" | "ConcurrentSyncReportRuns" | "DailyAnalyticsDataflowJobExecutions" | "DailyApiRequests" | "DailyAsyncApexExecutions" | "DailyAsyncApexTests" | "DailyBulkApiBatches" | "DailyBulkV2QueryFileStorageMB" | "DailyBulkV2QueryJobs" | "DailyDeliveredPlatformEvents" | "DailyDurableGenericStreamingApiEvents" | "DailyDurableStreamingApiEvents" | "DailyGenericStreamingApiEvents" | "DailyScratchOrgs" | "DailyStandardVolumePlatformEvents" | "DailyStreamingApiEvents" | "DailyWorkflowEmails" | "DataStorageMB" | "FileStorageMB" | "HourlyAsyncReportRuns" | "HourlyDashboardRefreshes" | "HourlyDashboardResults" | "HourlyDashboardStatuses" | "HourlyLongTermIdMapping" | "HourlyPublishedPlatformEvents" | "HourlyPublishedStandardVolumePlatformEvents" | "HourlyShortTermIdMapping" | "HourlySyncReportRuns" | "HourlyTimeBasedWorkflow" | "MassEmail" | "MonthlyPlatformEventsUsageEntitlement" | "Package2VersionCreates" | "PermissionTypes" | "SingleEmail" | "StreamingApiConcurrentClients";
+/** The `/limits` response, keyed by limit name. Well-known names autocomplete; others are allowed. */
+type OrgLimits = { [Name in KnownOrgLimit]?: LimitInfo; } & Record<string, LimitInfo>;
+interface QueryPlan {
+  cardinality: number;
+  fields: string[];
+  leadingOperationType: "Index" | "Other" | "Sharing" | "TableScan";
+  notes: {
+    description: string;
+    fields: string[];
+    tableEnumOrId: string;
+  }[];
+  /** Above 1 means the query is not selective. */
+  relativeCost: number;
+  sobjectCardinality: number;
+  sobjectType: string;
+}
+interface RecordCountResult {
+  sObjects: {
+    count: number;
+    name: string;
+  }[];
+}
+interface DeletedRecordsResult {
+  deletedRecords: {
+    id: string;
+    deletedDate: string;
+  }[];
+  earliestDateAvailable: string;
+  latestDateCovered: string;
+}
+interface UpdatedRecordsResult {
+  ids: string[];
+  latestDateCovered: string;
+}
+interface SearchResult<T = GenericRecord> {
+  searchRecords: WithAttributes<T>[];
+  metadata?: {
+    entityMetadata: {
+      entityName: string;
+      fieldMetadata: {
+        name: string;
+        label: string;
+      }[];
+    }[];
+  };
+}
+interface ParameterizedSearchSObject {
+  name: string;
+  fields?: string[];
+  limit?: number;
+  where?: string;
+  orderBy?: string;
+}
+interface ParameterizedSearchRequest {
+  q: string;
+  fields?: string[];
+  sobjects?: ParameterizedSearchSObject[];
+  in?: "ALL" | "NAME" | "EMAIL" | "PHONE" | "SIDEBAR";
+  overallLimit?: number;
+  defaultLimit?: number;
+  offset?: number;
+  division?: string;
+  dataCategories?: {
+    groupName: string;
+    operator: string;
+    categories: string[];
+  }[];
+  networkIds?: string[];
+  metadata?: "LABELS";
+  snippet?: string;
+  spellCorrection?: boolean;
+}
+interface SearchSuggestionsResult<T = GenericRecord> {
+  autoSuggestResults: WithAttributes<T>[];
+  hasMoreResults: boolean;
+}
+type CompositeMethod = "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+interface CompositeSubrequest {
+  method: CompositeMethod;
+  /** Must start with `/services/data/vXX.X/`. */
+  url: string;
+  referenceId: string;
+  body?: unknown;
+  httpHeaders?: Record<string, string>;
+}
+interface CompositeSubrequestResult<T = unknown> {
+  body: T | RestError[] | null;
+  httpHeaders: Record<string, string>;
+  httpStatusCode: number;
+  referenceId: string;
+}
+interface CompositeBatchSubrequest {
+  method: CompositeMethod;
+  /** Relative to the API version, e.g. `"sobjects/Account/001..."`. */
+  url: string;
+  richInput?: unknown;
+  binaryPartName?: string;
+  binaryPartNameAlias?: string;
+}
+interface CompositeBatchResult {
+  hasErrors: boolean;
+  results: {
+    statusCode: number;
+    result: unknown;
+  }[];
+}
+interface TreeSaveResult {
+  hasErrors: boolean;
+  results: {
+    referenceId: string;
+    id?: string;
+    errors?: SaveError[];
+  }[];
+}
+interface ActionSummary {
+  label: string;
+  name: string;
+  type: string;
+  url?: string;
+}
+interface ActionParameterDescribe {
+  name: string;
+  label: string;
+  type: string;
+  required: boolean;
+  description: string | null;
+  maxOccurs: number;
+  sobjectType: string | null;
+  picklistValues: unknown[] | null;
+  [key: string]: unknown;
+}
+interface ActionDescribe {
+  name: string;
+  label: string;
+  type: string;
+  description: string | null;
+  category?: string;
+  inputs: ActionParameterDescribe[];
+  outputs: ActionParameterDescribe[];
+  [key: string]: unknown;
+}
+interface InvocableActionResult<TOutput = GenericRecord> {
+  actionName: string;
+  errors: SaveError[] | null;
+  isSuccess: boolean;
+  outputValues: TOutput | null;
+  sortOrder?: number;
+  version?: number;
+  invocationId?: string | null;
+}
+interface ExecuteAnonymousResult {
+  line: number;
+  column: number;
+  compiled: boolean;
+  success: boolean;
+  compileProblem: string | null;
+  exceptionMessage: string | null;
+  exceptionStackTrace: string | null;
+}
+interface RunTestsRequest {
+  /** Comma-separated class ids, or use `tests`. */
+  classids?: string;
+  suiteids?: string;
+  maxFailedTests?: number;
+  testLevel?: "RunSpecifiedTests" | "RunLocalTests" | "RunAllTestsInOrg";
+  skipCodeCoverage?: boolean;
+  tests?: {
+    classId?: string;
+    className?: string;
+    testMethods?: string[];
+  }[];
+}
+type BulkIngestOperation = "insert" | "update" | "upsert" | "delete" | "hardDelete";
+type BulkQueryOperation = "query" | "queryAll";
+type BulkJobState = "Open" | "UploadComplete" | "InProgress" | "JobComplete" | "Failed" | "Aborted";
+type BulkColumnDelimiter = "COMMA" | "TAB" | "PIPE" | "SEMICOLON" | "CARET" | "BACKQUOTE";
+type BulkLineEnding = "LF" | "CRLF";
+interface BulkJobInfo {
+  id: string;
+  operation: BulkIngestOperation | BulkQueryOperation;
+  object: string;
+  createdById: string;
+  createdDate: string;
+  systemModstamp: string;
+  state: BulkJobState;
+  concurrencyMode: string;
+  contentType: "CSV";
+  /** A number, e.g. `66.0`. */
+  apiVersion: number;
+  jobType?: string;
+  lineEnding: BulkLineEnding;
+  columnDelimiter: BulkColumnDelimiter;
+  contentUrl?: string;
+  externalIdFieldName?: string;
+  assignmentRuleId?: string;
+  numberRecordsProcessed?: number;
+  numberRecordsFailed?: number;
+  retries?: number;
+  totalProcessingTime?: number;
+  apiActiveProcessingTime?: number;
+  apexProcessingTime?: number;
+  errorMessage?: string;
+  isPkChunkingSupported?: boolean;
+  [key: string]: unknown;
+}
+interface OAuthTokenResponse {
+  access_token: string;
+  instance_url: string;
+  id?: string;
+  token_type?: string;
+  /** Epoch milliseconds, as a string. */
+  issued_at?: string;
+  signature?: string;
+  scope?: string;
+  refresh_token?: string;
+  id_token?: string;
+  api_instance_url?: string;
+}
+//#endregion
+//#region src/resources/actions.d.ts
+interface InvokeOptions {
+  /** Throw a `SalesforceSaveError` when any input reported `isSuccess: false`. Defaults to `true`. */
+  throwOnError?: boolean;
+  signal?: AbortSignal;
+}
+/** The custom action types of `/actions/custom/{type}`. */
+type CustomActionType = "flow" | "apex" | "quickAction" | "emailAlert" | "submit" | "externalService" | (string & {});
+/** Invocable actions (`/actions/standard`, `/actions/custom`), including autolaunched Flows and `@InvocableMethod` Apex. */
+export declare class ActionsApi {
+  private readonly _connection;
+  constructor(_connection: SalesforceConnection);
+  listStandard(options?: {
+    signal?: AbortSignal;
+  }): Promise<ActionSummary[]>;
+  listCustom(type: CustomActionType, options?: {
+    signal?: AbortSignal;
+  }): Promise<ActionSummary[]>;
+  describeStandard(name: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<ActionDescribe>;
+  describeCustom(type: CustomActionType, name: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<ActionDescribe>;
+  /** Invokes a standard action, e.g. `"emailSimple"` or `"chatterPost"`. One result per input. */
+  invokeStandard<TInput extends object = GenericRecord, TOutput = GenericRecord>(name: string, inputs: readonly TInput[], options?: InvokeOptions): Promise<InvocableActionResult<TOutput>[]>;
+  /** Invokes a custom action of `type`. One result per input. */
+  invokeCustom<TInput extends object = GenericRecord, TOutput = GenericRecord>(type: CustomActionType, name: string, inputs: readonly TInput[], options?: InvokeOptions): Promise<InvocableActionResult<TOutput>[]>;
+  /**
+   * Runs an autolaunched Flow by API name. Input keys are the Flow's input variable names;
+   * `outputValues` holds its output variables plus `Flow__InterviewStatus`.
+   */
+  invokeFlow<TInput extends object = GenericRecord, TOutput = GenericRecord>(apiName: string, inputs: readonly TInput[], options?: InvokeOptions): Promise<InvocableActionResult<TOutput>[]>;
+  /** Invokes an `@InvocableMethod` of an Apex class (`Namespace__ClassName` for managed packages). */
+  invokeApex<TInput extends object = GenericRecord, TOutput = GenericRecord>(className: string, inputs: readonly TInput[], options?: InvokeOptions): Promise<InvocableActionResult<TOutput>[]>;
+  private invoke;
+}
+//#endregion
+//#region src/types/platform.d.ts
+interface ApprovalProcessInfo {
+  description: string | null;
+  id: string;
+  name: string;
+  object: string;
+  sortOrder: number;
+}
+interface ApprovalResult {
+  actorIds: string[];
+  entityId: string;
+  errors: SaveError[] | null;
+  instanceId: string;
+  instanceStatus: "Approved" | "Rejected" | "Removed" | "Pending" | (string & {});
+  /** Ids of the new work items (normalised from `newWorkitemIds` / `newWorkItemIds`). */
+  newWorkitemIds: string[];
+  success: boolean;
+}
+interface PendingApprovalWorkItem {
+  /** The ProcessInstanceWorkitem id (`04i...`), used to approve or reject. */
+  id: string;
+  actorId: string;
+  processInstanceId: string;
+  targetObjectId: string;
+}
+interface QuickActionSummary {
+  actionEnumOrId: string;
+  label: string;
+  name: string;
+  type: string;
+  urls?: Record<string, string>;
+}
+interface QuickActionDescribe {
+  name: string;
+  label: string;
+  type: string;
+  targetSobjectType: string | null;
+  targetParentField: string | null;
+  targetRecordTypeId: string | null;
+  contextSobjectType: string | null;
+  defaultValues: {
+    field: string;
+    defaultValue: unknown;
+  }[] | null;
+  layout: unknown;
+  [key: string]: unknown;
+}
+interface QuickActionResult {
+  success: boolean;
+  created: boolean;
+  id?: string;
+  ids: string[];
+  contextId?: string;
+  feedItemIds: string[] | null;
+  successMessage: string | null;
+  errors: SaveError[];
+}
+interface UiFieldInfo {
+  apiName: string;
+  label: string;
+  dataType: string;
+  required: boolean;
+  createable: boolean;
+  updateable: boolean;
+  custom: boolean;
+  calculated: boolean;
+  nameField: boolean;
+  reference: boolean;
+  referenceToInfos: {
+    apiName: string;
+    nameFields: string[];
+  }[];
+  relationshipName: string | null;
+  controllerName: string | null;
+  length: number;
+  precision: number;
+  scale: number;
+  [key: string]: unknown;
+}
+interface UiRecordTypeInfo {
+  available: boolean;
+  defaultRecordTypeMapping: boolean;
+  master: boolean;
+  name: string;
+  recordTypeId: string;
+}
+interface ObjectInfo {
+  apiName: string;
+  label: string;
+  labelPlural: string;
+  keyPrefix: string | null;
+  custom: boolean;
+  createable: boolean;
+  updateable: boolean;
+  deletable: boolean;
+  queryable: boolean;
+  nameFields: string[];
+  /** The master record type (`012000000000000AAA`) when there is no other default. */
+  defaultRecordTypeId: string | null;
+  recordTypeInfos: Record<string, UiRecordTypeInfo>;
+  dependentFields: Record<string, unknown>;
+  fields: Record<string, UiFieldInfo>;
+  childRelationships: unknown[];
+  [key: string]: unknown;
+}
+interface PicklistValue {
+  label: string;
+  value: string;
+  /** Indexes into the controlling field's `controllerValues`. */
+  validFor: number[];
+  attributes: Record<string, unknown> | null;
+}
+interface PicklistValues {
+  controllerValues: Record<string, number>;
+  defaultValue: PicklistValue | null;
+  values: PicklistValue[];
+  url: string;
+  eTag?: string;
+}
+interface UiFieldValue<T = unknown> {
+  displayValue: string | null;
+  value: T;
+}
+/** A UI API record. `fields` is typed when the record was loaded with typed field names. */
+interface UiRecord<TFields extends object = Record<string, UiFieldValue>> {
+  apiName: string;
+  id: string;
+  fields: TFields;
+  childRelationships: Record<string, unknown>;
+  lastModifiedById: string | null;
+  lastModifiedDate: string | null;
+  recordTypeId: string | null;
+  recordTypeInfo: UiRecordTypeInfo | null;
+  systemModstamp: string | null;
+  eTag?: string;
+  weakEtag?: number;
+}
+interface UiLayoutComponent {
+  apiName: string | null;
+  componentType: "Field" | "Canvas" | "CustomLink" | "EmptySpace" | "ReportChart" | "VisualforcePage" | (string & {});
+  label: string;
+}
+interface UiLayout {
+  id: string;
+  layoutType: string;
+  mode: string;
+  objectApiName: string;
+  recordTypeId: string;
+  sections: {
+    collapsible: boolean;
+    columns: number;
+    heading: string;
+    id: string;
+    rows: number;
+    useHeading: boolean;
+    layoutRows: {
+      layoutItems: {
+        editableForNew: boolean;
+        editableForUpdate: boolean;
+        label: string;
+        required: boolean;
+        layoutComponents: UiLayoutComponent[];
+      }[];
+    }[];
+  }[];
+  [key: string]: unknown;
+}
+interface ReportSummary {
+  id: string;
+  name: string;
+  url: string;
+  describeUrl: string;
+  instancesUrl: string;
+}
+interface ReportFilter {
+  column: string;
+  operator: "equals" | "notEqual" | "lessThan" | "greaterThan" | "lessOrEqual" | "greaterOrEqual" | "contains" | "notContain" | "startsWith" | "includes" | "excludes" | "within" | (string & {});
+  value: string;
+  isRunPageEditable?: boolean;
+}
+interface ReportMetadata {
+  id: string;
+  name: string;
+  developerName: string;
+  reportFormat: "TABULAR" | "SUMMARY" | "MATRIX" | "MULTI_BLOCK";
+  detailColumns: string[];
+  aggregates: string[];
+  reportFilters: ReportFilter[];
+  reportBooleanFilter: string | null;
+  groupingsDown: {
+    name: string;
+    dateGranularity: string;
+    sortOrder: string;
+  }[];
+  groupingsAcross: {
+    name: string;
+    dateGranularity: string;
+    sortOrder: string;
+  }[];
+  hasDetailRows: boolean;
+  [key: string]: unknown;
+}
+interface ReportDataCell {
+  label: string;
+  value: unknown;
+}
+interface ReportFact {
+  aggregates: ReportDataCell[];
+  rows?: {
+    dataCells: ReportDataCell[];
+  }[];
+}
+interface ReportExtendedMetadata {
+  aggregateColumnInfo: Record<string, {
+    label: string;
+    dataType: string;
+  }>;
+  detailColumnInfo: Record<string, {
+    label: string;
+    dataType: string;
+  }>;
+  groupingColumnInfo: Record<string, {
+    label: string;
+    dataType: string;
+    groupingLevel: number;
+  }>;
+}
+interface ReportResult {
+  attributes: {
+    describeUrl: string;
+    instancesUrl: string;
+    reportId: string;
+    reportName: string;
+    type: string;
+  };
+  allData: boolean;
+  hasDetailRows: boolean;
+  /** Keys like `"T!T"` (grand total), `"0!T"` (first grouping) or `"0_1!0"` (matrix cell). */
+  factMap: Record<string, ReportFact>;
+  groupingsDown: {
+    groupings: unknown[];
+  };
+  groupingsAcross: {
+    groupings: unknown[];
+  };
+  reportMetadata: ReportMetadata;
+  reportExtendedMetadata: ReportExtendedMetadata;
+  [key: string]: unknown;
+}
+interface ReportDescribe {
+  reportMetadata: ReportMetadata;
+  reportExtendedMetadata: ReportExtendedMetadata;
+  reportTypeMetadata: Record<string, unknown>;
+}
+interface ReportInstance {
+  id: string;
+  status: "New" | "Running" | "Success" | "Error";
+  url: string;
+  ownerId: string;
+  hasDetailRows: boolean;
+  queryable: boolean;
+  requestDate: string;
+  completionDate: string | null;
+}
+//#endregion
+//#region src/resources/query.d.ts
+declare const queryCursorRecord: unique symbol;
+/** A `nextRecordsUrl` that remembers the record type of the query it belongs to. */
+type QueryCursor<TRecord> = string & {
+  readonly [queryCursorRecord]: TRecord;
+};
+/** One page of query results. Pass `nextRecordsUrl` to `queryMore` to fetch the next page. */
+interface QueryResult<TRecord> {
+  records: TRecord[];
+  totalSize: number;
+  done: boolean;
+  nextRecordsUrl?: QueryCursor<TRecord>;
+}
+interface QueryOptions {
+  /** Use `/queryAll`, which also returns deleted and archived records. */
+  includeDeleted?: boolean;
+  /** Preferred page size (200–2000), sent as `Sforce-Query-Options: batchSize=n`. Not guaranteed. */
+  batchSize?: number;
+  signal?: AbortSignal;
+}
+/** Runs SOQL against `/query`/`/queryAll` (or the Tooling API equivalents) and follows pages. */
+export declare class QueryApi {
+  private readonly _connection;
+  private readonly _basePath;
+  constructor(_connection: SalesforceConnection, _basePath?: "" | "/tooling");
+  /** Returns the first page of results. */
+  page<TRecord>(soql: string, options?: QueryOptions): Promise<QueryResult<TRecord>>;
+  /** Sends a query that is too long for a URL as a composite subrequest (still one API call). */
+  private viaComposite;
+  /** Fetches the page a cursor points to. */
+  more<TRecord>(cursor: QueryCursor<TRecord>, options?: Pick<QueryOptions, "batchSize" | "signal">): Promise<QueryResult<TRecord>>;
+  /** Yields every record, fetching further pages on demand. */
+  iterate<TRecord>(soql: string, options?: QueryOptions): AsyncGenerator<TRecord, void, undefined>;
+  /** Fetches every page and returns all records. */
+  collect<TRecord>(soql: string, options?: QueryOptions): Promise<TRecord[]>;
+}
+//#endregion
+//#region src/resources/approvals.d.ts
+interface SubmitOptions {
+  comments?: string;
+  /** Required when the process step lets the submitter choose the approver. */
+  nextApproverIds?: string[];
+  /** The approval process to use (API name or id); otherwise the first matching process runs. */
+  processDefinitionNameOrId?: string;
+  skipEntryCriteria?: boolean;
+  /** Submit on behalf of this user id. */
+  submitterId?: string;
+  /** Throw a `SalesforceSaveError` when Salesforce reports `success: false`. Defaults to `true`. */
+  throwOnError?: boolean;
+  signal?: AbortSignal;
+}
+interface DecisionOptions {
+  comments?: string;
+  nextApproverIds?: string[];
+  /** Throw a `SalesforceSaveError` when Salesforce reports `success: false`. Defaults to `true`. */
+  throwOnError?: boolean;
+  signal?: AbortSignal;
+}
+/** Approval processes (`/process/approvals`): submit records, approve and reject pending steps. */
+export declare class ApprovalsApi {
+  private readonly _connection;
+  private readonly _queries;
+  constructor(_connection: SalesforceConnection, _queries: QueryApi);
+  /** Lists the approval processes per sObject. */
+  list(options?: {
+    signal?: AbortSignal;
+  }): Promise<Record<string, ApprovalProcessInfo[]>>;
+  /** Submits a record for approval. */
+  submit(recordId: string, options?: SubmitOptions): Promise<ApprovalResult>;
+  /**
+   * Approves a pending step. Pass the work item id (`04i...`), or the record id to approve its
+   * single pending work item.
+   */
+  approve(recordOrWorkitemId: string, options?: DecisionOptions): Promise<ApprovalResult>;
+  /** Rejects a pending step. Accepts a work item id or a record id, like `approve`. */
+  reject(recordOrWorkitemId: string, options?: DecisionOptions): Promise<ApprovalResult>;
+  /** The pending work items of a record (visible to the current user). */
+  pending(recordId: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<PendingApprovalWorkItem[]>;
+  private resolveWorkitem;
+  private process;
+  /**
+   * Sends one approval request. Failures such as `NO_APPLICABLE_PROCESS` or `ALREADY_IN_PROCESS`
+   * come back as HTTP 400 with an error array; they become an unsuccessful result.
+   */
+  private send;
+}
+//#endregion
+//#region src/soql/escape.d.ts
+declare const soqlLiteralBrand: unique symbol;
+/** A value that is inserted into SOQL verbatim. Create one with {@link soqlLiteral}. */
+interface SoqlLiteral {
+  readonly [soqlLiteralBrand]: true;
+  readonly sql: string;
+}
+/** A value accepted by the typed `where` helpers. */
+type SoqlValue = string | number | boolean | null | Date | SoqlLiteral;
+/**
+ * Marks `sql` as a raw SOQL literal, e.g. a date literal such as `soqlLiteral("LAST_N_DAYS:30")`
+ * or `soqlLiteral("TODAY")`. Never pass untrusted input.
+ */
+export declare function soqlLiteral(sql: string): SoqlLiteral;
+/**
+ * Formats a value as a SOQL literal. Strings are quoted with backslashes, quotes and control
+ * characters escaped, which prevents SOQL injection for values from user or external input.
+ * In `LIKE` patterns `%` and `_` stay wildcards; use {@link soqlLike} to match them literally.
+ *
+ * A `Date` becomes a DateTime literal (`yyyy-MM-ddTHH:mm:ssZ`, UTC), which only works against
+ * DateTime fields. Use {@link soqlDate} for Date-only fields (e.g. `Birthdate`).
+ */
+export declare function soqlEscape(value: SoqlValue): string;
+/**
+ * Formats a `Date` as a Date-only literal (`yyyy-MM-dd`), for use against Date fields. Uses the
+ * UTC date unless `local` is set, in which case the date in the local time zone is used.
+ */
+export declare function soqlEscapeDateOnly(value: Date, options?: {
+  local?: boolean;
+}): string;
+/**
+ * A Date-only literal for the typed `where` helpers, e.g. `where("Birthdate", ">", soqlDate(d))`.
+ * Accepts a `Date` or a `yyyy-MM-dd` string. A `Date` uses its UTC date; pass `{ local: true }`
+ * to use the date in the local time zone (e.g. for `new Date(2026, 0, 31)`).
+ */
+export declare function soqlDate(value: Date | string, options?: {
+  local?: boolean;
+}): SoqlLiteral;
+/** Date literals without a number, e.g. `TODAY` or `THIS_FISCAL_QUARTER`. */
+type SoqlFixedDateLiteral = "YESTERDAY" | "TODAY" | "TOMORROW" | "LAST_WEEK" | "THIS_WEEK" | "NEXT_WEEK" | "LAST_MONTH" | "THIS_MONTH" | "NEXT_MONTH" | "LAST_90_DAYS" | "NEXT_90_DAYS" | "THIS_QUARTER" | "LAST_QUARTER" | "NEXT_QUARTER" | "THIS_YEAR" | "LAST_YEAR" | "NEXT_YEAR" | "THIS_FISCAL_QUARTER" | "LAST_FISCAL_QUARTER" | "NEXT_FISCAL_QUARTER" | "THIS_FISCAL_YEAR" | "LAST_FISCAL_YEAR" | "NEXT_FISCAL_YEAR";
+/** Date literals that take a number, e.g. `LAST_N_DAYS:30`. */
+type SoqlRelativeDateLiteral = "LAST_N_DAYS" | "NEXT_N_DAYS" | "N_DAYS_AGO" | "LAST_N_WEEKS" | "NEXT_N_WEEKS" | "N_WEEKS_AGO" | "LAST_N_MONTHS" | "NEXT_N_MONTHS" | "N_MONTHS_AGO" | "LAST_N_QUARTERS" | "NEXT_N_QUARTERS" | "N_QUARTERS_AGO" | "LAST_N_YEARS" | "NEXT_N_YEARS" | "N_YEARS_AGO" | "LAST_N_FISCAL_QUARTERS" | "NEXT_N_FISCAL_QUARTERS" | "N_FISCAL_QUARTERS_AGO" | "LAST_N_FISCAL_YEARS" | "NEXT_N_FISCAL_YEARS" | "N_FISCAL_YEARS_AGO";
+/**
+ * A typed SOQL date literal for date and datetime fields:
+ * `soqlDateLiteral("TODAY")`, `soqlDateLiteral("LAST_N_DAYS", 30)`.
+ */
+export declare function soqlDateLiteral(name: SoqlFixedDateLiteral): SoqlLiteral;
+export declare function soqlDateLiteral(name: SoqlRelativeDateLiteral, n: number): SoqlLiteral;
+/**
+ * Escapes a term for a SOSL `FIND {...}` clause by backslash-escaping the reserved characters
+ * `? & | ! { } [ ] ( ) ^ ~ * : \ " ' + -`.
+ */
+export declare function soslEscape(term: string): string;
+//#endregion
+//#region src/soql/types.d.ts
+type SoqlComparisonOperator = "=" | "!=" | ">" | "<" | ">=" | "<=";
+type SoqlOperator = SoqlComparisonOperator | "LIKE";
+/** Any non-null value the builder can render. */
+type SoqlScalar = string | number | boolean | Date | SoqlLiteral;
+type NonNull<T> = Exclude<T, null | undefined>;
+/** The TypeScript type of field `F` on `K` (`unknown` for untyped registries). */
+type FieldType$1<R, K extends SObjectName<R>, F extends string> = F extends keyof SObjectRecord<R, K> ? SObjectRecord<R, K>[F] : unknown;
+type IsUnknown<T> = unknown extends T ? true : false;
+/**
+ * The non-null values `where` accepts for field `F`:
+ * - date fields: `soqlDate(date)` or a date literal (a quoted string or `Date` would be invalid SOQL);
+ * - datetime fields: a `Date` or a literal;
+ * - time fields: a literal;
+ * - number fields: a number; boolean fields: a boolean;
+ * - string and picklist fields: their value type (picklist unions stay checked).
+ */
+type SoqlFieldValue<R, K extends SObjectName<R>, F extends string> = FieldKind<R, K, F> extends "date" ? SoqlLiteral : FieldKind<R, K, F> extends "datetime" ? Date | SoqlLiteral : FieldKind<R, K, F> extends "time" ? SoqlLiteral : IsUnknown<FieldType$1<R, K, F>> extends true ? SoqlScalar : NonNull<FieldType$1<R, K, F>> extends number ? number | SoqlLiteral : NonNull<FieldType$1<R, K, F>> extends boolean ? boolean : NonNull<FieldType$1<R, K, F>> extends string ? NonNull<FieldType$1<R, K, F>> | SoqlLiteral : SoqlScalar;
+/** The operators that make sense for field `F` (`LIKE` only on text, `=`/`!=` only on booleans). */
+type SoqlOperatorFor<R, K extends SObjectName<R>, F extends string> = FieldKind<R, K, F> extends "multipicklist" ? "=" | "!=" : FieldKind<R, K, F> extends "date" | "datetime" | "time" ? SoqlComparisonOperator : IsUnknown<FieldType$1<R, K, F>> extends true ? SoqlOperator : NonNull<FieldType$1<R, K, F>> extends boolean ? "=" | "!=" : NonNull<FieldType$1<R, K, F>> extends number ? SoqlComparisonOperator : SoqlOperator;
+/**
+ * The value `where(field, operator, value)` accepts. `null` works with `!=` on any field
+ * (`Id != null`) and with `=` only on nillable fields.
+ */
+type SoqlWhereValue<R, K extends SObjectName<R>, F extends string, O extends string> = SoqlFieldValue<R, K, F> | (O extends "!=" ? null : O extends "=" ? (null extends FieldType$1<R, K, F> ? null : never) : never);
+/** The sObject at the end of a parent path, e.g. `"User"` for `"Account.Owner"` from `Contact`. */
+type PathTarget<R, K extends SObjectName<R>, P extends string> = ParentPathTarget<R, K, P> & SObjectName<R>;
+/** Nests a selection under a dotted parent path: `"Account.Owner"` -> `{ Account: { Owner: V } }`. */
+type NestPath<P extends string, V> = P extends `${infer Head}.${infer Tail}` ? { [Key in Head]: WithAttributes<NestPath<Tail, V>> | null; } : { [Key in P]: WithAttributes<V> | null; };
+/**
+ * Fields available on a polymorphic relationship without TYPEOF (the "Name" object), e.g.
+ * `Owner.Name` or `What.Type`.
+ */
+interface PolymorphicName {
+  Id: string;
+  Name: string | null;
+  Type: string;
+  Alias: string | null;
+  Email: string | null;
+  FirstName: string | null;
+  LastName: string | null;
+  IsActive: boolean;
+  Phone: string | null;
+  Title: string | null;
+  Username: string | null;
+}
+type PolymorphicNameField = Extract<keyof PolymorphicName, string>;
+/** A record whose `attributes.type` is narrowed to `T`, so unions can be discriminated. */
+type TypedRecord<T extends string, V> = V & {
+  attributes: {
+    type: T;
+    url?: string;
+  };
+};
+/** Fields selectable for `T` inside TYPEOF: its fields when `T` is in the registry, else the Name fields. */
+type TypeOfField<R, T extends string> = T extends SObjectName<R> ? SObjectFieldName<R, T> : PolymorphicNameField;
+type TypeOfPick<R, T extends string, F extends string> = T extends SObjectName<R> ? Pick<SObjectRecord<R, T>, Extract<F, keyof SObjectRecord<R, T>>> : Pick<PolymorphicName, Extract<F, PolymorphicNameField>>;
+//#endregion
+//#region src/soql/query-builder.d.ts
+type SoqlDirection = "ASC" | "DESC";
+type SoqlNullOrder = "NULLS FIRST" | "NULLS LAST";
+declare const noSelectionBrand: unique symbol;
+/** Marker for "nothing selected yet", which queries `FIELDS(ALL)` and returns the full record. */
+type NoSelection = {
+  readonly [noSelectionBrand]: true;
+};
+type SelectedRecord<R, K extends SObjectName<R>, S extends object> = S extends NoSelection ? SObjectRecord<R, K> : S;
+type ExplicitSelection<S extends object> = S extends NoSelection ? object : S;
+type NumericField<R, K extends SObjectName<R>> = string extends keyof SObjectRecord<R, K> ? string : { [P in SObjectFieldName<R, K>]: Exclude<SObjectRecord<R, K>[P], null | undefined> extends number ? P : never; }[SObjectFieldName<R, K>];
+/** The value of a parent-to-child subquery field. Salesforce returns `null` when there are no child rows. */
+type SoqlChildQueryResult<TRecord> = {
+  records: WithAttributes<TRecord>[];
+  totalSize: number;
+  done: boolean;
+  nextRecordsUrl?: string;
+};
+/** The record type a query built with `SoqlQueryBuilder<R, K, S>` returns. */
+type SoqlQueryRecord<R, K extends SObjectName<R>, S extends object> = WithAttributes<SelectedRecord<R, K, S>>;
+/**
+ * Builds a `TYPEOF` expression for a polymorphic relationship. Each `when` narrows the result to a
+ * record whose `attributes.type` is that sObject; `else` covers the remaining types with Name fields.
+ */
+export declare class TypeOfBuilder<R extends object, Remaining extends string, Result = never> {
+  private readonly _whens;
+  private readonly _types;
+  private _else;
+  /** `WHEN type THEN fields`. */
+  when<T extends Remaining, F extends TypeOfField<R, T>>(sobject: T, firstField: F, ...additionalFields: F[]): TypeOfBuilder<R, Exclude<Remaining, T>, Result | TypedRecord<T, TypeOfPick<R, T, F>>>;
+  /** `ELSE fields`: the Name fields for every type without a `when`. */
+  else<F extends PolymorphicNameField>(firstField: F, ...additionalFields: F[]): TypeOfBuilder<R, never, Result | TypedRecord<Remaining, Pick<PolymorphicName, F>>>;
+  /** @internal */
+  toSoql(relationship: string): string;
+}
+/**
+ * Narrows a record by its `attributes.type`, e.g. the union returned for a `selectTypeOf` field.
+ * TypeScript doesn't narrow on nested properties, so `record.attributes.type === "Account"` alone
+ * won't narrow; this guard does:
+ *
+ * ```ts
+ * if (isSObjectType(task.What, "Account")) task.What.Phone;
+ * ```
+ */
+export declare function isSObjectType<U extends {
+  attributes: {
+    type: string;
+  };
+}, T extends U["attributes"]["type"]>(record: U | null | undefined, type: T): record is Extract<U, {
+  attributes: {
+    type: T;
+  };
+}>;
+type TypeOfResult<Remaining extends string, Result> = Result | ([Remaining] extends [never] ? never : TypedRecord<Remaining, object>);
+/**
+ * A type-safe, fluent SOQL builder. Field names are checked against the registry, values are
+ * checked per field type, and the selected fields narrow the record type the query returns.
+ *
+ * Create one with `client.soql("Account")` or `soqlFor<SObjectRegistry>()("Account")`.
+ *
+ * - `select` for direct fields;
+ * - `selectRelated("Account.Owner", ...)` for child-to-parent paths (up to 3 hops typed);
+ * - `selectChild` for parent-to-child subqueries;
+ * - `selectPolymorphic` / `selectTypeOf` for polymorphic lookups such as `Owner` or `What`;
+ * - `selectRaw` / `whereRaw` for anything else (escape values with `soqlEscape`).
+ *
+ * Builders are **mutable**: every method changes the builder and returns it. To branch off a
+ * shared base query, `clone()` it first:
+ *
+ * ```ts
+ * const base = sf.soql("Account").select("Id");
+ * const energy = base.clone().where("Industry", "=", "Energy");
+ * const banking = base.clone().where("Industry", "=", "Banking");
+ * ```
+ */
+export declare class SoqlQueryBuilder<R extends object, K extends SObjectName<R>, S extends object = NoSelection> {
+  private readonly _fromClause;
+  private _fields;
+  private _conditions;
+  private _groupBy;
+  private _having;
+  private _orderBy;
+  private _limit;
+  private _offset;
+  private _withUserMode;
+  private _forClause;
+  private _usesTypeOf;
+  private _countAll;
+  private _usesAggregates;
+  private constructor();
+  /** Returns an independent copy, so the original can be reused as a base for other queries. */
+  clone(): SoqlQueryBuilder<R, K, S>;
+  /** Starts a query on `sobjectName`. Prefer `client.soql()` or `soqlFor<R>()`, which infer `R`. */
+  static from<R extends object, K extends SObjectName<R>>(sobjectName: K): SoqlQueryBuilder<R, K>;
+  /** The sObject (or child relationship, in a subquery) this query selects from. */
+  get sobjectName(): string;
+  /** `true` when the query contains `TYPEOF`, which Bulk API, semi-joins and GROUP BY don't support. */
+  get usesTypeOf(): boolean;
+  /** Adds fields to the select list. The result type is narrowed to the selected fields. */
+  select<F extends SObjectFieldName<R, K>>(firstField: F, ...additionalFields: F[]): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Pick<SObjectRecord<R, K>, F>>;
+  /** Escape hatch for select expressions the typed helpers can't express. The result gains an index signature. */
+  selectRaw(firstExpression: string, ...additionalExpressions: string[]): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Record<string, unknown>>;
+  /**
+   * Selects fields through a child-to-parent path, e.g. `selectRelated("Account", "Name")` or
+   * `selectRelated("Account.Owner", "Email")` from `Contact`. Each level is `| null` in the result.
+   */
+  selectRelated<P extends ParentPath<R, K>, F extends SObjectFieldName<R, PathTarget<R, K, P>>>(path: P, firstField: F, ...additionalFields: F[]): SoqlQueryBuilder<R, K, ExplicitSelection<S> & NestPath<P, Pick<SObjectRecord<R, PathTarget<R, K, P>>, F>>>;
+  /**
+   * Selects Name fields of a polymorphic lookup without TYPEOF, e.g. `selectPolymorphic("Owner", "Name")`
+   * from `Case`. `attributes.type` tells which sObject it is.
+   */
+  selectPolymorphic<Rel extends PolymorphicRelationshipName<R, K>, F extends PolymorphicNameField>(relationship: Rel, firstField: F, ...additionalFields: F[]): SoqlQueryBuilder<R, K, ExplicitSelection<S> & { [P in Rel]: TypedRecord<PolymorphicTargets<R, K, Rel>, Pick<PolymorphicName, F>> | null; }>;
+  /**
+   * Adds a `TYPEOF` expression for a polymorphic lookup. The result is a union discriminated on
+   * `attributes.type`:
+   *
+   * ```ts
+   * sf.soql("Task").select("Id").selectTypeOf("What", (t) =>
+   * 	t.when("Account", "Phone").when("Opportunity", "Amount").else("Name"),
+   * );
+   * ```
+   */
+  selectTypeOf<Rel extends PolymorphicRelationshipName<R, K>, Remaining extends string, Result>(relationship: Rel, build: (typeOf: TypeOfBuilder<R, PolymorphicTargets<R, K, Rel>>) => TypeOfBuilder<R, Remaining, Result>): SoqlQueryBuilder<R, K, ExplicitSelection<S> & { [P in Rel]: TypeOfResult<Remaining, Result> | null; }>;
+  /**
+   * Adds a parent-to-child subquery, e.g. `selectChild("Contacts", c => c.select("Id", "Email"))`
+   * from `Account` builds `(SELECT Id, Email FROM Contacts)`.
+   */
+  selectChild<Rel extends ChildRelationshipName<R, K>, ChildSelection extends object, ChildName extends ChildSObjectName<R, K, Rel> = ChildSObjectName<R, K, Rel>>(relationship: Rel, build: (sub: SoqlQueryBuilder<R, ChildName>) => SoqlQueryBuilder<R, ChildName, ChildSelection>): SoqlQueryBuilder<R, K, ExplicitSelection<S> & { [P in Rel]: SoqlChildQueryResult<SelectedRecord<R, ChildName, ChildSelection>> | null; }>;
+  /** `SELECT COUNT() FROM ...`: the count is in the result's `totalSize`; `records` is empty. */
+  count(): SoqlQueryBuilder<R, K, ExplicitSelection<S>>;
+  /** `COUNT(field) alias`. */
+  count<F extends SObjectFieldName<R, K>, A extends string>(field: F, alias: A): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Record<A, number>>;
+  countDistinct<F extends SObjectFieldName<R, K>, A extends string>(field: F, alias: A): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Record<A, number>>;
+  sum<F extends NumericField<R, K>, A extends string>(field: F, alias: A): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Record<A, number | null>>;
+  avg<F extends NumericField<R, K>, A extends string>(field: F, alias: A): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Record<A, number | null>>;
+  min<F extends SObjectFieldName<R, K>, A extends string>(field: F, alias: A): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Record<A, SObjectRecord<R, K>[F] | null>>;
+  max<F extends SObjectFieldName<R, K>, A extends string>(field: F, alias: A): SoqlQueryBuilder<R, K, ExplicitSelection<S> & Record<A, SObjectRecord<R, K>[F] | null>>;
+  /**
+   * Adds `field operator value`. The value is escaped and type-checked against the field:
+   * date fields take `soqlDate()`/`soqlDateLiteral()`, datetime fields a `Date` or literal,
+   * `LIKE` only works on text, and `null` only on nillable fields with `=`/`!=`.
+   */
+  where<F extends SObjectFieldName<R, K>, O extends SoqlOperatorFor<R, K, F>>(field: F, operator: O, value: SoqlWhereValue<R, K, F, O>): this;
+  /**
+   * Adds a raw condition, wrapped in parentheses so an `OR` inside it can't change how it combines
+   * with other conditions. Escape interpolated values with `soqlEscape`.
+   */
+  whereRaw(conditionSql: string): this;
+  /** `field IN (...)` with a list of values or a single-field semi-join subquery. */
+  whereIn<F extends SObjectFieldName<R, K>, SK extends SObjectName<R>, SubSelection extends object>(field: F, values: readonly SoqlFieldValue<R, K, F>[] | SoqlQueryBuilder<R, SK, SubSelection>): this;
+  /** `field NOT IN (...)` with a list of values or a single-field anti-join subquery. */
+  whereNotIn<F extends SObjectFieldName<R, K>, SK extends SObjectName<R>, SubSelection extends object>(field: F, values: readonly SoqlFieldValue<R, K, F>[] | SoqlQueryBuilder<R, SK, SubSelection>): this;
+  /**
+   * `field INCLUDES (...)` for multi-select picklists. Each item matches when all its values are
+   * selected: `whereIncludes("Interests__c", [["Golf", "Tennis"], "Chess"])` builds
+   * `INCLUDES ('Golf;Tennis', 'Chess')`.
+   */
+  whereIncludes(field: MultiPicklistField<R, K>, values: readonly (string | readonly string[])[]): this;
+  /** `field EXCLUDES (...)` for multi-select picklists; items combine like `whereIncludes`. */
+  whereExcludes(field: MultiPicklistField<R, K>, values: readonly (string | readonly string[])[]): this;
+  /**
+   * Wraps conditions in parentheses, joined by `join` (default `OR`). Groups nest, so
+   * `(A OR B) AND (C OR (D AND E))` is expressible. Top-level conditions are always joined with AND.
+   */
+  whereGroup(build: (group: SoqlQueryBuilder<R, K>) => void, join?: "AND" | "OR"): this;
+  /** Negates a group of conditions: `whereNot(g => g.where("Type", "=", "Prospect"))` builds `(NOT (Type = 'Prospect'))`. */
+  whereNot(build: (group: SoqlQueryBuilder<R, K>) => void, join?: "AND" | "OR"): this;
+  /**
+   * Condition on a parent field, e.g. `whereRelated("Account", "Name", "=", "Acme")` or
+   * `whereRelated("Account.Owner", "IsActive", "=", true)` from `Contact`.
+   */
+  whereRelated<P extends ParentPath<R, K>, F extends SObjectFieldName<R, PathTarget<R, K, P>>, O extends SoqlOperatorFor<R, PathTarget<R, K, P>, F>>(path: P, field: F, operator: O, value: SoqlWhereValue<R, PathTarget<R, K, P>, F, O>): this;
+  groupBy(...fields: SObjectFieldName<R, K>[]): this;
+  /** Raw `HAVING` condition, e.g. `"COUNT(Id) > 1"`, wrapped in parentheses. */
+  havingRaw(conditionSql: string): this;
+  havingGroup(build: (group: SoqlQueryBuilder<R, K>) => void, join?: "AND" | "OR"): this;
+  orderBy(field: SObjectFieldName<R, K>, direction?: SoqlDirection, nullOrder?: SoqlNullOrder): this;
+  /** Orders by a parent field, e.g. `orderByRelated("Account", "Name", "DESC")`. */
+  orderByRelated<P extends ParentPath<R, K>>(path: P, field: SObjectFieldName<R, PathTarget<R, K, P>>, direction?: SoqlDirection, nullOrder?: SoqlNullOrder): this;
+  /** Raw `ORDER BY` item, e.g. `"Account.Name DESC"`. */
+  orderByRaw(expression: string): this;
+  /** Adds `WITH USER_MODE`, so sharing rules and field-level security of the running user apply. */
+  withUserMode(): this;
+  limit(count: number): this;
+  offset(count: number): this;
+  /** Adds `FOR VIEW`, `FOR REFERENCE` or `FOR UPDATE`. */
+  for(clause: "VIEW" | "REFERENCE" | "UPDATE"): this;
+  /** Returns the SOQL string. Throws when the query is invalid. */
+  build(): string;
+  toString(): string;
+  private cast;
+  /** Adds fields, skipping duplicates. Field names are case-insensitive in SOQL. */
+  private addFields;
+  private groupConditions;
+  /** A group callback may only add conditions (or HAVING conditions); anything else would be lost. */
+  private assertOnly;
+  private whereSet;
+  private whereMultiPicklist;
+  private selectAggregate;
+  private assertValidQuery;
+}
+/** Returns a factory for builders bound to registry `R`: `const soql = soqlFor<SObjectRegistry>(); soql("Account")`. */
+export declare function soqlFor<R extends object = GenericRegistry>(): <K extends SObjectName<R>>(sobjectName: K) => SoqlQueryBuilder<R, K>;
+//#endregion
+//#region src/resources/bulk.d.ts
+type Scalar = string | number | boolean | null | undefined;
+type FlatKeys<T> = { [P in keyof T & string]: P extends "attributes" ? never : NonNullable<T[P]> extends Scalar ? P : NonNullable<T[P]> extends object ? `${P}.${Exclude<keyof NonNullable<T[P]>, "attributes"> & string}` : P; }[keyof T & string];
+/**
+ * A row of a Bulk API CSV result. All values are strings; relationship fields become dotted
+ * columns (e.g. `"Account.Name"`).
+ */
+type BulkCsvRecord<T> = string extends keyof T ? Record<string, string> : { [P in FlatKeys<T>]: string; };
+/**
+ * A record to ingest: any subset of the sObject's fields (`null` clears a field), plus dotted
+ * relationship columns for parent lookups by external id (e.g. `"Account.External_Id__c"`).
+ */
+type BulkIngestRecord<R extends object, K extends SObjectName<R>> = { [F in SObjectFieldName<R, K>]?: SObjectRecord<R, K>[F] | Date | null; } & {
+  [relationshipColumn: `${string}.${string}`]: string | number | undefined;
+};
+interface WaitOptions {
+  /** Delay between status checks. Defaults to 2 000 ms. */
+  pollIntervalMs?: number;
+  /** Give up after this many milliseconds. Defaults to 10 minutes. */
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+interface BulkIngestJobOptions<K extends string = string> {
+  object: K;
+  operation: BulkIngestOperation;
+  /** Required for `upsert`. */
+  externalIdFieldName?: string;
+  assignmentRuleId?: string;
+  columnDelimiter?: BulkColumnDelimiter;
+  lineEnding?: BulkLineEnding;
+  signal?: AbortSignal;
+}
+interface BulkIngestOptions<R extends object, K extends SObjectName<R>> extends BulkIngestJobOptions<K> {
+  /** Required for `upsert`: an external id field of `object`. */
+  externalIdFieldName?: ExternalIdField<R, K>;
+  /** Records to upload; converted to CSV. Pass either `records` or `csv`. */
+  records?: readonly BulkIngestRecord<R, K>[];
+  /** Pre-built CSV to upload. */
+  csv?: string;
+  /** Wait until the job has finished. Defaults to `true`. */
+  wait?: boolean | WaitOptions;
+}
+interface BulkQueryOptions {
+  /** `queryAll` also returns deleted and archived records. */
+  includeDeleted?: boolean;
+  columnDelimiter?: BulkColumnDelimiter;
+  lineEnding?: BulkLineEnding;
+  /** Maximum records per result page. */
+  maxRecords?: number;
+  wait?: WaitOptions;
+  signal?: AbortSignal;
+}
+/** A Bulk API 2.0 ingest job. */
+export declare class BulkIngestJob {
+  private readonly _connection;
+  info: BulkJobInfo;
+  constructor(_connection: SalesforceConnection, info: BulkJobInfo);
+  get id(): string;
+  private get path();
+  private get delimiter();
+  /** Uploads CSV data, or records that are converted to CSV. Only allowed while the job is `Open`. */
+  upload(data: string | readonly object[], options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /** Marks the upload as complete so Salesforce starts processing. */
+  close(options?: {
+    signal?: AbortSignal;
+  }): Promise<BulkJobInfo>;
+  abort(options?: {
+    signal?: AbortSignal;
+  }): Promise<BulkJobInfo>;
+  delete(options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /** Fetches the current job status. */
+  refresh(options?: {
+    signal?: AbortSignal;
+  }): Promise<BulkJobInfo>;
+  /** Polls until the job is `JobComplete`. Throws `SalesforceBulkJobError` on `Failed`, `Aborted` or timeout. */
+  waitForCompletion(options?: WaitOptions): Promise<BulkJobInfo>;
+  /** Successfully processed rows: `sf__Id`, `sf__Created` and the uploaded columns. */
+  successfulResults(options?: {
+    signal?: AbortSignal;
+  }): Promise<Record<string, string>[]>;
+  /** Failed rows: `sf__Id`, `sf__Error` and the uploaded columns. */
+  failedResults(options?: {
+    signal?: AbortSignal;
+  }): Promise<Record<string, string>[]>;
+  /** Rows that were not processed (e.g. because the job was aborted). */
+  unprocessedRecords(options?: {
+    signal?: AbortSignal;
+  }): Promise<Record<string, string>[]>;
+  private results;
+  private setState;
+}
+/** A Bulk API 2.0 query job. */
+export declare class BulkQueryJob<TRow = Record<string, string>> {
+  private readonly _connection;
+  info: BulkJobInfo;
+  constructor(_connection: SalesforceConnection, info: BulkJobInfo);
+  get id(): string;
+  private get path();
+  refresh(options?: {
+    signal?: AbortSignal;
+  }): Promise<BulkJobInfo>;
+  /** Polls until the job is `JobComplete`. Throws `SalesforceBulkJobError` on `Failed`, `Aborted` or timeout. */
+  waitForCompletion(options?: WaitOptions): Promise<BulkJobInfo>;
+  abort(options?: {
+    signal?: AbortSignal;
+  }): Promise<BulkJobInfo>;
+  delete(options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /** Yields result pages (following `Sforce-Locator`). The job must be complete. */
+  pages(options?: {
+    maxRecords?: number;
+    signal?: AbortSignal;
+  }): AsyncGenerator<TRow[], void, undefined>;
+  /** Yields every result row. The job must be complete. */
+  records(options?: {
+    maxRecords?: number;
+    signal?: AbortSignal;
+  }): AsyncGenerator<TRow, void, undefined>;
+}
+/** Bulk API 2.0: asynchronous ingest (insert/update/upsert/delete) and query of large data volumes. */
+export declare class BulkApi<R extends object> {
+  private readonly _connection;
+  constructor(_connection: SalesforceConnection);
+  /** Creates an ingest job in state `Open`. Upload data with `job.upload()` and then call `job.close()`. */
+  createIngestJob<K extends SObjectName<R>>(options: BulkIngestJobOptions<K> & {
+    externalIdFieldName?: ExternalIdField<R, K>;
+  }): Promise<BulkIngestJob>;
+  /** Attaches to an existing ingest job. */
+  ingestJob(id: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<BulkIngestJob>;
+  /**
+   * Creates an ingest job, uploads the data, closes the job and (by default) waits for it.
+   * Check `job.info.numberRecordsFailed` and `job.failedResults()` afterwards.
+   */
+  ingest<K extends SObjectName<R>>(options: BulkIngestOptions<R, K>): Promise<BulkIngestJob>;
+  /** Creates a query job. Wait for it with `job.waitForCompletion()` and read rows with `job.records()`. */
+  createQueryJob<K extends SObjectName<R>, S extends object = NoSelection>(query: SoqlQueryBuilder<R, K, S>, options?: BulkQueryOptions): Promise<BulkQueryJob<BulkCsvRecord<SoqlQueryRecord<R, K, S>>>>;
+  createQueryJob<TRow = Record<string, string>>(soql: string, options?: BulkQueryOptions): Promise<BulkQueryJob<TRow>>;
+  private startQueryJob;
+  /** Attaches to an existing query job. */
+  queryJob<TRow = Record<string, string>>(id: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<BulkQueryJob<TRow>>;
+  /**
+   * Runs a query job, waits for it and yields every row (CSV values are strings).
+   *
+   * ```ts
+   * for await (const row of sf.bulk.query(sf.soql("Account").select("Id", "Name"))) { ... }
+   * ```
+   */
+  query<K extends SObjectName<R>, S extends object = NoSelection>(query: SoqlQueryBuilder<R, K, S>, options?: BulkQueryOptions): AsyncGenerator<BulkCsvRecord<SoqlQueryRecord<R, K, S>>, void, undefined>;
+  query<TRow = Record<string, string>>(soql: string, options?: BulkQueryOptions): AsyncGenerator<TRow, void, undefined>;
+}
+//#endregion
+//#region src/resources/collections.d.ts
+interface CollectionOptions {
+  /** Roll back the whole call when one record fails. */
+  allOrNone?: boolean;
+  /** Throw a `SalesforceSaveError` when any record failed. Defaults to `true`. */
+  throwOnError?: boolean;
+  /**
+   * Split more than 200 records into several sequential calls. Each call is its own
+   * transaction, so this cannot be combined with `allOrNone`.
+   */
+  chunk?: boolean;
+  signal?: AbortSignal;
+}
+/** sObject Collections (`/composite/sobjects`): create, update, upsert, delete and retrieve up to 200 records per call. */
+export declare class CollectionsApi<R extends object> {
+  private readonly _connection;
+  constructor(_connection: SalesforceConnection);
+  create<K extends SObjectName<R>>(sobject: K, records: readonly SObjectCreateInput<R, K>[], options?: CollectionOptions): Promise<SaveResult[]>;
+  /** Updates records; every record needs its `Id`. */
+  update<K extends SObjectName<R>>(sobject: K, records: readonly (SObjectUpdateInput<R, K> & {
+    Id: string;
+  })[], options?: CollectionOptions): Promise<SaveResult[]>;
+  /** Upserts records of one sObject by external id. Every record needs the external id field. */
+  upsert<K extends SObjectName<R>, F extends ExternalIdField<R, K>>(sobject: K, externalIdField: F, records: readonly SObjectCreateInput<R, K>[], options?: CollectionOptions): Promise<UpsertResult[]>;
+  /** Deletes records by id (they may be of different sObjects). */
+  delete(ids: readonly string[], options?: CollectionOptions): Promise<DeleteResult[]>;
+  /** Retrieves records by id with the given fields. Inaccessible or unknown ids yield `null`. */
+  retrieve<K extends SObjectName<R>, F extends SObjectFieldName<R, K>>(sobject: K, ids: readonly string[], fields: readonly F[], options?: {
+    signal?: AbortSignal;
+  }): Promise<(WithAttributes<Pick<SObjectRecord<R, K>, F>> | null)[]>;
+  private save;
+}
+//#endregion
+//#region src/resources/composite.d.ts
+declare const refResultType: unique symbol;
+/**
+ * A handle to a composite subrequest. Use `ref("id")` to reference its result in a later
+ * subrequest (it becomes `@{referenceId.id}`) and `response.get(handle)` to read the result.
+ */
+interface CompositeRef<T> {
+  readonly referenceId: string;
+  /** Returns the `@{referenceId.path}` expression. Paths can go deeper, e.g. `"records[0].Id"`. */
+  ref(path: (keyof T & string) | (string & {})): string;
+  readonly [refResultType]?: T;
+}
+interface SubrequestOptions {
+  /** A custom reference id. Defaults to `ref1`, `ref2`, ... */
+  referenceId?: string;
+  /** Extra headers for this subrequest (not Accept, Authorization or Content-Type). */
+  httpHeaders?: Record<string, string>;
+}
+interface CompositeRawSubrequest {
+  method: CompositeMethod;
+  /** Relative to `/services/data/{version}` (e.g. `"/sobjects/Account"`) or a full `/services/...` path. */
+  path: string;
+  body?: unknown;
+}
+/** Collects subrequests for `/composite` or one graph of `/composite/graph`. */
+export declare class CompositeRequestBuilder<R extends object> {
+  private readonly _apiVersion;
+  private readonly _referencePrefix;
+  private readonly _subrequests;
+  private _queryCount;
+  constructor(_apiVersion: ApiVersion, _referencePrefix?: string);
+  /** The subrequests collected so far. */
+  get subrequests(): readonly CompositeSubrequest[];
+  /** Number of query subrequests collected so far (Salesforce allows at most 5 per composite request). */
+  get queryCount(): number;
+  create<K extends SObjectName<R>>(sobject: K, record: SObjectCreateInput<R, K>, options?: SubrequestOptions): CompositeRef<SaveResult>;
+  update<K extends SObjectName<R>>(sobject: K, id: string, record: SObjectUpdateInput<R, K>, options?: SubrequestOptions): CompositeRef<null>;
+  upsert<K extends SObjectName<R>, F extends ExternalIdField<R, K>>(sobject: K, externalIdField: F, externalIdValue: string | number, record: Omit<SObjectCreateInput<R, K>, F>, options?: SubrequestOptions): CompositeRef<UpsertResult>;
+  delete<K extends SObjectName<R>>(sobject: K, id: string, options?: SubrequestOptions): CompositeRef<null>;
+  get<K extends SObjectName<R>, F extends SObjectFieldName<R, K> = SObjectFieldName<R, K>>(sobject: K, id: string, fields?: readonly F[], options?: SubrequestOptions): CompositeRef<WithAttributes<Pick<SObjectRecord<R, K>, F>>>;
+  /** Adds a SOQL query subrequest. Its result is one page (`QueryResponse`). */
+  query<K extends SObjectName<R>, S extends object>(query: SoqlQueryBuilder<R, K, S>, options?: SubrequestOptions): CompositeRef<QueryResponse<SoqlQueryRecord<R, K, S>>>;
+  query<T = Record<string, unknown>>(soql: string, options?: SubrequestOptions): CompositeRef<QueryResponse<T>>;
+  /** Adds any other supported subrequest (sObject collections, describe, ...). */
+  request<T = unknown>(subrequest: CompositeRawSubrequest, options?: SubrequestOptions): CompositeRef<T>;
+  /** `ref1`, `ref2`, ...: skips ids already taken by a custom `referenceId`. */
+  private nextReferenceId;
+  private add;
+}
+/** The result of a composite request (or of one graph). */
+export declare class CompositeResponse {
+  readonly responses: CompositeSubrequestResult[];
+  constructor(responses: CompositeSubrequestResult[]);
+  /** `true` when any subrequest returned a status of 400 or higher. */
+  get hasErrors(): boolean;
+  /** The raw subrequest result for `ref`. */
+  response<T>(ref: CompositeRef<T>): CompositeSubrequestResult<T>;
+  /** The body of the subrequest for `ref`. Throws `SalesforceError` when that subrequest failed. */
+  get<T>(ref: CompositeRef<T>): T;
+}
+interface CompositeOptions {
+  /** Roll back all subrequests when one fails. */
+  allOrNone?: boolean;
+  /** Let Salesforce group independent subrequests (default `true` on the server). */
+  collateSubrequests?: boolean;
+  /** Throw a `SalesforceError` for the first failed subrequest. Defaults to `false`. */
+  throwOnError?: boolean;
+  signal?: AbortSignal;
+}
+interface CompositeGraphInput<R extends object> {
+  graphId: string;
+  build: (graph: CompositeRequestBuilder<R>) => void;
+}
+interface CompositeGraphResult {
+  graphId: string;
+  isSuccessful: boolean;
+  response: CompositeResponse;
+}
+interface CompositeBatchRequest {
+  method: CompositeMethod;
+  /** Relative to the API version, e.g. `"/sobjects/Account/001..."`. */
+  path: string;
+  /** The request body (`richInput`). */
+  body?: unknown;
+}
+type TreeChildren<R extends object, K extends SObjectName<R>> = string extends ChildRelationshipName<R, K> ? unknown : { [C in ChildRelationshipName<R, K>]?: {
+  records: TreeChildRecord<R, ChildSObjectName<R, K, C>>[];
+}; };
+type TreeNodeMeta<R extends object, K extends SObjectName<R>> = {
+  attributes: {
+    type: K;
+    referenceId: string;
+  };
+} & TreeChildren<R, K>;
+/** A root record of an sObject tree. */
+type TreeRecord<R extends object, K extends SObjectName<R>> = SObjectCreateInput<R, K> & TreeNodeMeta<R, K>;
+/** A child record of an sObject tree; the lookup to the parent is set by Salesforce. */
+type TreeChildRecord<R extends object, K extends SObjectName<R>> = Partial<SObjectCreateInput<R, K>> & TreeNodeMeta<R, K>;
+/** `/composite`, `/composite/batch`, `/composite/tree` and `/composite/graph`. */
+export declare class CompositeApi<R extends object> {
+  private readonly _connection;
+  constructor(_connection: SalesforceConnection);
+  /**
+   * Runs up to 25 subrequests in one call; later subrequests can reference earlier results.
+   *
+   * ```ts
+   * const result = await sf.composite.execute(c => {
+   * 	const account = c.create("Account", { Name: "Acme" });
+   * 	c.create("Contact", { LastName: "Doe", AccountId: account.ref("id") });
+   * 	return { account };
+   * }, { allOrNone: true });
+   * const accountId = result.get(result.refs.account).id;
+   * ```
+   */
+  execute<TRefs = void>(build: (composite: CompositeRequestBuilder<R>) => TRefs, options?: CompositeOptions): Promise<CompositeResponse & {
+    refs: TRefs;
+  }>;
+  /** `/composite/batch`: up to 25 independent subrequests (each counts against API limits). */
+  batch(requests: CompositeBatchRequest[], options?: {
+    haltOnError?: boolean;
+    signal?: AbortSignal;
+  }): Promise<CompositeBatchResult>;
+  /**
+   * `/composite/tree/{sobject}`: creates up to 200 records with nested children in one
+   * all-or-nothing call. On failure a `SalesforceError` is thrown whose `body` holds the per-record errors.
+   */
+  tree<K extends SObjectName<R>>(sobject: K, records: TreeRecord<R, K>[], options?: {
+    signal?: AbortSignal;
+  }): Promise<TreeSaveResult>;
+  /** `/composite/graph`: several independent all-or-nothing graphs of subrequests in one call. */
+  graph(graphs: CompositeGraphInput<R>[], options?: {
+    signal?: AbortSignal;
+  }): Promise<CompositeGraphResult[]>;
+}
+//#endregion
+//#region src/resources/events.d.ts
+/** Platform event sObject names (`...__e`) in registry `R`. */
+type PlatformEventName<R> = string extends SObjectName<R> ? `${string}__e` : Extract<SObjectName<R>, `${string}__e`>;
+interface PublishResult {
+  /** `true` when Salesforce accepted (enqueued) the event. */
+  success: boolean;
+  /** The event UUID (`EventUuid`), taken from the `OPERATION_ENQUEUED` entry Salesforce returns. */
+  uuid: string | undefined;
+  /** The returned id. Not unique or meaningful for events; use `uuid` to correlate. */
+  id: string | undefined;
+  /** Real errors (the `OPERATION_ENQUEUED` entry is not an error and is left out). */
+  errors: SaveError[];
+}
+interface PublishOptions {
+  /** Throw a `SalesforceSaveError` when any event was not accepted. Defaults to `true`. */
+  throwOnError?: boolean;
+  signal?: AbortSignal;
+}
+/**
+ * Publishes platform events. Payloads are typed by the event's generated create input.
+ *
+ * ```ts
+ * await sf.events.publish("Order_Shipped__e", { Order_Number__c: "A-1" });
+ * await sf.events.publish("Order_Shipped__e", [{ Order_Number__c: "A-1" }, { Order_Number__c: "A-2" }]);
+ * ```
+ *
+ * With the default "Publish Immediately" behaviour, events are published even when later
+ * events in the same call fail; there is no rollback.
+ */
+export declare class EventsApi<R extends object> {
+  private readonly _connection;
+  constructor(_connection: SalesforceConnection);
+  publish<K extends PlatformEventName<R> & SObjectName<R>>(eventName: K, events: SObjectCreateInput<R, K> | readonly SObjectCreateInput<R, K>[], options?: PublishOptions): Promise<PublishResult[]>;
+  private publishOne;
+  private publishBatch;
+}
+/** Converts a save result, treating the `OPERATION_ENQUEUED` entry as the UUID instead of an error. */
+export declare function toPublishResult(result: SaveResult): PublishResult;
+//#endregion
+//#region src/resources/files.d.ts
+/** JSON uploads send base64, which Salesforce caps at 37.5 MB encoded (about 28 MB of file data). */
+export declare const MAX_JSON_UPLOAD_BYTES: number;
+/** Multipart ContentVersion uploads are limited to 2 GB. */
+export declare const MAX_UPLOAD_BYTES: number;
+type FileShareType = "V" | "C" | "I";
+type FileVisibility = "AllUsers" | "InternalUsers" | "SharedUsers";
+interface UploadFileOptions {
+  /** The file content. Strings are encoded as UTF-8. */
+  data: Uint8Array | string;
+  /** The file name including extension, e.g. `"invoice.pdf"` (`PathOnClient`). */
+  fileName: string;
+  /** Defaults to the file name without extension. */
+  title?: string;
+  description?: string;
+  /** A record id (or user/library id) to share the file with. */
+  linkTo?: string;
+  /** Link permission: `V` viewer (default), `C` collaborator, `I` inferred from the record. */
+  shareType?: FileShareType;
+  visibility?: FileVisibility;
+  signal?: AbortSignal;
+}
+interface NewVersionOptions {
+  data: Uint8Array | string;
+  fileName: string;
+  title?: string;
+  reasonForChange?: string;
+  signal?: AbortSignal;
+}
+interface UploadedFile {
+  contentVersionId: string;
+  contentDocumentId: string;
+}
+/**
+ * Salesforce Files (ContentVersion / ContentDocument). Small files go up as JSON with base64,
+ * larger ones as multipart (up to 2 GB), which works with every transport.
+ */
+export declare class FilesApi {
+  private readonly _connection;
+  /** Files up to this size go up as JSON/base64, larger ones as multipart. */
+  private readonly _jsonUploadLimit;
+  constructor(_connection: SalesforceConnection,
+  /** Files up to this size go up as JSON/base64, larger ones as multipart. */
+  _jsonUploadLimit?: number);
+  /** Uploads a file and optionally links it to a record. */
+  upload(options: UploadFileOptions): Promise<UploadedFile>;
+  /** Adds a new version to an existing file. */
+  newVersion(contentDocumentId: string, options: NewVersionOptions): Promise<UploadedFile>;
+  /** Downloads file content by ContentVersion id (`068...`) or ContentDocument id (`069...`, latest version). */
+  download(id: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<Uint8Array>;
+  /** Shares a file with a record, user or library. Returns the ContentDocumentLink id. */
+  link(contentDocumentId: string, linkedEntityId: string, options?: {
+    shareType?: FileShareType;
+    visibility?: FileVisibility;
+    signal?: AbortSignal;
+  }): Promise<string>;
+  private createVersion;
+  private createVersionMultipart;
+}
+//#endregion
+//#region src/resources/quick-actions.d.ts
+interface InvokeQuickActionOptions {
+  /** The record the action runs on (e.g. the parent Account of a "New Contact" action). */
+  contextId?: string;
+  /** Throw a `SalesforceSaveError` when Salesforce reports `success: false`. Defaults to `true`. */
+  throwOnError?: boolean;
+  signal?: AbortSignal;
+}
+/**
+ * Quick actions of one sObject (`sf.sobject("Account").quickActions`) or global quick actions
+ * (`sf.quickActions`). An sObject's list also includes the global actions on its layout; those
+ * only exist under `/quickActions`, so calls for them fall back to the global path.
+ */
+export declare class QuickActionsApi {
+  private readonly _connection;
+  private readonly _basePath;
+  constructor(_connection: SalesforceConnection, _basePath: string);
+  list(options?: {
+    signal?: AbortSignal;
+  }): Promise<QuickActionSummary[]>;
+  describe(name: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<QuickActionDescribe>;
+  /** The default field values the action would pre-fill, optionally for a context record. */
+  defaultValues(name: string, contextId?: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<GenericRecord>;
+  /** Runs the action with the given record values. */
+  invoke<TRecord extends object = GenericRecord>(name: string, record: TRecord, options?: InvokeQuickActionOptions): Promise<QuickActionResult>;
+  /** Calls the action under this sObject, falling back to the global action of that name. */
+  private send;
+}
+//#endregion
+//#region src/resources/reports.d.ts
+interface RunReportOptions {
+  /** Include detail rows (not just aggregates). Defaults to `true`. */
+  includeDetails?: boolean;
+  /** Override filters for this run (other metadata comes from the saved report). */
+  filters?: ReportFilter[];
+  /** Boolean filter logic for `filters`, e.g. `"1 AND (2 OR 3)"`. */
+  booleanFilter?: string;
+  signal?: AbortSignal;
+}
+interface WaitForReportOptions {
+  /** Delay between status checks. Defaults to 2 000 ms. */
+  pollIntervalMs?: number;
+  /** Give up after this many milliseconds. Defaults to 5 minutes. */
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+/** A detail row: detail column API name -> `{ label, value }`. */
+type ReportRow = Record<string, ReportDataCell>;
+/**
+ * Reports and Dashboards REST API (`/analytics/reports`). Synchronous runs return at most the
+ * first 2 000 detail rows; the org allows 500 synchronous runs per hour.
+ */
+export declare class ReportsApi {
+  private readonly _connection;
+  constructor(_connection: SalesforceConnection);
+  /** Recently viewed reports. */
+  list(options?: {
+    signal?: AbortSignal;
+  }): Promise<ReportSummary[]>;
+  describe(reportId: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<ReportDescribe>;
+  /** Runs a report synchronously. */
+  run(reportId: string, options?: RunReportOptions): Promise<ReportResult>;
+  /** Starts an asynchronous run; results stay available for 24 hours. */
+  runAsync(reportId: string, options?: RunReportOptions): Promise<ReportInstance>;
+  /** Status (and, when finished, results) of an asynchronous run. */
+  instance(reportId: string, instanceId: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<ReportResult & {
+    attributes: {
+      status?: ReportInstance["status"];
+    };
+  }>;
+  /** Polls an asynchronous run until it succeeds, then returns the results. */
+  waitForInstance(reportId: string, instanceId: string, options?: WaitForReportOptions): Promise<ReportResult>;
+  /** Flattens detail rows of a report result; see `reportRows`. */
+  toRows(result: ReportResult): ReportRow[];
+}
+/**
+ * Flattens the detail rows of a report result into objects keyed by detail column API name
+ * (e.g. `ACCOUNT.NAME`), each with the cell's `label` and `value`. Works for tabular, summary
+ * and matrix reports; requires `includeDetails`.
+ */
+export declare function reportRows(result: ReportResult): ReportRow[];
+//#endregion
+//#region src/resources/search.d.ts
+interface SearchSuggestionsOptions {
+  /** The search text (at least 3 characters for most objects). */
+  q: string;
+  sobject: string;
+  fields?: string[];
+  limit?: number;
+  where?: string;
+  useSearchScope?: boolean;
+  signal?: AbortSignal;
+}
+/** SOSL search, parameterized search and search suggestions. */
+export declare class SearchApi {
+  private readonly _connection;
+  constructor(_connection: SalesforceConnection);
+  /**
+   * Runs a SOSL query, e.g. `FIND {Acme*} IN NAME FIELDS RETURNING Account(Id, Name)`.
+   * Escape user input in the `FIND {...}` term with `soslEscape`.
+   */
+  sosl<T = GenericRecord>(query: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<SearchResult<T>>;
+  /** `POST /parameterizedSearch`: search without writing SOSL. */
+  parameterized<T = GenericRecord>(request: ParameterizedSearchRequest, options?: {
+    signal?: AbortSignal;
+  }): Promise<SearchResult<T>>;
+  /** `GET /search/suggestions`: auto-suggest records matching the start of a term. */
+  suggestions<T = GenericRecord>(options: SearchSuggestionsOptions): Promise<SearchSuggestionsResult<T>>;
+}
+//#endregion
+//#region src/cache.d.ts
+/**
+ * An in-memory cache for metadata calls (describe, UI API object info, record type ids).
+ * Concurrent callers share one in-flight request, each waiting with its own abort signal;
+ * failed loads are not cached.
+ */
+export declare class MetadataCache {
+  private readonly _enabled;
+  private readonly _entries;
+  constructor(_enabled?: boolean);
+  /**
+   * Returns the cached value for `key`, or loads (and caches) it. `load` receives a signal of
+   * its own: aborting `signal` only stops this caller from waiting.
+   */
+  getOrLoad<T>(key: string, load: (signal: AbortSignal | undefined) => Promise<T>, signal?: AbortSignal): Promise<T>;
+  /** Removes one entry, or every entry when `key` is omitted. */
+  clear(key?: string): void;
+}
+//#endregion
+//#region src/resources/sobject.d.ts
+interface UpsertOutcome {
+  id: string;
+  /** `true` when a record was inserted, `false` when an existing one was updated. */
+  created: boolean;
+}
+interface RequestSignal {
+  signal?: AbortSignal;
+}
+/** A picklist option, typed with the field's value type. */
+interface PicklistOption<TValue> {
+  value: TValue;
+  label: string;
+  isDefault: boolean;
+}
+/** Typed operations on one sObject: describe, CRUD, upsert, external ids, blobs and queries. */
+export declare class SObjectResource<R extends object, K extends SObjectName<R>> {
+  private readonly _connection;
+  private readonly _queries;
+  readonly name: K;
+  private readonly _basePath;
+  private readonly _cache?;
+  constructor(_connection: SalesforceConnection, _queries: QueryApi, name: K, _basePath?: "" | "/tooling", _cache?: MetadataCache | undefined);
+  private get path();
+  /** `GET /sobjects/{name}/describe`: fields, relationships, record types, ... Cached per client. */
+  describe(options?: RequestSignal): Promise<DescribeSObjectResult>;
+  /**
+   * Returns the id of a record type by DeveloperName, e.g. `recordTypeId("Complaint")`. Record type
+   * ids differ between orgs, so resolve them at runtime instead of hard-coding them.
+   */
+  recordTypeId(developerName: RecordTypeName<R, K>, options?: RequestSignal): Promise<string>;
+  /**
+   * Active picklist values of a field. With `recordType`, only the values available for that
+   * record type are returned (via the UI API).
+   */
+  picklistValues<F extends SObjectFieldName<R, K>>(field: F, options?: RequestSignal & {
+    recordType?: RecordTypeName<R, K>;
+  }): Promise<PicklistOption<NonNullable<SObjectRecord<R, K>[F]>>[]>;
+  /** Quick actions of this sObject. */
+  get quickActions(): QuickActionsApi;
+  /** `GET /sobjects/{name}`: basic metadata and recently viewed records. */
+  basicInfo(options?: RequestSignal): Promise<SObjectBasicInfo>;
+  /** Creates a record and returns its id. Throws `SalesforceSaveError` if Salesforce reports `success: false`. */
+  create(record: SObjectCreateInput<R, K>, options?: RequestSignal): Promise<string>;
+  /** Retrieves a record with all fields. */
+  get(id: string, options?: RequestSignal): Promise<WithAttributes<SObjectRecord<R, K>>>;
+  /** Retrieves a record with only `fields`; the result type is narrowed accordingly. */
+  get<F extends SObjectFieldName<R, K>>(id: string, fields: readonly F[], options?: RequestSignal): Promise<WithAttributes<Pick<SObjectRecord<R, K>, F>>>;
+  /** Updates fields of a record. */
+  update(id: string, record: SObjectUpdateInput<R, K>, options?: RequestSignal): Promise<void>;
+  /** Deletes a record. */
+  delete(id: string, options?: RequestSignal): Promise<void>;
+  /**
+   * Inserts or updates a record by external id (`PATCH /sobjects/{name}/{field}/{value}`).
+   * Salesforce answers 300 (a `SalesforceError`) when the value matches more than one record.
+   */
+  upsert<F extends ExternalIdField<R, K>>(externalIdField: F, externalIdValue: string | number, record: Omit<SObjectCreateInput<R, K>, F>, options?: RequestSignal & {
+    updateOnly?: boolean;
+  }): Promise<UpsertOutcome>;
+  /** Retrieves a record by external id. */
+  getByExternalId<F extends SObjectFieldName<R, K> = SObjectFieldName<R, K>>(externalIdField: ExternalIdField<R, K>, externalIdValue: string | number, fields?: readonly F[], options?: RequestSignal): Promise<WithAttributes<Pick<SObjectRecord<R, K>, F>>>;
+  /** Ids of records deleted between `start` and `end` (UTC, at most 15 days back). */
+  getDeleted(start: Date, end: Date, options?: RequestSignal): Promise<DeletedRecordsResult>;
+  /** Ids of records updated between `start` and `end` (UTC, at most 30 days back). */
+  getUpdated(start: Date, end: Date, options?: RequestSignal): Promise<UpdatedRecordsResult>;
+  /** Downloads a blob field, e.g. `sobject("ContentVersion").getBlob(id, "VersionData")`. */
+  getBlob(id: string, field: SObjectFieldName<R, K>, options?: RequestSignal): Promise<Uint8Array>;
+  /** Starts a typed query on this sObject. */
+  soql(): SoqlQueryBuilder<R, K>;
+  /** Runs a query built on this sObject and returns the first page. */
+  query<S extends object = NoSelection>(build: (query: SoqlQueryBuilder<R, K>) => SoqlQueryBuilder<R, K, S>, options?: QueryOptions): Promise<QueryResult<SoqlQueryRecord<R, K, S>>>;
+  /** Runs a query built on this sObject and returns the records of all pages. */
+  collect<S extends object = NoSelection>(build: (query: SoqlQueryBuilder<R, K>) => SoqlQueryBuilder<R, K, S>, options?: QueryOptions): Promise<SoqlQueryRecord<R, K, S>[]>;
+  /** Runs a query built on this sObject and yields records of all pages lazily. */
+  iterate<S extends object = NoSelection>(build: (query: SoqlQueryBuilder<R, K>) => SoqlQueryBuilder<R, K, S>, options?: QueryOptions): AsyncGenerator<SoqlQueryRecord<R, K, S>, void, undefined>;
+}
+//#endregion
+//#region src/resources/debug-logs.d.ts
+type LogLevel = "NONE" | "ERROR" | "WARN" | "INFO" | "DEBUG" | "FINE" | "FINER" | "FINEST";
+/** Log levels per category, as on a DebugLevel record. */
+interface DebugLevels {
+  ApexCode: LogLevel;
+  ApexProfiling: LogLevel;
+  Callout: LogLevel;
+  Database: LogLevel;
+  System: LogLevel;
+  Validation: LogLevel;
+  Visualforce: LogLevel;
+  Workflow: LogLevel;
+}
+/** Defaults tuned for debugging Apex: everything from `System.debug` and exceptions, little noise. */
+export declare const DEFAULT_DEBUG_LEVELS: DebugLevels;
+/** The DebugLevel this library creates and reuses. */
+export declare const DEBUG_LEVEL_NAME = "sobjectly";
+interface ApexLogEntry {
+  id: string;
+  operation: string;
+  request: string;
+  /** `"Success"` or the unhandled exception message. */
+  status: string;
+  startTime: string;
+  durationMilliseconds: number;
+  logLength: number;
+  /** The log text (when `includeBodies` is on). */
+  body?: string;
+}
+interface CaptureLogsOptions {
+  /** The user to trace. Defaults to the authenticated user. */
+  userId?: string;
+  /** Log levels; defaults to `DEFAULT_DEBUG_LEVELS`. */
+  levels?: Partial<DebugLevels>;
+  /** Download the log text. Defaults to `true`. */
+  includeBodies?: boolean;
+  /** Wait this long after the callback before collecting logs. Defaults to 1 000 ms. */
+  settleMs?: number;
+  /** How long the trace flag stays active if cleanup fails. Defaults to 30 minutes (max 24 hours). */
+  expirationMinutes?: number;
+  signal?: AbortSignal;
+}
+interface CaptureLogsResult<T> {
+  result: T;
+  logs: ApexLogEntry[];
+  /**
+   * Set when restoring the user's trace flag failed. The work's result is still returned; the
+   * flag lapses on its own after `expirationMinutes`.
+   */
+  cleanupError?: unknown;
+}
+/** Thrown by `capture` when the callback throws; carries the logs collected anyway. */
+export declare class DebugLogCaptureError extends Error {
+  readonly logs: ApexLogEntry[];
+  readonly cause: unknown;
+  /** Set when restoring the user's trace flag failed as well. */
+  readonly cleanupError?: unknown;
+  readonly name: string;
+  constructor(logs: ApexLogEntry[], cause: unknown,
+  /** Set when restoring the user's trace flag failed as well. */
+  cleanupError?: unknown);
+}
+/** Apex debug logs through the Tooling API: capture the logs of a block of work, list and read logs. */
+export declare class DebugLogsApi {
+  private readonly _tooling;
+  /** The latest capture per user: a user has one trace flag, so captures for a user take turns. */
+  private readonly _captures;
+  constructor(_tooling: ToolingApi);
+  /** The id of the authenticated user (from `/services/oauth2/userinfo`). */
+  currentUserId(options?: {
+    signal?: AbortSignal;
+  }): Promise<string>;
+  /** The most recent Apex logs, newest first. */
+  list(options?: {
+    userId?: string;
+    limit?: number;
+    signal?: AbortSignal;
+  }): Promise<ApexLogEntry[]>;
+  /** The text of one Apex log. */
+  body(logId: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<string>;
+  /**
+   * Runs `work` with debug logging enabled for the user, then returns its result together with
+   * the Apex logs it produced (e.g. from triggers, flows or Apex REST calls):
+   *
+   * ```ts
+   * const { result, logs } = await sf.tooling.debugLogs.capture(() => sf.sobject("Case").create({ Subject: "x" }));
+   * console.log(logs.map((log) => log.body).join("\n"));
+   * ```
+   *
+   * Salesforce allows one trace flag per user; an existing flag is reused and restored afterwards,
+   * and captures for the same user through this client run one after another. Only work that runs
+   * while the callback does is traced: async Apex it enqueues (queueable, batch, future) usually
+   * runs later. At most the 200 newest logs of the user are collected.
+   */
+  capture<T>(work: () => Promise<T>, options?: CaptureLogsOptions): Promise<CaptureLogsResult<T>>;
+  private captureFor;
+  private ensureDebugLevel;
+  /** Enables tracing and returns a function that restores the previous state. */
+  private enableTraceFlag;
+}
+//#endregion
+//#region src/resources/tooling.d.ts
+/** Thrown by `executeAnonymous` when Apex fails to compile or throws. */
+export declare class ApexExecutionError extends Error {
+  readonly result: ExecuteAnonymousResult;
+  /** The debug logs, when the Apex ran with `captureLog: true`. */
+  readonly logs: ApexLogEntry[];
+  readonly name: string;
+  constructor(result: ExecuteAnonymousResult,
+  /** The debug logs, when the Apex ran with `captureLog: true`. */
+  logs?: ApexLogEntry[]);
+}
+/** Loosely typed result of `runTestsSynchronous`. */
+interface RunTestsResult {
+  numTestsRun: number;
+  numFailures: number;
+  totalTime: number;
+  successes: Record<string, unknown>[];
+  failures: Record<string, unknown>[];
+  codeCoverage?: Record<string, unknown>[];
+  codeCoverageWarnings?: Record<string, unknown>[];
+  [key: string]: unknown;
+}
+/** The Tooling API (`/tooling/...`): metadata-ish sObjects such as ApexClass, anonymous Apex and tests. */
+interface ExecuteAnonymousOptions {
+  /** Throw `ApexExecutionError` when the Apex doesn't compile or throws. Defaults to `true`. */
+  throwOnError?: boolean;
+  /** Capture the debug log of the execution (see `debugLogs.capture`). */
+  captureLog?: boolean;
+  /** Options for the log capture, e.g. log levels. */
+  logOptions?: Omit<CaptureLogsOptions, "signal">;
+  signal?: AbortSignal;
+}
+export declare class ToolingApi {
+  private readonly _connection;
+  private readonly _queries;
+  /** Apex debug logs: capture the logs of a block of work, list and read logs. */
+  readonly debugLogs: DebugLogsApi;
+  constructor(_connection: SalesforceConnection);
+  /** The connection this API uses. */
+  get connection(): SalesforceConnection;
+  /** Runs a Tooling SOQL query and returns the first page. */
+  query<T = GenericRecord>(soql: string, options?: QueryOptions): Promise<QueryResult<T>>;
+  queryMore<T>(cursor: QueryCursor<T>, options?: Pick<QueryOptions, "signal">): Promise<QueryResult<T>>;
+  iterate<T = GenericRecord>(soql: string, options?: QueryOptions): AsyncGenerator<T, void, undefined>;
+  collect<T = GenericRecord>(soql: string, options?: QueryOptions): Promise<T[]>;
+  /** CRUD and describe for a Tooling sObject, e.g. `tooling.sobject("TraceFlag")`. */
+  sobject(name: string): SObjectResource<GenericRegistry, string>;
+  describeGlobal(options?: {
+    signal?: AbortSignal;
+  }): Promise<DescribeGlobalResult>;
+  /**
+   * Executes anonymous Apex. Throws `ApexExecutionError` when it does not compile or throws,
+   * unless `throwOnError` is `false`. Salesforce only accepts the Apex in the query string, so it is
+   * limited to about 12 000 characters once URL-encoded; put longer logic in an Apex class.
+   * With `captureLog: true` the result includes the debug log (`System.debug` output).
+   */
+  executeAnonymous(apex: string, options: ExecuteAnonymousOptions & {
+    captureLog: true;
+  }): Promise<ExecuteAnonymousResult & {
+    logs: ApexLogEntry[];
+  }>;
+  executeAnonymous(apex: string, options?: ExecuteAnonymousOptions): Promise<ExecuteAnonymousResult>;
+  /** Runs Apex tests synchronously (a single class) and returns the results. */
+  runTestsSynchronous(request: RunTestsRequest, options?: {
+    signal?: AbortSignal;
+  }): Promise<RunTestsResult>;
+  /** Enqueues Apex tests and returns the AsyncApexJob id. */
+  runTestsAsynchronous(request: RunTestsRequest, options?: {
+    signal?: AbortSignal;
+  }): Promise<string>;
+  /** Any other Tooling resource; `path` is relative to `/tooling`. */
+  request<T>(request: RestRequest): Promise<T>;
+}
+//#endregion
+//#region src/resources/ui-api.d.ts
+interface UiRecordOptions<F extends string> {
+  /** Fields that must be accessible; an inaccessible field fails the request. */
+  fields?: readonly F[];
+  /** Fields that are returned when accessible and silently left out otherwise. */
+  optionalFields?: readonly F[];
+  layoutTypes?: readonly ("Full" | "Compact")[];
+  modes?: readonly ("Create" | "Edit" | "View")[];
+  signal?: AbortSignal;
+}
+interface UiLayoutOptions {
+  recordTypeId?: string;
+  mode?: "Create" | "Edit" | "View";
+  layoutType?: "Full" | "Compact";
+  formFactor?: "Large" | "Medium" | "Small";
+  signal?: AbortSignal;
+}
+/** The typed `fields` of a UI API record loaded with field names `F` of sObject `K`. */
+type UiRecordFields<R, K extends SObjectName<R>, F extends string> = { [P in F]: UiFieldValue<P extends keyof SObjectRecord<R, K> ? SObjectRecord<R, K>[P] : unknown>; };
+/** User Interface API: object info, picklist values per record type, records and layouts. */
+export declare class UiApi<R extends object> {
+  private readonly _connection;
+  private readonly _cache?;
+  constructor(_connection: SalesforceConnection, _cache?: MetadataCache | undefined);
+  /** `GET /ui-api/object-info/{name}`: fields, record types and defaults as the UI sees them. Cached. */
+  objectInfo<K extends SObjectName<R>>(sobject: K, options?: {
+    signal?: AbortSignal;
+  }): Promise<ObjectInfo>;
+  /** Picklist values of every picklist field for a record type. */
+  picklistValues<K extends SObjectName<R>>(sobject: K, recordTypeId: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<Record<string, PicklistValues>>;
+  /** Picklist values of one field for a record type. */
+  picklistValues<K extends SObjectName<R>>(sobject: K, recordTypeId: string, field: SObjectFieldName<R, K>, options?: {
+    signal?: AbortSignal;
+  }): Promise<PicklistValues>;
+  /**
+   * `GET /ui-api/records/{id}` with typed field names. At least one of `fields`,
+   * `optionalFields` or `layoutTypes` is required.
+   *
+   * ```ts
+   * const record = await sf.uiApi.record("Account", id, { fields: ["Name", "Industry"] });
+   * record.fields.Name.displayValue;
+   * ```
+   */
+  record<K extends SObjectName<R>, F extends SObjectFieldName<R, K>>(sobject: K, id: string, options: UiRecordOptions<F>): Promise<UiRecord<UiRecordFields<R, K, F>>>;
+  /** `GET /ui-api/layout/{name}`: the page layout sections, rows and fields. */
+  layout<K extends SObjectName<R>>(sobject: K, options?: UiLayoutOptions): Promise<UiLayout>;
+}
+//#endregion
+//#region src/client.d.ts
+interface SalesforceClientOptions {
+  /** Where access tokens come from: `accessToken()`, `clientCredentials()`, `jwtBearer()`, ... */
+  auth: AuthProvider;
+  /**
+   * The REST API version, e.g. `"v66.0"`. Required: there is no default, so a Salesforce release
+   * never changes the version you call. Tip: pass the `API_VERSION` constant exported by your
+   * generated types, so requests use the version the types were generated with.
+   */
+  apiVersion: ApiVersion;
+  /** The HTTP transport. Defaults to `fetchTransport()`; pass your own to use another HTTP client. */
+  transport?: HttpTransport;
+  /** Per-request timeout in milliseconds. Defaults to 120 000. Use `0` to disable. */
+  timeoutMs?: number;
+  /** Opt-in retries on 429/5xx. Only `GET`/`HEAD` are retried unless a request sets `retry: true`. */
+  retry?: RetryOptions | boolean;
+  /** Extra origins (besides the instance URL) that absolute URLs may point to. */
+  allowedOrigins?: string[];
+  /** Headers sent with every request, e.g. `{ "Sforce-Call-Options": "client=my-app" }`. */
+  headers?: Record<string, string>;
+  /** Observability hooks. Tokens are redacted. */
+  hooks?: RequestHooks;
+  /**
+   * Cache metadata (describe, UI API object info, record type ids) in memory for the lifetime of
+   * the client. Defaults to `true`; clear it with `clearCache()`.
+   */
+  cache?: boolean;
+}
+interface ApexRestRequest extends Omit<RestRequest, "path"> {
+  /** The `urlMapping` of the `@RestResource`, e.g. `"/accounts/001..."` (namespace included if any). */
+  path: string;
+}
+/**
+ * A type-safe Salesforce REST API client.
+ *
+ * ```ts
+ * import type { SObjectRegistry } from "./generated/sobjects";
+ *
+ * const sf = new SalesforceClient<SObjectRegistry>({
+ * 	auth: clientCredentials({ loginUrl, clientId, clientSecret }),
+ * });
+ * const id = await sf.sobject("Account").create({ Name: "Acme" });
+ * ```
+ *
+ * Without a registry type argument the client is untyped: any sObject name and field is accepted.
+ */
+export declare class SalesforceClient<R extends object = GenericRegistry> {
+  /** The low-level executor, for advanced use. */
+  readonly connection: SalesforceConnection;
+  /** SOSL, parameterized search and search suggestions. */
+  readonly search: SearchApi;
+  /** Composite, composite batch, sObject tree and composite graph. */
+  readonly composite: CompositeApi<R>;
+  /** sObject collections: up to 200 records per call. */
+  readonly collections: CollectionsApi<R>;
+  /** Invocable actions, including Flows and Apex `@InvocableMethod`s. */
+  readonly actions: ActionsApi;
+  /** The Tooling API. */
+  readonly tooling: ToolingApi;
+  /** Bulk API 2.0 ingest and query jobs. */
+  readonly bulk: BulkApi<R>;
+  /** Publish platform events. */
+  readonly events: EventsApi<R>;
+  /** Approval processes: submit, approve, reject. */
+  readonly approvals: ApprovalsApi;
+  /** Global quick actions (per-sObject actions are on `sobject(name).quickActions`). */
+  readonly quickActions: QuickActionsApi;
+  /** User Interface API: object info, picklist values per record type, records, layouts. */
+  readonly uiApi: UiApi<R>;
+  /** Salesforce Files: upload, download, new versions, sharing. */
+  readonly files: FilesApi;
+  /** Reports: run synchronously or asynchronously and flatten the rows. */
+  readonly reports: ReportsApi;
+  private readonly _queries;
+  private readonly _cache;
+  constructor(options: SalesforceClientOptions);
+  /** Drops cached metadata (describe results, object info, record type ids). */
+  clearCache(): void;
+  get apiVersion(): ApiVersion;
+  /** API usage as reported by the last response (`Sforce-Limit-Info`). */
+  get apiUsage(): ApiUsage | undefined;
+  /** The instance URL of the current access token (authenticates if needed). */
+  instanceUrl(options?: {
+    signal?: AbortSignal;
+  }): Promise<string>;
+  /**
+   * Calls any REST resource. `path` is relative to `/services/data/{apiVersion}` unless it
+   * starts with `/services/` or is an absolute URL on the instance.
+   *
+   * ```ts
+   * const limits = await sf.request<OrgLimits>({ path: "/limits" });
+   * ```
+   */
+  request<T = unknown>(request: RestRequest): Promise<T>;
+  /** Like `request`, but also returns the status and response headers. */
+  requestWithResponse<T = unknown>(request: RestRequest): Promise<RestResponse<T>>;
+  /** Calls an Apex REST endpoint (`/services/apexrest/...`). */
+  apexRest<T = unknown>(request: ApexRestRequest): Promise<T>;
+  /** Typed operations on one sObject. */
+  sobject<K extends SObjectName<R>>(name: K): SObjectResource<R, K>;
+  /** Starts a typed SOQL query. Run it with `query`, `queryAll`, `iterate` or `collect`. */
+  soql<K extends SObjectName<R>>(sobjectName: K): SoqlQueryBuilder<R, K>;
+  /** Runs a query and returns the first page. Follow `nextRecordsUrl` with `queryMore`. */
+  query<K extends SObjectName<R>, S extends object = NoSelection>(query: SoqlQueryBuilder<R, K, S>, options?: QueryOptions): Promise<QueryResult<SoqlQueryRecord<R, K, S>>>;
+  query<T = GenericRecord>(soql: string, options?: QueryOptions): Promise<QueryResult<T>>;
+  /** Fetches the next page of a query. */
+  queryMore<T>(cursor: QueryCursor<T>, options?: Pick<QueryOptions, "batchSize" | "signal">): Promise<QueryResult<T>>;
+  /** Yields every record of a query, fetching pages lazily. */
+  iterate<K extends SObjectName<R>, S extends object = NoSelection>(query: SoqlQueryBuilder<R, K, S>, options?: QueryOptions): AsyncGenerator<SoqlQueryRecord<R, K, S>, void, undefined>;
+  iterate<T = GenericRecord>(soql: string, options?: QueryOptions): AsyncGenerator<T, void, undefined>;
+  /** Fetches all pages of a query and returns every record. */
+  collect<K extends SObjectName<R>, S extends object = NoSelection>(query: SoqlQueryBuilder<R, K, S>, options?: QueryOptions): Promise<SoqlQueryRecord<R, K, S>[]>;
+  collect<T = GenericRecord>(soql: string, options?: QueryOptions): Promise<T[]>;
+  /** `GET /services/data`: every API version the org supports. Does not count against limits. */
+  versions(options?: {
+    signal?: AbortSignal;
+  }): Promise<ApiVersionInfo[]>;
+  /** `GET /services/data/{version}`: the resources available in this version. */
+  resources(options?: {
+    signal?: AbortSignal;
+  }): Promise<Record<string, string>>;
+  /** `GET /limits`: org limits such as `DailyApiRequests`. */
+  limits(options?: {
+    signal?: AbortSignal;
+  }): Promise<OrgLimits>;
+  /** `GET /limits/recordCount`: approximate record counts per sObject. */
+  recordCount(sobjects: readonly SObjectName<R>[], options?: {
+    signal?: AbortSignal;
+  }): Promise<RecordCountResult>;
+  /** `GET /sobjects`: every sObject visible to the user. */
+  describeGlobal(options?: {
+    signal?: AbortSignal;
+  }): Promise<DescribeGlobalResult>;
+  /**
+   * Asks Salesforce how it would run a query (`GET /query?explain=`, beta), e.g. to check a
+   * filter is selective. Plans are sorted best first; `relativeCost` above 1 means not selective.
+   */
+  explain(query: string | {
+    build(): string;
+  }, options?: {
+    signal?: AbortSignal;
+  }): Promise<QueryPlan[]>;
+}
+//#endregion
+//#region src/auth/providers.d.ts
+/** Uses a fixed access token, e.g. one issued by the Salesforce CLI (`sf org display`). */
+export declare function accessToken(token: AccessToken): AuthProvider;
+/**
+ * Wraps your own token source. The result is cached until Salesforce answers 401, after which
+ * `fetchToken` is called again.
+ */
+export declare function tokenProvider(fetchToken: (context: AuthContext) => Promise<AccessToken>): AuthProvider;
+interface ClientCredentialsOptions {
+  /** Your My Domain URL, e.g. `https://mydomain.my.salesforce.com`. Required for this flow. */
+  loginUrl: string;
+  clientId: string;
+  clientSecret: string;
+  /** Optional space-separated scopes. */
+  scope?: string;
+}
+/**
+ * OAuth 2.0 client credentials flow (server-to-server, runs as the app's "Run As" user).
+ * The token is cached in memory and refreshed once when Salesforce answers 401.
+ */
+export declare function clientCredentials(options: ClientCredentialsOptions): AuthProvider;
+interface JwtBearerOptions {
+  /** `https://login.salesforce.com`, `https://test.salesforce.com` or your My Domain URL. */
+  loginUrl: string;
+  /** The consumer key of the connected app / external client app. */
+  clientId: string;
+  /** The username to act as. */
+  username: string;
+  /** The PEM-encoded RSA private key whose certificate is uploaded to the app. */
+  privateKey: string;
+  /**
+   * The JWT `aud` claim. Defaults to `https://test.salesforce.com` for sandbox login URLs and
+   * `https://login.salesforce.com` otherwise.
+   */
+  audience?: string;
+  /** Lifetime of the assertion in seconds (max 180). Defaults to 180. */
+  expiresInSeconds?: number;
+}
+/** OAuth 2.0 JWT bearer flow. The assertion is signed locally with RS256; no extra dependencies. */
+export declare function jwtBearer(options: JwtBearerOptions): AuthProvider;
+interface RefreshTokenOptions {
+  loginUrl: string;
+  clientId: string;
+  /** Required unless the app is configured without a secret for the refresh token flow. */
+  clientSecret?: string;
+  refreshToken: string;
+  /** Called when Salesforce rotates the refresh token, so you can store the new one. Errors it throws are ignored. */
+  onRefreshTokenRotated?: (refreshToken: string) => void;
+}
+/** Exchanges a refresh token for access tokens. */
+export declare function refreshToken(options: RefreshTokenOptions): AuthProvider;
+/** Builds a signed RS256 JWT assertion for the JWT bearer flow. Exported for testing. */
+export declare function createJwtAssertion(options: JwtBearerOptions, now?: number): string;
+//#endregion
+//#region src/auth/sf-cli.d.ts
+/** Runs a command and returns its stdout. Resolves even on a non-zero exit when stdout was written. */
+type RunCommand = (command: string, args: readonly string[]) => Promise<string>;
+interface SfCliOptions {
+  /** The org alias or username (`--target-org`). Defaults to the CLI's default org. */
+  targetOrg?: string;
+  /** The CLI executable. Defaults to `sf`. */
+  command?: string;
+  /** Replaces how the CLI is run, e.g. in tests. */
+  runCommand?: RunCommand;
+}
+/**
+ * Uses an org you are logged into with the Salesforce CLI (`sf org login web --alias my-org`).
+ * Handy for local development: no connected app or secrets needed.
+ *
+ * The token comes from `sf org auth show-access-token`, the instance URL from `sf org display`
+ * (which no longer returns tokens). Both run without a shell. On a 401 the CLI is asked again;
+ * it refreshes the token itself.
+ */
+export declare function sfCli(options?: SfCliOptions): AuthProvider;
+//#endregion
+//#region src/api-version.d.ts
+/** `true` for a version such as `"v66.0"`. */
+export declare function isApiVersion(value: unknown): value is ApiVersion;
+/**
+ * Accepts the ways people write an API version (`"66"`, `"66.0"`, `"v66"`, `"v66.0"`) and
+ * returns the canonical form (`"v66.0"`), or `undefined` when the input is not a version.
+ */
+export declare function normalizeApiVersion(input: string): ApiVersion | undefined;
+//#endregion
+//#region src/http/fetch-transport.d.ts
+interface FetchTransportOptions {
+  /** A custom `fetch` implementation. Defaults to `globalThis.fetch`. */
+  fetch?: typeof fetch;
+}
+/** The default transport, built on the platform `fetch` (Node.js 20+). Supports streaming. */
+export declare function fetchTransport(options?: FetchTransportOptions): HttpTransport;
+//#endregion
+//#region src/errors.d.ts
+interface SalesforceErrorDetails {
+  status: number;
+  method: HttpMethod;
+  /**
+   * The request path without the query string (query strings can hold SOQL with personal data).
+   * Note that Salesforce's own error `message` may still quote parts of the query.
+   */
+  path: string;
+  body: unknown;
+  headers: Record<string, string>;
+}
+/** Thrown for every non-2xx Salesforce REST response. */
+export declare class SalesforceError extends Error {
+  readonly name: string;
+  readonly status: number;
+  readonly method: HttpMethod;
+  readonly path: string;
+  /** The `errorCode` of the first error, e.g. `"MALFORMED_QUERY"` or `"INVALID_FIELD"`. */
+  readonly errorCode: SalesforceErrorCode | undefined;
+  /** All errors Salesforce returned, when the body was the standard error array. */
+  readonly errors: RestError[];
+  /** The parsed response body. */
+  readonly body: unknown;
+  /** Response headers, without `set-cookie`. */
+  readonly headers: Record<string, string>;
+  /** The value of the `Sforce-Limit-Info` header, e.g. `"api-usage=18/15000"`. */
+  readonly limitInfo: string | undefined;
+  constructor(details: SalesforceErrorDetails);
+}
+/** Thrown when an OAuth token request fails. Never contains secrets or tokens. */
+export declare class SalesforceAuthError extends Error {
+  readonly name: string;
+  readonly status: number | undefined;
+  /** The OAuth `error` code, e.g. `"invalid_client"` or `"invalid_grant"`. */
+  readonly error: string | undefined;
+  readonly errorDescription: string | undefined;
+  constructor(message: string, details?: {
+    status?: number;
+    error?: string;
+    errorDescription?: string;
+  });
+}
+/**
+ * Thrown when a call returned HTTP 2xx but one or more items reported `success: false`
+ * (record create, sObject collections, invocable actions, ...).
+ */
+export declare class SalesforceSaveError<TResult = unknown> extends Error {
+  readonly name: string;
+  /** Every item result, including the successful ones. */
+  readonly results: TResult[];
+  /** The errors of all failed items, flattened. */
+  readonly errors: SaveError[];
+  constructor(message: string, results: TResult[], errors: SaveError[]);
+}
+/** Thrown when a Bulk API 2.0 job ends in `Failed` or `Aborted`, or does not finish in time. */
+export declare class SalesforceBulkJobError extends Error {
+  readonly name: string;
+  readonly jobId: string;
+  readonly state: string;
+  readonly jobInfo: unknown;
+  constructor(message: string, jobId: string, state: string, jobInfo: unknown);
+}
+/**
+ * `true` when `error` is a `SalesforceError` (non-2xx response), optionally with `code` as one of
+ * its error codes.
+ */
+export declare function isSalesforceError(error: unknown, code?: SalesforceErrorCode): error is SalesforceError;
+/**
+ * `true` when `error` carries error code `code`: a `SalesforceError` from a failed request, or a
+ * `SalesforceSaveError` with a failed item (save results, collections, actions). Handy for
+ * `catch` blocks and retry decisions, e.g. `hasErrorCode(error, "UNABLE_TO_LOCK_ROW")`.
+ */
+export declare function hasErrorCode(error: unknown, code: SalesforceErrorCode): boolean;
+/**
+ * Thrown when a call split into several requests (chunked collections, batched events) fails
+ * after earlier chunks already succeeded. `completedResults` holds the results of those chunks,
+ * which Salesforce has committed; `cause` is the error of the failing chunk.
+ */
+export declare class SalesforcePartialFailureError<TResult = unknown> extends Error {
+  readonly name: string;
+  readonly completedResults: TResult[];
+  readonly cause: unknown;
+  constructor(message: string, completedResults: TResult[], cause: unknown);
+}
+//#endregion
+//#region src/http/multipart.d.ts
+interface MultipartPart {
+  /** The form field name, e.g. `entity_content` or `VersionData`. */
+  name: string;
+  filename?: string;
+  contentType: string;
+  data: string | Uint8Array;
+}
+/**
+ * Builds a `multipart/form-data` body as bytes, so it can go through any transport without
+ * FormData support.
+ */
+export declare function buildMultipart(parts: readonly MultipartPart[], boundary?: string): {
+  body: Uint8Array;
+  contentType: string;
+};
+//#endregion
+//#region src/resources/csv.d.ts
+interface CsvOptions {
+  delimiter?: string;
+  lineEnding?: BulkLineEnding;
+}
+/**
+ * Serializes records to Bulk API CSV. Columns are the union of all keys in first-seen order.
+ * `null` becomes `#N/A` (clears the field), `undefined` stays empty (leaves it unchanged),
+ * `Date` becomes an ISO string (a Date field takes its UTC date), the text `"#N/A"` is written so
+ * that it is stored as text rather than as null, and one level of nesting becomes a relationship column, so
+ * `{ Account: { External_Id__c: "A1" } }` is written as column `Account.External_Id__c`.
+ */
+export declare function toCsv(records: readonly object[], options?: CsvOptions): string;
+/**
+ * An incremental RFC 4180 CSV parser: feed it text chunks with `push` and it returns the rows
+ * completed so far. Quotes, escaped quotes and CRLF may be split across chunks.
+ *
+ * A truly blank line is returned as an empty array (`[]`), so it can be told apart from a row
+ * with one empty value (`[""]`, e.g. a quoted `""` in a single-column file).
+ */
+export declare class CsvRowParser {
+  private readonly _delimiter;
+  private _row;
+  private _field;
+  private _inQuotes;
+  /** The current field was quoted, so it exists even when empty. */
+  private _fieldQuoted;
+  /** A `"` was seen inside quotes; the next character decides whether it was an escaped quote. */
+  private _quotePending;
+  /** The last row ended with `\r`; a following `\n` belongs to it. */
+  private _skipLineFeed;
+  private _started;
+  constructor(_delimiter?: string);
+  /** Parses a chunk and returns the rows it completed. */
+  push(chunk: string): string[][];
+  /** Finishes parsing and returns the last row, if any. */
+  end(): string[][];
+  private consume;
+  private consumeUnquoted;
+}
+/** Parses CSV (RFC 4180: quoted fields, escaped quotes, CRLF or LF) into rows of strings. */
+export declare function parseCsvRows(text: string, delimiter?: string): string[][];
+/**
+ * Parses streamed CSV (with a header row) into objects keyed by column name, yielding each row
+ * as soon as it is complete.
+ */
+export declare function parseCsvStream(chunks: AsyncIterable<Uint8Array>, delimiter?: string): AsyncGenerator<Record<string, string>, void, undefined>;
+/** Parses CSV with a header row into objects keyed by column name. */
+export declare function parseCsv(text: string, delimiter?: string): Record<string, string>[];
+//#endregion
+export type { AccessToken, ActionDescribe, ActionParameterDescribe, ActionSummary, ApexLogEntry, ApexRestRequest, ApiUsage, ApiVersion, ApiVersionInfo, ApprovalProcessInfo, ApprovalResult, AuthContext, AuthProvider, BulkColumnDelimiter, BulkCsvRecord, BulkIngestJobOptions, BulkIngestOperation, BulkIngestOptions, BulkIngestRecord, BulkJobInfo, BulkJobState, BulkLineEnding, BulkQueryOperation, BulkQueryOptions, CaptureLogsOptions, CaptureLogsResult, ChildRelationship, ChildRelationshipName, ChildSObjectName, ClientCredentialsOptions, CollectionOptions, CompositeBatchRequest, CompositeBatchResult, CompositeBatchSubrequest, CompositeGraphInput, CompositeGraphResult, CompositeMethod, CompositeOptions, CompositeRawSubrequest, CompositeRef, CompositeSubrequest, CompositeSubrequestResult, ConnectionOptions, CsvOptions, CustomActionType, DebugLevels, DecisionOptions, DeleteResult, DeletedRecordsResult, DescribeGlobalResult, DescribeGlobalSObject, DescribeSObjectResult, ExecuteAnonymousOptions, ExecuteAnonymousResult, ExternalIdField, FetchTransportOptions, FieldDescribe, FieldKind, FieldKindName, FieldType, FileShareType, FileVisibility, GenericRecord, GenericRegistry, HttpMethod, HttpTransport, InvocableActionResult, InvokeOptions, InvokeQuickActionOptions, JwtBearerOptions, KnownOrgLimit, KnownSalesforceErrorCode, LimitInfo, LogLevel, MultiPicklistField, MultipartPart, NestPath, NewVersionOptions, NoSelection, OAuthTokenResponse, ObjectInfo, OrgLimits, ParameterizedSearchRequest, ParameterizedSearchSObject, ParentPath, ParentPathTarget, ParentRelationshipName, ParentSObjectName, PathTarget, PendingApprovalWorkItem, PicklistEntry, PicklistOption, PicklistValue, PicklistValues, PlatformEventName, PolymorphicName, PolymorphicNameField, PolymorphicRelationshipName, PolymorphicTargets, PublishOptions, PublishResult, QueryCursor, QueryOptions, QueryParamValue, QueryPlan, QueryResponse, QueryResult, QuickActionDescribe, QuickActionResult, QuickActionSummary, RecordAttributes, RecordCountResult, RecordTypeInfo, RecordTypeName, RefreshTokenOptions, ReportDataCell, ReportDescribe, ReportExtendedMetadata, ReportFact, ReportFilter, ReportInstance, ReportMetadata, ReportResult, ReportRow, ReportSummary, RequestEvent, RequestHooks, RequestSignal, ResponseEvent, ResponseType, RestError, RestRequest, RestResponse, RetryOptions, RunCommand, RunReportOptions, RunTestsRequest, RunTestsResult, SObjectBasicInfo, SObjectCreateInput, SObjectFieldName, SObjectName, SObjectRecord, SObjectRegistryEntry, SObjectUpdateInput, SalesforceAddress, SalesforceClientOptions, SalesforceErrorCode, SalesforceGeolocation, SaveError, SaveResult, SearchResult, SearchSuggestionsOptions, SearchSuggestionsResult, SfCliOptions, SoqlChildQueryResult, SoqlComparisonOperator, SoqlDirection, SoqlFieldValue, SoqlFixedDateLiteral, SoqlLiteral, SoqlNullOrder, SoqlOperator, SoqlOperatorFor, SoqlQueryRecord, SoqlRelativeDateLiteral, SoqlScalar, SoqlValue, SoqlWhereValue, StreamingTransportResponse, SubmitOptions, SubrequestOptions, TransportRequest, TransportResponse, TreeChildRecord, TreeRecord, TreeSaveResult, TypedRecord, UiFieldInfo, UiFieldValue, UiLayout, UiLayoutComponent, UiLayoutOptions, UiRecord, UiRecordFields, UiRecordOptions, UiRecordTypeInfo, UpdatedRecordsResult, UploadFileOptions, UploadedFile, UpsertOutcome, UpsertResult, WaitForReportOptions, WaitOptions, WithAttributes };
+//# sourceMappingURL=index.d.mts.map