@salesforce/vscode-services 65.2.0

package/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2025 Salesforce, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+3. Neither the name of Salesforce nor the names of its contributors may be
+used to endorse or promote products derived from this software without specific
+prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY SALESFORCE AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL SALESFORCE OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,92 @@
+# @salesforce/vscode-services
+
+TypeScript type definitions for the Salesforce VS Code Services extension API.
+
+## Overview
+
+This package provides TypeScript type definitions for consuming the Salesforce VS Code Services extension API. It contains only type declarations (`.d.ts` files) with no runtime code, making it lightweight and suitable for type-checking during development.
+
+## Installation
+
+```bash
+npm install --save-dev @salesforce/vscode-services
+```
+
+## Usage
+
+Import the type definitions in your VS Code extension to get type safety when consuming the Salesforce Services API:
+
+```typescript
+import type { SalesforceVSCodeServicesApi } from '@salesforce/vscode-services';
+import * as vscode from 'vscode';
+
+// Get the Salesforce Services extension API with proper typing
+const extension = vscode.extensions.getExtension('salesforce.salesforcedx-vscode-services');
+const api: SalesforceVSCodeServicesApi | undefined = extension?.exports;
+
+if (api) {
+  // Access services with full type support
+  const { ConnectionService, ProjectService, ChannelService } = api.services;
+
+  // Use the services in your extension
+  // All methods and properties are fully typed
+}
+```
+
+### Example: Using Services in Your Extension
+
+```typescript
+import type { SalesforceVSCodeServicesApi } from '@salesforce/vscode-services';
+import * as vscode from 'vscode';
+
+export const activate = async (context: vscode.ExtensionContext) => {
+  const sfServices = vscode.extensions.getExtension<SalesforceVSCodeServicesApi>(
+    'salesforce.salesforcedx-vscode-services'
+  );
+
+  if (!sfServices?.exports) {
+    throw new Error('Salesforce Services extension not available');
+  }
+
+  const { services } = sfServices.exports;
+
+  // Now you have access to all services with full type safety
+  // services.ConnectionService
+  // services.ProjectService
+  // services.ChannelService
+  // services.WorkspaceService
+  // ... and more
+};
+```
+
+## What's Included
+
+This package exports:
+
+- **`SalesforceVSCodeServicesApi`** - The complete type definition for the extension's public API
+  - Includes type definitions for all service classes
+  - Provides access to service tags and implementations
+  - Fully typed method signatures and return types
+
+**All internal implementation details are protected.** The package uses Node.js `exports` field to restrict imports to only the main entry point. You cannot directly import internal types or constants.
+
+## Package Contents
+
+This package bundles:
+
+- Type definitions for the public API
+- Type definitions for all transitive dependencies
+- No runtime code or JavaScript files
+
+## Development
+
+This package is automatically generated from the source code of the `salesforcedx-vscode-services` extension. Types and dependency versions are kept in sync with the parent package.
+
+## License
+
+BSD-3-Clause
+
+## Support
+
+For issues or questions, please file an issue at:
+<https://github.com/forcedotcom/salesforcedx-vscode/issues>

package/out/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const sampleProjectName = "MyProject";
+export declare const CODE_BUILDER_WEB_SECTION = "salesforcedx-vscode-code-builder-web";
+export declare const SALESFORCE_DX_SECTION = "salesforcedx-vscode-salesforcedx";
+export declare const INSTANCE_URL_KEY = "instanceUrl";
+export declare const ACCESS_TOKEN_KEY = "accessToken";
+export declare const API_VERSION_KEY = "apiVersion";
+//# sourceMappingURL=constants.d.ts.map

package/out/core/configService.d.ts

@@ -0,0 +1,14 @@
+import { ConfigAggregator } from '@salesforce/core/configAggregator';
+import * as Effect from 'effect/Effect';
+import { WorkspaceService } from '../vscode/workspaceService';
+declare const ConfigService_base: Effect.Service.Class<ConfigService, "ConfigService", {
+    readonly succeed: {
+        /** Get a ConfigAggregator for the current workspace */
+        readonly getConfigAggregator: Effect.Effect<ConfigAggregator, Error, WorkspaceService>;
+    };
+    readonly dependencies: readonly [import("effect/Layer").Layer<WorkspaceService, never, never>];
+}>;
+export declare class ConfigService extends ConfigService_base {
+}
+export {};
+//# sourceMappingURL=configService.d.ts.map

package/out/core/connectionService.d.ts

@@ -0,0 +1,15 @@
+import { Connection } from '@salesforce/core';
+import * as Effect from 'effect/Effect';
+import { SettingsService } from '../vscode/settingsService';
+import { ConfigService } from './configService';
+declare const ConnectionService_base: Effect.Service.Class<ConnectionService, "ConnectionService", {
+    readonly effect: Effect.Effect<{
+        /** Get a Connection to the target org */
+        readonly getConnection: Effect.Effect<Connection<import("@jsforce/jsforce-node").Schema>, Error, import("../vscode/workspaceService").WorkspaceService | ConfigService | SettingsService>;
+    }, never, never>;
+    readonly dependencies: readonly [import("effect/Layer").Layer<SettingsService, never, never>, import("effect/Layer").Layer<ConfigService, never, never>];
+}>;
+export declare class ConnectionService extends ConnectionService_base {
+}
+export {};
+//# sourceMappingURL=connectionService.d.ts.map

package/out/core/defaultOrgService.d.ts

@@ -0,0 +1,24 @@
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+export declare const DefaultOrgInfoSchema: Schema.Struct<{
+    orgId: Schema.optional<typeof Schema.String>;
+    devHubOrgId: Schema.optional<typeof Schema.String>;
+    username: Schema.optional<typeof Schema.String>;
+    devHubUsername: Schema.optional<typeof Schema.String>;
+    tracksSource: Schema.optional<typeof Schema.Boolean>;
+    isScratch: Schema.optional<typeof Schema.Boolean>;
+    isSandbox: Schema.optional<typeof Schema.Boolean>;
+}>;
+export declare const defaultOrgRef: SubscriptionRef.SubscriptionRef<{
+    readonly orgId?: string | undefined;
+    readonly devHubOrgId?: string | undefined;
+    readonly isSandbox?: boolean | undefined;
+    readonly isScratch?: boolean | undefined;
+    readonly tracksSource?: boolean | undefined;
+    readonly username?: string | undefined;
+    readonly devHubUsername?: string | undefined;
+}>;
+/** watch the global and local sf/config.json files; clear the defaultOrgRef when they change */
+export declare const watchConfigFiles: () => Effect.Effect<void, Error>;
+//# sourceMappingURL=defaultOrgService.d.ts.map

package/out/core/metadataDescribeService.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigService } from './configService';
+import type { DescribeMetadataObject } from './schemas/describeMetadataObject';
+import type { SettingsService } from '../vscode/settingsService';
+import type { WorkspaceService } from '../vscode/workspaceService';
+import * as Effect from 'effect/Effect';
+import type { DescribeSObjectResult } from 'jsforce';
+import { ChannelService } from '../vscode/channelService';
+import { ConnectionService } from './connectionService';
+import { type FileProperties } from './schemas/fileProperties';
+type DescribeContext = ConnectionService | ConfigService | WorkspaceService | ChannelService | SettingsService;
+declare const MetadataDescribeService_base: Effect.Service.Class<MetadataDescribeService, "MetadataDescribeService", {
+    readonly effect: Effect.Effect<{
+        /**
+         * Performs a Metadata API describe and returns the result.
+         * When forceRefresh=true, bypasses the cache and makes a fresh API call.
+         */
+        readonly describe: (forceRefresh?: boolean) => Effect.Effect<readonly DescribeMetadataObject[], Error, DescribeContext>;
+        /**
+         * Calls the Metadata API list method for a given type and optional folder.
+         * Returns the list of metadata components for that type.
+         */
+        readonly listMetadata: (type: string, folder?: string) => Effect.Effect<readonly FileProperties[], Error, DescribeContext>;
+        readonly describeCustomObject: (objectName: string) => Effect.Effect<DescribeSObjectResult, Error, DescribeContext>;
+    }, never, never>;
+    readonly dependencies: readonly [import("effect/Layer").Layer<ConnectionService, never, never>];
+}>;
+export declare class MetadataDescribeService extends MetadataDescribeService_base {
+}
+export {};
+//# sourceMappingURL=metadataDescribeService.d.ts.map

package/out/core/metadataRegistryService.d.ts

@@ -0,0 +1,15 @@
+import { type MetadataRegistry, RegistryAccess } from '@salesforce/source-deploy-retrieve';
+import * as Effect from 'effect/Effect';
+import { WorkspaceService } from '../vscode/workspaceService';
+declare const MetadataRegistryService_base: Effect.Service.Class<MetadataRegistryService, "MetadataRegistryService", {
+    readonly scoped: Effect.Effect<{
+        /** Get the metadata registry (cached) */
+        readonly getRegistry: () => Effect.Effect<Readonly<MetadataRegistry>, Error, WorkspaceService>;
+        /** Get the registry access (cached) */
+        readonly getRegistryAccess: () => Effect.Effect<RegistryAccess, Error, WorkspaceService>;
+    }, never, never>;
+}>;
+export declare class MetadataRegistryService extends MetadataRegistryService_base {
+}
+export {};
+//# sourceMappingURL=metadataRegistryService.d.ts.map

package/out/core/metadataRetrieveService.d.ts

@@ -0,0 +1,26 @@
+import { type RetrieveResult, type MetadataMember, ComponentSet } from '@salesforce/source-deploy-retrieve';
+import * as Effect from 'effect/Effect';
+import { SuccessfulCancelResult } from '../vscode/cancellation';
+import { SettingsService } from '../vscode/settingsService';
+import { WorkspaceService } from '../vscode/workspaceService';
+import { ConfigService } from './configService';
+import { ConnectionService } from './connectionService';
+import { MetadataRegistryService } from './metadataRegistryService';
+import { ProjectService } from './projectService';
+import { SourceTrackingService } from './sourceTrackingService';
+declare const MetadataRetrieveService_base: Effect.Service.Class<MetadataRetrieveService, "MetadataRetrieveService", {
+    readonly succeed: {
+        /**
+         * Retrieve one or more metadata components from the default org.
+         * @param members - Array of MetadataMember (type, fullName)
+         * @returns Effect that resolves to SDR's RetrieveResult
+         */
+        readonly retrieve: (members: MetadataMember[]) => Effect.Effect<RetrieveResult | SuccessfulCancelResult, Error, ConnectionService | ProjectService | WorkspaceService | ConfigService | SettingsService | MetadataRegistryService | SourceTrackingService>;
+        readonly buildComponentSet: (members: MetadataMember[]) => Effect.Effect<ComponentSet, Error, MetadataRegistryService | WorkspaceService>;
+        readonly buildComponentSetFromSource: (members: MetadataMember[], sourcePaths: string[]) => Effect.Effect<ComponentSet, Error, MetadataRegistryService | WorkspaceService>;
+    };
+}>;
+export declare class MetadataRetrieveService extends MetadataRetrieveService_base {
+}
+export {};
+//# sourceMappingURL=metadataRetrieveService.d.ts.map

package/out/core/projectService.d.ts

@@ -0,0 +1,16 @@
+import { SfProject } from '@salesforce/core/project';
+import * as Effect from 'effect/Effect';
+import { WorkspaceService } from '../vscode/workspaceService';
+declare const ProjectService_base: Effect.Service.Class<ProjectService, "ProjectService", {
+    readonly succeed: {
+        /** Check if we're in a Salesforce project (sfdx-project.json exists) */
+        readonly isSalesforceProject: Effect.Effect<boolean, never, WorkspaceService>;
+        /** Get the SfProject instance for the workspace (fails if not a Salesforce project) */
+        readonly getSfProject: Effect.Effect<SfProject, Error, WorkspaceService>;
+    };
+    readonly dependencies: readonly [import("effect/Layer").Layer<WorkspaceService, never, never>];
+}>;
+export declare class ProjectService extends ProjectService_base {
+}
+export {};
+//# sourceMappingURL=projectService.d.ts.map

package/out/core/schemas/describeMetadataObject.d.ts

@@ -0,0 +1,12 @@
+import * as S from 'effect/Schema';
+declare const DescribeMetadataObjectSchema: S.Struct<{
+    childXmlNames: S.Array$<typeof S.String>;
+    directoryName: typeof S.String;
+    inFolder: typeof S.Boolean;
+    metaFile: typeof S.Boolean;
+    suffix: S.optional<S.Union<[typeof S.String, typeof S.Null]>>;
+    xmlName: typeof S.String;
+}>;
+export type DescribeMetadataObject = S.Schema.Type<typeof DescribeMetadataObjectSchema>;
+export {};
+//# sourceMappingURL=describeMetadataObject.d.ts.map

package/out/core/schemas/fileProperties.d.ts

@@ -0,0 +1,18 @@
+import * as S from 'effect/Schema';
+/** Schema for FileProperties (metadata.list result) */
+export declare const FilePropertiesSchema: S.Struct<{
+    fullName: typeof S.String;
+    type: typeof S.String;
+    id: S.optional<typeof S.String>;
+    createdById: S.optional<typeof S.String>;
+    createdByName: S.optional<typeof S.String>;
+    createdDate: S.optional<typeof S.String>;
+    fileName: S.optional<typeof S.String>;
+    lastModifiedById: S.optional<typeof S.String>;
+    lastModifiedByName: S.optional<typeof S.String>;
+    lastModifiedDate: S.optional<typeof S.String>;
+    manageableState: S.optional<typeof S.String>;
+    namespacePrefix: S.optional<typeof S.String>;
+}>;
+export type FileProperties = S.Schema.Type<typeof FilePropertiesSchema>;
+//# sourceMappingURL=fileProperties.d.ts.map

package/out/core/shared.d.ts

@@ -0,0 +1,5 @@
+import { Org, Connection, ConfigAggregator } from '@salesforce/core';
+import * as Effect from 'effect/Effect';
+/** passing in a configAggregator is highly recommended to avoid sfdx-core creating a new one  */
+export declare const getOrgFromConnection: (connection: Connection, aggregator?: ConfigAggregator) => Effect.Effect<Org, Error>;
+//# sourceMappingURL=shared.d.ts.map

package/out/core/sourceTrackingService.d.ts

@@ -0,0 +1,20 @@
+import type { RetrieveResult } from '@salesforce/source-deploy-retrieve';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { SettingsService } from '../vscode/settingsService';
+import { WorkspaceService } from '../vscode/workspaceService';
+import { ConfigService } from './configService';
+import { ConnectionService } from './connectionService';
+import { MetadataRegistryService } from './metadataRegistryService';
+import { ProjectService } from './projectService';
+declare const SourceTrackingService_base: Effect.Service.Class<SourceTrackingService, "SourceTrackingService", {
+    readonly succeed: {
+        readonly getSourceTracking: Effect.Effect<import("@salesforce/source-tracking").SourceTracking, Error, WorkspaceService | ConfigService | SettingsService | ConnectionService | MetadataRegistryService | ProjectService>;
+        readonly updateTrackingFromRetrieve: (result: RetrieveResult) => Effect.Effect<void, Error>;
+    };
+    readonly dependencies: readonly [Layer.Layer<ConnectionService, never, never>, Layer.Layer<ProjectService, never, never>, Layer.Layer<ConfigService, never, never>, Layer.Layer<SettingsService, never, never>, Layer.Layer<WorkspaceService, never, never>, Layer.Layer<MetadataRegistryService, never, never>];
+}>;
+export declare class SourceTrackingService extends SourceTrackingService_base {
+}
+export {};
+//# sourceMappingURL=sourceTrackingService.d.ts.map

package/out/extensionScope.d.ts

@@ -0,0 +1,5 @@
+import * as Effect from 'effect/Effect';
+import * as Scope from 'effect/Scope';
+export declare const getExtensionScope: () => Effect.Effect<Scope.CloseableScope, Error, never>;
+export declare const closeExtensionScope: () => Effect.Effect<void, Error, never>;
+//# sourceMappingURL=extensionScope.d.ts.map

package/out/index.d.ts

@@ -0,0 +1,41 @@
+import * as vscode from 'vscode';
+import { ConfigService } from './core/configService';
+import { ConnectionService } from './core/connectionService';
+import { defaultOrgRef } from './core/defaultOrgService';
+import { MetadataDescribeService } from './core/metadataDescribeService';
+import { MetadataRegistryService } from './core/metadataRegistryService';
+import { MetadataRetrieveService } from './core/metadataRetrieveService';
+import { ProjectService } from './core/projectService';
+import { SourceTrackingService } from './core/sourceTrackingService';
+import { SdkLayer } from './observability/spans';
+import { ChannelServiceLayer, ChannelService } from './vscode/channelService';
+import { FsService } from './vscode/fsService';
+import { SettingsService } from './vscode/settingsService';
+import { WorkspaceService } from './vscode/workspaceService';
+export type SalesforceVSCodeServicesApi = {
+    services: {
+        ConnectionService: typeof ConnectionService;
+        ProjectService: typeof ProjectService;
+        ChannelService: typeof ChannelService;
+        ChannelServiceLayer: typeof ChannelServiceLayer;
+        WorkspaceService: typeof WorkspaceService;
+        FsService: typeof FsService;
+        ConfigService: typeof ConfigService;
+        MetadataDescribeService: typeof MetadataDescribeService;
+        MetadataRegistryService: typeof MetadataRegistryService;
+        MetadataRetrieveService: typeof MetadataRetrieveService;
+        SourceTrackingService: typeof SourceTrackingService;
+        SettingsService: typeof SettingsService;
+        SdkLayer: typeof SdkLayer;
+        TargetOrgRef: typeof defaultOrgRef;
+    };
+};
+/**
+ * Activates the Salesforce Services extension and returns API for other extensions to consume
+ * Both service tags/types and their default Live implementations are exported.
+ * Consumers should get both from the API, not via direct imports.
+ */
+export declare const activate: (context: vscode.ExtensionContext) => Promise<SalesforceVSCodeServicesApi>;
+/** Deactivates the Salesforce Services extension */
+export declare const deactivate: () => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/out/observability/appInsights.d.ts

@@ -0,0 +1,4 @@
+/** instrumention key / connection string for test-otel-effect */
+export declare const DEFAULT_AI_CONNECTION_STRING = "InstrumentationKey=f5cbbeba-e06b-4657-b99c-62024c9d36bf;IngestionEndpoint=https://eastus-8.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/;ApplicationId=1485438c-5495-43dc-8c0a-b51e860b6cba";
+export declare const isTelemetryExtensionConfigurationEnabled: () => boolean;
+//# sourceMappingURL=appInsights.d.ts.map

package/out/observability/applicationInsightsWebExporter.d.ts

@@ -0,0 +1,16 @@
+import { ExportResult } from '@opentelemetry/core';
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { TelemetryReporter } from '@vscode/extension-telemetry';
+export declare const getWebAppInsightsReporter: () => TelemetryReporter;
+/**
+ * Custom OpenTelemetry span exporter that sends telemetry to Application Insights
+ * using the web SDK since @azure/monitor-opentelemetry-exporter doesn't work in browsers.
+ *
+ * Maps all OpenTelemetry spans to Application Insights Dependencies for consistency
+ * with the Node SDK behavior.
+ */
+export declare class ApplicationInsightsWebExporter implements SpanExporter {
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=applicationInsightsWebExporter.d.ts.map

package/out/observability/localTracing.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get local traces enabled setting.  Sends traces to a locally running docker container.
+ * See setting description for how to use
+ */
+export declare const getLocalTracesEnabled: () => boolean;
+/** export spans/traces to console (browser or nodejs) */
+export declare const getConsoleTracesEnabled: () => boolean;
+export declare const getOptionalBooleanConfiguration: (section: string) => (configName: string) => boolean;
+//# sourceMappingURL=localTracing.d.ts.map

package/out/observability/spanTransformProcessor.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '@opentelemetry/api';
+import { Span, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+/** Custom span processor that transforms spans before they're exported */
+export declare class SpanTransformProcessor extends BatchSpanProcessor {
+    onStart(span: Span, parentContext: Context): void;
+}
+//# sourceMappingURL=spanTransformProcessor.d.ts.map

package/out/observability/spans.d.ts

@@ -0,0 +1,2 @@
+export declare const SdkLayer: import("effect/Layer").Layer<import("@effect/opentelemetry/Resource").Resource, never, never>;
+//# sourceMappingURL=spans.d.ts.map

package/out/observability/spansNode.d.ts

@@ -0,0 +1,2 @@
+export declare const NodeSdkLayer: import("effect/Layer").Layer<import("@effect/opentelemetry/Resource").Resource, never, never>;
+//# sourceMappingURL=spansNode.d.ts.map

package/out/observability/spansWeb.d.ts

@@ -0,0 +1,2 @@
+export declare const WebSdkLayer: import("effect/Layer").Layer<import("@effect/opentelemetry/Resource").Resource, never, never>;
+//# sourceMappingURL=spansWeb.d.ts.map

package/out/virtualFsProvider/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const fsPrefix = "memfs";
+//# sourceMappingURL=constants.d.ts.map

package/out/virtualFsProvider/fileSystemProvider.d.ts

@@ -0,0 +1,28 @@
+import * as vscode from 'vscode';
+/**
+ * the VSCode API doesn't store these anywhere by default.
+ * This is hooked up to memfs right now, and its watcher handles everything else
+ */
+export declare class FsProvider implements vscode.FileSystemProvider {
+    readonly onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]>;
+    exists(uri: vscode.Uri): boolean;
+    stat(uri: vscode.Uri): vscode.FileStat;
+    readDirectory(uri: vscode.Uri): [string, vscode.FileType][];
+    createDirectory(uri: vscode.Uri): Promise<void>;
+    readFile(uri: vscode.Uri): Uint8Array;
+    writeFile(uri: vscode.Uri, content: Uint8Array, options: {
+        create: boolean;
+        overwrite: boolean;
+    }): Promise<void>;
+    delete(uri: vscode.Uri, options: {
+        recursive: boolean;
+    }): Promise<void>;
+    rename(oldUri: vscode.Uri, newUri: vscode.Uri, options: {
+        overwrite: boolean;
+    }): Promise<void>;
+    watch(_uri: vscode.Uri, _options: {
+        recursive: boolean;
+        excludes: string[];
+    }): vscode.Disposable;
+}
+//# sourceMappingURL=fileSystemProvider.d.ts.map

package/out/virtualFsProvider/fsTypes.d.ts

@@ -0,0 +1,25 @@
+import * as vscode from 'vscode';
+export type fsProvider = vscode.FileSystemProvider & {
+    /** does not exist in the vscode.FileSystemProvider but super handy so I added it*/
+    exists: (uri: vscode.Uri) => boolean;
+};
+type SerializedFile = vscode.FileStat & {
+    type: vscode.FileType.File;
+    data: string;
+};
+type SerializedDirectory = vscode.FileStat & {
+    type: vscode.FileType.Directory;
+    entries: Record<string, SerializedEntry>;
+};
+type SerializedEntry = SerializedFile | SerializedDirectory;
+export declare const isSerializedDirectoryWithPath: (entry: SerializedEntryWithPath) => entry is SerializedDirectoryWithPath;
+export type SerializedFileWithPath = SerializedFile & {
+    path: string;
+};
+type SerializedDirectoryWithPath = SerializedDirectory & {
+    path: string;
+};
+export type SerializedEntryWithPath = SerializedFileWithPath | SerializedDirectoryWithPath;
+export declare const isSerializedFileWithPath: (entry: SerializedEntryWithPath) => entry is SerializedFileWithPath;
+export {};
+//# sourceMappingURL=fsTypes.d.ts.map

package/out/virtualFsProvider/indexedDbStorage.d.ts

@@ -0,0 +1,19 @@
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+declare const IndexedDBStorageService_base: Effect.Service.Class<IndexedDBStorageService, "IndexedDBStorageService", {
+    readonly scoped: Effect.Effect<{
+        /** Load state from IndexedDB into memfs */
+        readonly loadState: () => Effect.Effect<void, Error>;
+        /** Save a file to IndexedDB */
+        readonly saveFile: (path: string) => Effect.Effect<void, Error>;
+        /** Delete a file from IndexedDB */
+        readonly deleteFile: (path: string) => Effect.Effect<void, Error>;
+        /** Load a specific file from IndexedDB */
+        readonly loadFile: (path: string) => Effect.Effect<void, Error>;
+    }, Error, import("effect/Scope").Scope>;
+}>;
+export declare class IndexedDBStorageService extends IndexedDBStorageService_base {
+}
+export declare const IndexedDBStorageServiceShared: Layer.Layer<IndexedDBStorageService, Error, import("effect/Scope").Scope>;
+export {};
+//# sourceMappingURL=indexedDbStorage.d.ts.map

package/out/virtualFsProvider/memfsWatcher.d.ts

@@ -0,0 +1,8 @@
+import * as Effect from 'effect/Effect';
+import * as vscode from 'vscode';
+import { ChannelService } from '../vscode/channelService';
+import { IndexedDBStorageService } from './indexedDbStorage';
+export declare const emitter: vscode.EventEmitter<vscode.FileChangeEvent[]>;
+/** Starts watching the memfs for file changes */
+export declare const startWatch: () => Effect.Effect<void, Error, ChannelService | IndexedDBStorageService>;
+//# sourceMappingURL=memfsWatcher.d.ts.map

package/out/virtualFsProvider/projectInit.d.ts

@@ -0,0 +1,6 @@
+import * as Effect from 'effect/Effect';
+import { SettingsService } from '../vscode/settingsService';
+import { fsProvider } from './fsTypes';
+/** Creates the files for an empty sfdx project */
+export declare const projectFiles: (fsp: fsProvider) => Effect.Effect<void, Error, SettingsService>;
+//# sourceMappingURL=projectInit.d.ts.map

package/out/virtualFsProvider/templates/forceignore.d.ts

@@ -0,0 +1,2 @@
+export declare const forceignore: string[];
+//# sourceMappingURL=forceignore.d.ts.map

package/out/virtualFsProvider/templates/gitignore.d.ts

@@ -0,0 +1,2 @@
+export declare const gitignore: string[];
+//# sourceMappingURL=gitignore.d.ts.map

package/out/virtualFsProvider/templates/jestConfig.d.ts

@@ -0,0 +1,2 @@
+export declare const jestConfig: string[];
+//# sourceMappingURL=jestConfig.d.ts.map

package/out/virtualFsProvider/templates/metadataDirs.d.ts

@@ -0,0 +1,2 @@
+export declare const metadataDirs: string[];
+//# sourceMappingURL=metadataDirs.d.ts.map

package/out/virtualFsProvider/templates/prettierignore.d.ts

@@ -0,0 +1,2 @@
+export declare const prettierignore: string[];
+//# sourceMappingURL=prettierignore.d.ts.map

package/out/virtualFsProvider/templates/prettierrc.d.ts

@@ -0,0 +1,2 @@
+export declare const prettierrc: string[];
+//# sourceMappingURL=prettierrc.d.ts.map

package/out/virtualFsProvider/templates/readme.d.ts

@@ -0,0 +1,2 @@
+export declare const readme: string[];
+//# sourceMappingURL=readme.d.ts.map

package/out/virtualFsProvider/templates/sfdxProject.d.ts

@@ -0,0 +1,2 @@
+export declare const sfdxProjectJson: string[];
+//# sourceMappingURL=sfdxProject.d.ts.map

package/out/virtualFsProvider/templates/templates.d.ts

@@ -0,0 +1,15 @@
+import { metadataDirs } from './metadataDirs';
+/** map of file name to file content */
+export declare const TEMPLATES: {
+    '.vscode/settings.json': string[];
+    '.forceignore': string[];
+    '.gitignore': string[];
+    'sfdx-project.json': string[];
+    '.prettierrc': string[];
+    '.prettierignore': string[];
+    'jest.config.js': string[];
+    'README.md': string[];
+    'tsconfig.json': string[];
+};
+export { metadataDirs };
+//# sourceMappingURL=templates.d.ts.map

package/out/virtualFsProvider/templates/tsconfig.d.ts

@@ -0,0 +1,2 @@
+export declare const tsconfig: string[];
+//# sourceMappingURL=tsconfig.d.ts.map

package/out/virtualFsProvider/templates/vscodeSettings.d.ts

@@ -0,0 +1,2 @@
+export declare const vscodeSettings: string[];
+//# sourceMappingURL=vscodeSettings.d.ts.map

package/out/vscode/cancellation.d.ts

@@ -0,0 +1,4 @@
+import * as Brand from 'effect/Brand';
+/** a branded string type to indicate successful cancellation */
+export type SuccessfulCancelResult = string & Brand.Brand<'SuccessfulCancelResult'>;
+//# sourceMappingURL=cancellation.d.ts.map

package/out/vscode/channelService.d.ts

@@ -0,0 +1,22 @@
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as vscode from 'vscode';
+declare const ChannelService_base: Effect.Service.Class<ChannelService, "ChannelService", {
+    readonly sync: () => {
+        /** Get the OutputChannel for this ChannelService */
+        readonly getChannel: Effect.Effect<vscode.OutputChannel, never, never>;
+        /** Append a message to this OutputChannel */
+        readonly appendToChannel: (message: string) => Effect.Effect<void | undefined, never, never>;
+    };
+}>;
+export declare class ChannelService extends ChannelService_base {
+}
+/**
+ * Factory for a Layer that provides a ChannelService for the given channel name.
+ * Use this in other extensions
+ * Usage:
+ * Layer.provide(ChannelServiceLayer('My Channel'))
+ */
+export declare const ChannelServiceLayer: (channelName: string) => Layer.Layer<ChannelService>;
+export {};
+//# sourceMappingURL=channelService.d.ts.map

package/out/vscode/fsService.d.ts

@@ -0,0 +1,25 @@
+import * as Effect from 'effect/Effect';
+import * as S from 'effect/Schema';
+import * as vscode from 'vscode';
+import { ChannelService } from '../vscode/channelService';
+declare const FsService_base: Effect.Service.Class<FsService, "FsService", {
+    readonly succeed: {
+        readonly readFile: (filePath: string) => Effect.Effect<string, Error, ChannelService>;
+        readonly writeFile: (filePath: string, content: string) => Effect.Effect<void, Error, ChannelService>;
+        readonly fileOrFolderExists: (filePath: string) => Effect.Effect<boolean, Error, ChannelService>;
+        readonly isDirectory: (path: string) => Effect.Effect<boolean, Error, never>;
+        readonly isFile: (path: string) => Effect.Effect<boolean, Error, never>;
+        readonly createDirectory: (dirPath: string) => Effect.Effect<void, Error, never>;
+        readonly deleteFile: (filePath: string, options?: {}) => Effect.Effect<void, Error, never>;
+        readonly readDirectory: (dirPath: string) => Effect.Effect<string[], Error, never>;
+        readonly stat: (filePath: string) => Effect.Effect<vscode.FileStat, Error, never>;
+        readonly safeDelete: (filePath: string, options?: {}) => Effect.Effect<void, Error, never>;
+        readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, Error, never>;
+        readonly readJSON: <A>(filePath: string, schema: S.Schema<A>) => Effect.Effect<A, Error, ChannelService>;
+    };
+    readonly dependencies: readonly [import("effect/Layer").Layer<ChannelService, never, never>];
+}>;
+export declare class FsService extends FsService_base {
+}
+export {};
+//# sourceMappingURL=fsService.d.ts.map

package/out/vscode/settingsService.d.ts

@@ -0,0 +1,47 @@
+import * as Effect from 'effect/Effect';
+declare const SettingsService_base: Effect.Service.Class<SettingsService, "SettingsService", {
+    readonly succeed: {
+        /**
+         * Get a value from settings
+         * @param section The settings section
+         * @param key The settings key
+         * @param defaultValue Optional default value
+         */
+        readonly getValue: <T>(section: string, key: string, defaultValue?: T) => Effect.Effect<T | undefined, Error, never>;
+        /**
+         * Set a value in settings
+         * @param section The settings section
+         * @param key The settings key
+         * @param value The value to set
+         */
+        readonly setValue: <T>(section: string, key: string, value: T) => Effect.Effect<void, Error, never>;
+        /**
+         * Get the Salesforce instance URL from settings
+         */
+        readonly getInstanceUrl: Effect.Effect<string, Error, never>;
+        /**
+         * Get the Salesforce access token from settings
+         */
+        readonly getAccessToken: Effect.Effect<string, Error, never>;
+        /**
+         * Get the Salesforce API version from settings.  In the form of '64.0'
+         */
+        readonly getApiVersion: Effect.Effect<string, Error, never>;
+        /**
+         * Set the Salesforce instance URL in settings
+         */
+        readonly setInstanceUrl: (url: string) => Effect.Effect<void, Error, never>;
+        /**
+         * Set the Salesforce access token in settings
+         */
+        readonly setAccessToken: (token: string) => Effect.Effect<void, Error, never>;
+        /**
+         * Set the Salesforce API version in settings
+         */
+        readonly setApiVersion: (version: string) => Effect.Effect<void, Error, never>;
+    };
+}>;
+export declare class SettingsService extends SettingsService_base {
+}
+export {};
+//# sourceMappingURL=settingsService.d.ts.map

package/out/vscode/workspaceService.d.ts

@@ -0,0 +1,19 @@
+import * as Effect from 'effect/Effect';
+type WorkspaceInfo = {
+    /** includes the file:// or other schemeprefix */
+    path: string;
+    /** the path without the scheme prefix */
+    fsPath: string;
+    isEmpty: boolean;
+    isVirtualFs: boolean;
+};
+declare const WorkspaceService_base: Effect.Service.Class<WorkspaceService, "WorkspaceService", {
+    readonly succeed: {
+        /** Get info about the workspace */
+        readonly getWorkspaceInfo: Effect.Effect<WorkspaceInfo, never, never>;
+    };
+}>;
+export declare class WorkspaceService extends WorkspaceService_base {
+}
+export {};
+//# sourceMappingURL=workspaceService.d.ts.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@salesforce/vscode-services",
+  "version": "65.2.0",
+  "description": "TypeScript type definitions for Salesforce VS Code Services extension API",
+  "author": "Salesforce",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/forcedotcom/salesforcedx-vscode"
+  },
+  "bugs": {
+    "url": "https://github.com/forcedotcom/salesforcedx-vscode/issues"
+  },
+  "homepage": "https://github.com/forcedotcom/salesforcedx-vscode/tree/develop/packages/salesforcedx-vscode-services-types",
+  "types": "out/salesforcedx-vscode-services-types/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./out/salesforcedx-vscode-services-types/src/index.d.ts"
+    }
+  },
+  "files": [
+    "out/**/*.d.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "generate-entry": "ts-node scripts/generateEntry.ts",
+    "sync-deps": "ts-node scripts/syncDeps.ts",
+    "compile": "tsc -p ./",
+    "clean": "shx rm -rf src out node_modules *.tgz"
+  },
+  "dependencies": {
+    "@azure/monitor-opentelemetry-exporter": "^1.0.0-beta.32",
+    "@effect/opentelemetry": "0.58.0",
+    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/core": "2.0.1",
+    "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
+    "@opentelemetry/sdk-logs": "0.203.0",
+    "@opentelemetry/sdk-metrics": "2.0.1",
+    "@opentelemetry/sdk-trace-base": "2.0.1",
+    "@opentelemetry/sdk-trace-node": "2.0.1",
+    "@opentelemetry/sdk-trace-web": "2.0.1",
+    "@salesforce/core": "^8.23.3",
+    "@salesforce/source-deploy-retrieve": "^12.25.0",
+    "@salesforce/source-tracking": "^7.5.0",
+    "effect": "^3.18.4",
+    "jsforce": "^3.10.2",
+    "vscode-uri": "^3.1.0",
+    "@types/vscode": "^1.90.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "shx": "^0.3.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.2"
+  }
+}