@uipath/solution-sdk 1.199.0 → 1.201.0-preview.115

package/dist/src/deployments-auto-install.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Automation Solutions "auto-install" deploy (v2).
+ *
+ * Hand-written wrapper — `POST /api/v2/deployments/auto-install` is not yet in
+ * the committed swagger the generator pulls from, so it isn't in the generated
+ * `DeploymentsApi`. It supersedes the older `POST /api/deployments/deploy`
+ * (generated `deploymentsDeploy`) for feed deploys: unlike that endpoint, it
+ * accepts a caller-chosen `deploymentName` and `solutionRootFolderName`
+ * instead of auto-naming the deployment `AutoDeploy-<solution>`. It is the
+ * same call Studio Web makes for a deploy-only ("packageAndDeploy: false")
+ * flow. Once the v2 path ships in the spec, regenerate and drop this file in
+ * favor of the generated method.
+ */
+/** Auth/endpoint inputs for {@link deploymentsAutoInstall}. */
+export interface AutoInstallClientConfig {
+    /** Tenant-scoped Automation Solutions base path (`.../automationsolutions_`). */
+    basePath: string;
+    accessToken: string;
+}
+/** Body of `POST /api/v2/deployments/auto-install` (mirrors Studio Web). */
+export interface DeploymentAutoInstallRequest {
+    /** Caller-chosen deployment name — the field the v1 auto-deploy endpoint lacked. */
+    deploymentName: string;
+    packageVersionKey: string;
+    /** Client-generated GUID for the deployment to create. */
+    newDeploymentKey: string;
+    /** Activate right after install (server-side; no separate activate call). */
+    forceActivate: boolean;
+    /** Key of the folder the deployment installs into. The server creates
+     *  `solutionRootFolderName` under THIS folder — not under
+     *  `pathFullyQualifiedName`, which only feeds the deployment record. */
+    installationFolderKey: string;
+    /** FQN of that same folder — recorded as the deployment's displayed path,
+     *  so it must agree with `installationFolderKey`. */
+    pathFullyQualifiedName: string;
+    /** False → deploy an already-published package (the CLI's case). */
+    packageAndDeploy: boolean;
+    /** Name of the new Orchestrator folder created for the deployment. */
+    solutionRootFolderName: string;
+    pauseBeforeRun: boolean;
+    runtimeSetup?: {
+        requireServerlessTemplate: boolean;
+    };
+}
+/**
+ * Deploy a feed package via the v2 auto-install endpoint.
+ *
+ * `feedFolderKey` is sent as `X-UIPATH-FolderKey` so the server resolves the
+ * package version within that feed (same scoping the search endpoints use).
+ * Non-2xx responses throw the generated runtime's {@link ResponseError} so
+ * callers' `extractErrorDetails` handling (status + body parsing) works
+ * unchanged. The response body is returned parsed when it is a JSON object,
+ * `{}` otherwise — the endpoint's response shape is not pinned by the spec yet.
+ */
+export declare function deploymentsAutoInstall(config: AutoInstallClientConfig, request: DeploymentAutoInstallRequest, feedFolderKey: string): Promise<Record<string, unknown>>;

package/dist/src/index.d.ts

@@ -1,8 +1,11 @@
 import "./user-agent.js";
+export { getAvailablePublishLocationsV2, type PublishLocationType, type PublishLocationV2, } from "@uipath/studioweb-sdk";
 export * from "../generated/src/index.js";
 export { buildSolutionPackageFromDir, bundleSolution, resolveSolutionDir, } from "./bundle-service";
+export { type AutoInstallClientConfig, type DeploymentAutoInstallRequest, deploymentsAutoInstall, } from "./deployments-auto-install";
+export { type PackageVersionSearchFilter, type PackageVersionSearchRow, type PackageVersionsClientConfig, searchPackageVersions, } from "./search-package-versions";
 export type { AutoCreatedSolution, ParentSolutionDiscovery, PrepareProjectLocationOptions, PrepareProjectLocationResult, ProjectSolutionRegistration, RegisterProjectOptions, SolutionManifestCreation, } from "./solution-file";
-export { autoScaffoldSolution, createSolutionManifest, findNearestParentUipxFile, findSolutionFile, isProjectRegisteredInSolution, normalizeProjectType, prepareProjectLocation, readSolutionManifest, readUipxFile, toPortableRelativePath, tryRegisterProjectInParentSolution, updateSolutionFile, updateUipxSolutionId, } from "./solution-file";
+export { autoScaffoldSolution, createSolutionManifest, findNearestParentUipxFile, findSolutionFile, findSolutionFileUpward, isProjectRegisteredInSolution, normalizeProjectType, prepareProjectLocation, readSolutionManifest, readUipxFile, toPortableRelativePath, tryRegisterProjectInParentSolution, updateSolutionFile, updateUipxSolutionId, } from "./solution-file";
 export { getStudioWebSolutionProjects } from "./solution-info";
 export type { BundleResult, SolutionImportResponse, StudioWebConfig, StudioWebSolutionProject, UipxFile, UipxProject, } from "./types";
 export { importSolution, overwriteSolution, solutionExistsOnStudioWeb, uploadOrOverwriteSolution, } from "./upload-service";

package/dist/src/resources/commands/project-utils.d.ts

@@ -0,0 +1,64 @@
+export interface ProjectFileContent {
+    Name?: string;
+    ProjectType?: string;
+    designOptions?: {
+        outputType?: string;
+    };
+    functions?: Record<string, string>;
+}
+export interface SolutionProject {
+    Type: string;
+    ProjectRelativePath: string;
+    Id: string;
+}
+export interface SolutionFileContent {
+    Projects?: SolutionProject[];
+}
+export interface ProjectFileInfo {
+    filePath: string;
+    fileName: string;
+    useProjectJson: boolean;
+}
+export interface ParsedProjectFile {
+    content: ProjectFileContent;
+    projectType: string;
+}
+export interface ParsedSolutionFile {
+    solution: SolutionFileContent;
+    rawContent: string;
+}
+/**
+ * Finds the project manifest inside a directory, in priority order:
+ * project.uiproj, project.json, then uipath.json (code-first JS/TS Functions).
+ */
+export declare function findProjectFile(projectDir: string): Promise<[Error, null] | [null, ProjectFileInfo]>;
+/**
+ * Reads and parses a project manifest, extracting the project type.
+ */
+export declare function readProjectFile(filePath: string, useProjectJson: boolean): Promise<[Error, null] | [null, ParsedProjectFile]>;
+/**
+ * Reads and parses a solution .uipx file.
+ * Returns both the parsed object and the raw content (for rollback).
+ */
+export declare function readSolutionFile(filePath: string): Promise<[Error, null] | [null, ParsedSolutionFile]>;
+/**
+ * Resolves the solution file path — either from an explicit option or by searching upward.
+ */
+export declare function resolveSolutionFilePath(solutionFileOption: string | undefined, searchStartDir: string): Promise<[Error, null] | [null, string]>;
+/**
+ * Writes the solution object back to disk as formatted JSON.
+ */
+export declare function writeSolutionFile(filePath: string, solution: SolutionFileContent): Promise<Error | null>;
+/**
+ * Restores the exact solution file content captured before a write.
+ */
+export declare function restoreSolutionFile(filePath: string, rawContent: string): Promise<Error | null>;
+/**
+ * Creates a project in the solution builder (resource builder services).
+ * Handles service init, builder creation, createProjectAsync, and dispose.
+ *
+ * `subType` is forwarded to the SDK's project template picker. For AppV2
+ * projects: pass `"Coded"` for a regular coded app or `"CodedAction"` for a
+ * coded action app; leave undefined for other project types.
+ */
+export declare function createProjectInSolutionBuilder(solutionDir: string, projectId: string, projectName: string, projectType: string, subType?: string): Promise<Error | null>;

package/dist/src/resources/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Public `@uipath/solution-sdk/resources` entry: the solution resource engine,
+ * split out of `solution-tool` so peer tools (flow, maestro, agent, case,
+ * codedapp) and the solution CLI share one implementation instead of importing
+ * across tool packages.
+ *
+ * Built as its own entry point in solution-sdk's `--splitting` pass, so the
+ * heavy `@uipath/resource-builder-sdk` / `@uipath/orchestrator-sdk` graph lands
+ * in this subpath's chunks — the light `.` barrel that every tool bundles never
+ * pulls it.
+ *
+ * The engine modules have disjoint export names, so `export *` gives callers the
+ * full surface without hand-curating (and silently dropping) individual symbols.
+ */
+export * from "./commands/project-utils";
+export * from "./providers/resource-builder-init";
+export * from "./services/entry-point-spec-enhancer";
+export * from "./services/local-resource-matcher";
+export * from "./services/project-artifacts-service";
+export * from "./services/resource-refresh-service";
+export * from "./services/solution-manifest";
+export * from "./services/sync-resources-from-bindings";

package/dist/src/resources/providers/file-storage-provider.d.ts

@@ -0,0 +1,11 @@
+import type { IFileStorageProvider, IFileStorageProviderFactory, ISolutionContext } from "@uipath/resource-builder-sdk";
+/**
+ * Factory for creating FileSystemFileStorageProvider instances.
+ */
+export declare class FileSystemFileStorageProviderFactory implements IFileStorageProviderFactory {
+    getProviderAsync(context: ISolutionContext, cancellationToken?: AbortSignal): Promise<IFileStorageProvider>;
+    getProviderByPathAsync(basePath: string, _cancellationToken?: AbortSignal): Promise<IFileStorageProvider>;
+    getCurrentUserProfileProviderAsync(context: ISolutionContext, cancellationToken?: AbortSignal): Promise<IFileStorageProvider>;
+    getUserProfileProviderAsync(context: ISolutionContext, userId: string, _cancellationToken?: AbortSignal): Promise<IFileStorageProvider>;
+    getCurrentUserProfileProviderByPathAsync(basePath: string, cancellationToken?: AbortSignal): Promise<IFileStorageProvider>;
+}

package/dist/src/resources/providers/resource-builder-init.d.ts

@@ -0,0 +1,12 @@
+import { type IResourceBuilderServices } from "@uipath/resource-builder-sdk";
+/**
+ * Creates a configured ResourceBuilderServices instance for CLI usage.
+ * Uses SolutionAccessProvider which maps SDK service scopes to full
+ * tenant-scoped gateway URLs, enabling server-side SDK operations
+ * (updateConfigurationAsync, addOrUpdateResourceToSolutionAsync, etc.).
+ *
+ * `EntryPointSpecEnhancer` is registered so artefact resources (resources
+ * with a `projectKey`) reflect the latest `entry-points.json` from disk at
+ * read time, instead of the snapshot captured at `solution projects add`.
+ */
+export declare function createResourceBuilderServices(): Promise<IResourceBuilderServices>;

package/dist/src/resources/providers/solution-access-provider.d.ts

@@ -0,0 +1,18 @@
+import type { AuthenticationInfo, IAccessProvider } from "@uipath/resource-builder-sdk";
+/**
+ * IAccessProvider that maps SDK service scopes to full tenant-scoped URLs.
+ * Unlike CliAccessProvider (which returns bare baseUrl), this builds the correct
+ * gateway paths that the resource-builder-sdk expects for server-side operations.
+ */
+export declare class SolutionAccessProvider implements IAccessProvider {
+    private loginStatus;
+    private userKey;
+    private getStatus;
+    getResourceUrlAsync(scope: string, _cancellationToken?: AbortSignal): Promise<string | null>;
+    getResourceUrlWithAuthAsync(scope: string, _authInfo: AuthenticationInfo, _cancellationToken?: AbortSignal): Promise<string | null>;
+    getAccessTokenAsync(_scopes: string[], _force?: boolean, _cancellationToken?: AbortSignal): Promise<string | null>;
+    getUserKeyAsync(_cancellationToken?: AbortSignal): Promise<string | null>;
+    getTenantKeyAsync(_cancellationToken?: AbortSignal): Promise<string | null>;
+    getAccountKeyAsync(_cancellationToken?: AbortSignal): Promise<string | null>;
+    isGatewayIntegrationEnabled(): boolean;
+}

package/dist/src/resources/services/entry-point-spec-enhancer.d.ts

@@ -0,0 +1,31 @@
+import { type IFileSystem } from "@uipath/filesystem";
+import type { IArtifactResourceSpecEnhancer, ISolutionContext, ResourceDefinition, ResourcePropertyMetadata } from "@uipath/resource-builder-sdk";
+/**
+ * Reads the project's `entry-points.json` at GET time and projects the primary
+ * entry points onto the resource spec, so consumers see the current on-disk
+ * state — not the snapshot captured at `solution projects add`.
+ *
+ * Mirrors the shape Studio Web returns from its process configuration
+ * endpoint: `entryPoints` always carries the raw `entry-points.json` text;
+ * `entryPointName` / `entryPointUniqueId` are populated only when the project
+ * has exactly one entry, and are explicit `null` for multi-entry or empty
+ * projects.
+ *
+ * Read-only by design: never mutates the on-disk resource JSON. Spec
+ * degradation (missing/malformed file) is swallowed so `resource get` stays
+ * functional.
+ */
+export declare class EntryPointSpecEnhancer implements IArtifactResourceSpecEnhancer {
+    private readonly fs;
+    constructor(fs?: IFileSystem);
+    enhanceSpecAsync(context: ISolutionContext, resource: ResourceDefinition, _propertiesMetadata: Map<string, ResourcePropertyMetadata>, spec: Map<string, unknown>, _cancellationToken?: AbortSignal): Promise<void>;
+    private applyEntryPointAsync;
+    private findSolutionFileAsync;
+}
+/**
+ * Applies `EntryPointSpecEnhancer` against a plain-object spec returned by the
+ * SDK's `getConfigurationAsync` path. Used by `resource get` until the SDK
+ * invokes `enhanceSpecAsync` itself from `GetMappedResourceConfigurationRequestHandler`;
+ * once that lands this becomes a redundant no-op for the same on-disk state.
+ */
+export declare function applyEntryPointEnhancementAsync(context: ISolutionContext, resource: ResourceDefinition, spec: Record<string, unknown>): Promise<Record<string, unknown>>;

package/dist/src/resources/services/local-resource-matcher.d.ts

@@ -0,0 +1,27 @@
+import type { ResourceDefinition } from "@uipath/resource-builder-sdk";
+/**
+ * Pure, dependency-free matching primitives for local solution resources.
+ * A leaf module on purpose: `sync-resources-from-bindings` and
+ * `resource-mutations` both re-export from here (so existing callers keep
+ * their import paths), while `commands/resource-add.ts` imports it directly —
+ * which lets its spec run the REAL matcher without mocking this module.
+ */
+/**
+ * Normalize a folder path for comparisons. `.` and `solution_folder` both
+ * encode "no folder" (tenant/root scope) — collapsing them to undefined lets
+ * us compare a binding's folder against an existing resource's folder
+ * consistently regardless of which placeholder either side carries.
+ */
+export declare function normalizeFolderPath(path: string | undefined): string | undefined;
+/**
+ * Find a solution resource matching (kind, name | name_<N>, normalized
+ * folder). Kind + name are compared case-insensitively; the suffix variants
+ * match because SDK's `addResourceWithUniqueName` may have suffixed an
+ * earlier add/import of the same name. With a solution-relative `folderPath`
+ * (`.` / `solution_folder` / undefined) only root-scope resources match.
+ *
+ * Single source of truth for "does an in-solution resource already cover
+ * this (kind, name, folder)?" — used by the refresh import guard (UV-15289),
+ * the virtual idempotency check, and `resources add --source local`.
+ */
+export declare function findMatchingLocalResource(resources: ResourceDefinition[], kind: string, name: string, folderPath: string | undefined): ResourceDefinition | undefined;

package/dist/src/resources/services/project-artifacts-service.d.ts

@@ -0,0 +1,44 @@
+export interface AddProjectArtifactsOptions {
+    /** Absolute path to the solution directory (containing the `.uipx`). */
+    solutionDir: string;
+    /** Stable project key — must match the `Id` in `.uipx` `Projects[]`. */
+    projectId: string;
+    /** Display name for the project; typically the project folder name. */
+    projectName: string;
+    /**
+     * Project type as written to `project.uiproj` (e.g. `Flow`,
+     * `ProcessOrchestration`, `Agent`, `CaseManagement`, `AppV2`). Normalized
+     * internally via `normalizeProjectType` so callers can pass the raw value.
+     */
+    projectType: string;
+    /**
+     * Optional SDK subType. Used by the resource-builder-sdk to pick the right
+     * artifact-resource template. For AppV2 (coded apps) callers must pass
+     * `"Coded"` for a regular coded app or `"CodedAction"` for a coded action
+     * app — mirrors the `context.projectSubType` value Studio Web posts when
+     * a project is created in a solution. Without a matching subType the SDK
+     * template lookup misses and falls back to a generic Process resource,
+     * which places the project under the Processes tab instead of Apps.
+     */
+    projectSubType?: string;
+}
+export interface ProjectArtifactsResult {
+    /** True when artifact resources were generated. */
+    Created: boolean;
+    /** Error message when `Created` is `false`. */
+    Error?: string;
+}
+/**
+ * Generate `resources/solution_folder/process/<kind>/` artifact-resource
+ * entries for a project that has just been registered in the parent
+ * solution's `.uipx`. Mirrors the second half of `uip solution project add`
+ * (after the manifest write), so `*-tool init` paths can produce the same
+ * complete on-disk state without requiring a follow-up
+ * `solution project remove` + `add` cycle.
+ *
+ * Returns a result envelope instead of throwing: the project files have
+ * already been created by the init caller, so a failure here is recoverable
+ * with `solution project remove` + `add`. Callers surface the result in
+ * their success envelope as `Data.ProjectArtifacts`.
+ */
+export declare function addProjectArtifactsToSolutionAsync(options: AddProjectArtifactsOptions): Promise<ProjectArtifactsResult>;

package/dist/src/resources/services/resource-refresh-service.d.ts

@@ -0,0 +1,34 @@
+/** Discriminator for {@link ResourceRefreshFailure}; library callers can ignore the tag and read `.message` / `.ok`. */
+export type ResourceRefreshFailureReason = "solution_not_found" | "not_a_solution" | "auth_failed" | "sync_failed";
+export interface ResourceRefreshOptions {
+    /** Minimum minutes before token expiration to trigger a refresh. Default `10` (matches the CLI's `--login-validity`). */
+    loginValidity?: number;
+    /** Pin auth to this exact `.uipath/.auth` path. */
+    envFilePath?: string;
+}
+export interface ResourceRefreshSuccess {
+    ok: true;
+    /** Resources newly created (virtualized) in the solution this run. */
+    created: number;
+    /** Resources imported from Orchestrator into the solution this run. */
+    imported: number;
+    /** Bindings whose cloud key was already in the solution (no-op this run). */
+    skipped: number;
+    /** Non-fatal advisories (e.g. unresolved connections, link-before-deploy hints). */
+    warnings: string[];
+}
+export interface ResourceRefreshFailure {
+    ok: false;
+    reason: ResourceRefreshFailureReason;
+    /** Human-readable summary suitable for top-level surfacing. */
+    message: string;
+}
+export type ResourceRefreshResult = ResourceRefreshSuccess | ResourceRefreshFailure;
+/**
+ * Programmatic core of `uip solution resources refresh`: re-scans every project's
+ * `bindings_v2.json` and syncs resource declarations into the solution, importing
+ * from Orchestrator when a match exists and virtualizing the rest. Returns a tagged
+ * {@link ResourceRefreshResult}; re-throws only on unexpected errors. Mirrors
+ * `./pack` / `./publish` / `./deploy`.
+ */
+export declare function resourceRefreshAsync(solutionPath?: string, options?: ResourceRefreshOptions): Promise<ResourceRefreshResult>;

package/dist/src/resources/services/solution-manifest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Throw if `dir` doesn't directly contain a `.uipx` manifest. Stricter than
+ * `findSolutionFile` (which walks up to find one) — write commands should not
+ * silently mutate the wrong folder when run from an arbitrary cwd.
+ *
+ * Lives in `services/` (not `commands/project.ts`) so callers can mock the
+ * check without pulling in the full project-commands module.
+ */
+export declare function assertSolutionManifest(dir: string): Promise<void>;

package/dist/src/resources/services/sync-resources-from-bindings.d.ts

@@ -0,0 +1,133 @@
+import { type IResourceBuilderServices, type ISolutionBuilder, type ResourceDefinition } from "@uipath/resource-builder-sdk";
+interface RequiredPropertyDefault {
+    property: string;
+    /** Empty placeholder value matching the property's declared type. */
+    placeholder: unknown;
+}
+interface ResolvedKindMetadata {
+    /** Subtype to pass to createVirtualResourceAsync (e.g. "StringAsset"). */
+    type?: string;
+    /** SDK's `supportsInLineCreation` — whether a virtual stub can be created. */
+    virtualizable: boolean;
+    /**
+     * Required spec properties that have no default in SDK metadata. Deploy
+     * validation rejects virtualized resources missing these (e.g. Asset.value).
+     * We fill them in-memory after `createVirtualResourceAsync` with a
+     * type-appropriate placeholder.
+     */
+    requiredDefaults: RequiredPropertyDefault[];
+}
+export { findMatchingLocalResource, normalizeFolderPath, } from "./local-resource-matcher";
+interface SyncResult {
+    created: number;
+    imported: number;
+    skipped: number;
+    warnings: string[];
+}
+/**
+ * Reads bindings_v2.json from project paths and creates/imports matching
+ * resources in the solution using the resource-builder-sdk.
+ *
+ * @param solutionDir - Path to the solution directory
+ * @param projectPaths - Specific project paths to scan (if omitted, scans all projects in .uipx)
+ */
+export declare function syncResourcesFromBindings(solutionDir: string, projectPaths?: string[]): Promise<SyncResult>;
+/**
+ * Mirror of SDK's private `addResourceWithUniqueName`
+ * (resource-builder-sdk index.js:673): if any other resource of the same
+ * kind already carries `name` (or a `name_<N>` suffix variant), return
+ * `name_<N+1>`. Otherwise return `name` unchanged. Excludes `excludeKey`
+ * so the resource we just created doesn't collide with itself.
+ */
+export declare function uniqueNameForResource(name: string, kind: string, excludeKey: string, solution: {
+    resources: Array<{
+        key: string;
+        kind?: string;
+        name?: string;
+    }>;
+}): string;
+export interface RcsMatch {
+    key: string;
+    name: string;
+    /** Subtype as RCS reports it (e.g. `Text` for Asset). `undefined` for
+     * kinds without a subtype (Queue). Callers may need to forward this to
+     * `addOrUpdateResourceToSolutionAsync`, which rejects type-less imports
+     * for kinds that SDK metadata indexes by (kind, type). */
+    type?: string;
+    folder?: {
+        fullyQualifiedName: string;
+        folderKey: string;
+        path?: string;
+    };
+}
+/**
+ * Find a resource in RCS by key (UUID). RCS's `SearchFolderEntities` endpoint
+ * has no key-based filter — only `name`/`entityTypes`/`entitySubTypes`. We
+ * paginate all resources of this kind and filter locally by key, exiting
+ * early on the match. Used for connections, whose binding carries the UUID
+ * directly via `bindingKey`.
+ */
+export declare function findResourceByKeyInRcs(builder: ISolutionBuilder, kind: string, expectedKey: string, folderPath?: string, propagateErrors?: boolean): Promise<RcsMatch | undefined>;
+/**
+ * Page through RCS for a given (kind, name) and collect every match. Returns
+ * an empty array on lookup error (logged as a warning). Callers decide what
+ * to do with 0/1/many matches.
+ */
+export declare function searchRcsResources(builder: ISolutionBuilder, kind: string, name: string): Promise<RcsMatch[]>;
+export declare function findResourceInRcs(builder: ISolutionBuilder, kind: string, name: string, folderPath?: string): Promise<RcsMatch | undefined>;
+/**
+ * Resolve a resource kind's metadata via the SDK (`kind`, optional `type`) so
+ * callers outside the bindings sync can fill required spec defaults the same
+ * way `createVirtualForBinding` does. Returns undefined if the kind isn't
+ * indexed by SDK metadata.
+ */
+export declare function resolveResourceKindMetadata(services: IResourceBuilderServices, kind: string, type?: string): Promise<ResolvedKindMetadata | undefined>;
+export interface CreateLocalResourceParams {
+    builder: ISolutionBuilder;
+    services: IResourceBuilderServices;
+    kind: string;
+    type?: string;
+    name: string;
+    folderPath?: string;
+}
+export interface CreateLocalResourceResult {
+    resource: ResourceDefinition;
+    /** Final name on the resource — may differ from input if SDK conflict suffix kicked in. */
+    finalName: string;
+}
+/**
+ * Create a virtual (local-only) resource via the SDK and rename it to `name`,
+ * mirroring the rename + spec-default flow `createVirtualForBinding` runs
+ * during refresh. Returns the freshly created `SolutionResource` after the
+ * mutation, or undefined if the SDK failed to allocate a key.
+ *
+ * Callers must:
+ *   - Persist the change (e.g. `builder.disposeAsync()` or
+ *     `context.saveAsync()`); this helper only mutates in-memory state.
+ *   - Have already done an idempotency check — this helper *always* creates,
+ *     and SDK's `addResourceWithUniqueName` will suffix the name on conflict.
+ */
+export declare function createLocalResource(params: CreateLocalResourceParams): Promise<CreateLocalResourceResult | undefined>;
+export interface UipxProject {
+    /** Project type as written in `.uipx` (e.g. "Agent", "Process"). */
+    type: string;
+    /** Design-time UUID used as `projectKey` in reconcile. */
+    id: string;
+    /** Path to the project directory (parent of `project.uiproj`). */
+    path: string;
+    /** Project name read from `project.uiproj` (`Name` field). */
+    name: string;
+}
+/**
+ * Read solution's `.uipx` and each project's `project.uiproj` to assemble the
+ * data needed for `reconcileProjectsAsync`. Without this, sync would only see
+ * resource bindings (Queue/Asset/etc.) and miss the project artefacts
+ * (process/<type>, package, app/<subType>, appVersion) the SDK generates from
+ * project templates.
+ */
+export declare function readUipxProjects(solutionDir: string): Promise<UipxProject[]>;
+/**
+ * Sync resources from bindings with logging. Non-fatal — logs warnings
+ * on failure and continues. Used by pack and upload before packaging.
+ */
+export declare function syncAndLog(solutionDir: string): Promise<void>;

package/dist/src/search-package-versions.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Automation Solutions package-version search.
+ *
+ * Hand-written wrapper — `POST /api/search/packages/{packageKey}/versions` is
+ * in the committed swagger but not in the generator's include list, and the
+ * generator can't currently be re-run (its swagger URL is auth-gated). It is
+ * the same call Studio Web's deploy-setup uses to list deployable versions,
+ * so feed deploys can target any published version, not just the latest.
+ * Once the path is added to `explicitlyIncludedPaths` in
+ * `src/scripts/generate-sdk.ts` and the SDK is regenerated, drop this file in
+ * favor of the generated method.
+ */
+/** Auth/endpoint inputs for {@link searchPackageVersions}. */
+export interface PackageVersionsClientConfig {
+    /** Tenant-scoped Automation Solutions base path (`.../automationsolutions_`). */
+    basePath: string;
+    accessToken: string;
+}
+/** Body of `POST /api/search/packages/{packageKey}/versions` (PackageVersionSearchFilter). */
+export interface PackageVersionSearchFilter {
+    searchTerm?: string;
+    skip?: number;
+    take?: number;
+    orderByColumn?: string;
+    orderByDirection?: "Ascending" | "Descending";
+    excludeInvalidPackages: boolean;
+}
+/** One row of the versions search (PackageVersionInfo, fields the CLI reads). */
+export interface PackageVersionSearchRow {
+    key: string;
+    version: string;
+    publishDate?: string;
+    state?: string;
+}
+/**
+ * Search a package's published versions within a feed.
+ *
+ * When `feedFolderKey` is set, it is sent as `X-UIPATH-FolderKey` so results
+ * are scoped to that feed, matching the package search. Omitting it searches
+ * the tenant feed. Non-2xx responses throw the generated runtime's
+ * {@link ResponseError}.
+ */
+export declare function searchPackageVersions(config: PackageVersionsClientConfig, packageKey: string, filter: PackageVersionSearchFilter, feedFolderKey?: string): Promise<{
+    count?: number;
+    values: PackageVersionSearchRow[];
+}>;

package/dist/src/solution-auth.d.ts

@@ -0,0 +1,13 @@
+export interface SolutionAuthContext {
+    accessToken: string;
+    basePath: string;
+    organizationId: string;
+    tenantName: string;
+}
+export declare function getSolutionAuthContext(options: {
+    tenant?: string;
+    loginValidity?: number;
+    /** Pin auth to this exact `.uipath/.auth` path (forwarded to
+     *  `getAuthContext`) instead of resolving from `process.cwd()`. */
+    envFilePath?: string;
+}): Promise<SolutionAuthContext>;

package/dist/src/solution-file.d.ts

@@ -11,7 +11,9 @@ import type { UipxFile, UipxProject } from "./types";
  * - `AlreadyRegistered` — Project was already in Projects[]; no write performed.
  * - `Skipped`           — A candidate solution was found but registration was deliberately
  *                         not attempted (ambiguous: multiple `.uipx` in same dir, or the
- *                         project dir sits outside the discovered solution dir).
+ *                         project dir sits outside the discovered solution dir, or the
+ *                         project's type cannot live in a solution — see
+ *                         {@link unsupportedSolutionProjectType}).
  * - `Failed`            — Registration was attempted and an error occurred (read/write/parse).
  * - `NotInSolution`     — No `.uipx` file was found by walking ancestor directories. The
  *                         project was created in standalone mode. This is the explicit
@@ -226,3 +228,13 @@ export declare function readSolutionManifest(fs: IFileSystem, solutionFile: stri
  * project path and the manifest path is far more actionable.
  */
 export declare function isProjectRegisteredInSolution(fs: IFileSystem, projectDir: string, solutionFile: string): Promise<boolean>;
+/**
+ * Walks up from `startDir` to the filesystem root, returning the path of the
+ * single `.uipx` solution file found. Throws when none — or more than one in a
+ * single directory — is found. Distinct from {@link findSolutionFile}, which
+ * peeks only the parent directory and returns solution/project ids.
+ *
+ * Used by the resource engine (`@uipath/solution-sdk/resources`) and the
+ * solution CLI to resolve `--solution-folder` to a concrete manifest.
+ */
+export declare function findSolutionFileUpward(fs: IFileSystem, startDir: string): Promise<string>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/solution-sdk",
   "license": "MIT",
-  "version": "1.199.0",
+  "version": "1.201.0-preview.115",
   "repository": {
     "type": "git",
     "url": "https://github.com/UiPath/cli.git",
@@ -22,6 +22,14 @@
     ".": {
       "types": "./dist/src/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./resources": {
+      "types": "./dist/src/resources/index.d.ts",
+      "default": "./dist/resources/index.js"
+    },
+    "./auth": {
+      "types": "./dist/src/solution-auth.d.ts",
+      "default": "./dist/solution-auth.js"
     }
   },
   "bin": {
@@ -31,5 +39,5 @@
     "dist"
   ],
   "private": false,
-  "gitHead": "723e6801b77b5926ba75e75b6a756cc38b1b7adc"
+  "gitHead": "f1086b73654d7728cb71f280588b3e0c77d535fc"
 }