@uipath/solution-sdk 1.204.0-preview.254 → 1.205.0-preview.256

package/dist/solution-auth.js

@@ -1,10 +1,11 @@
 import {
   getSolutionAuthContext
-} from "./index-6gp5j7j5.js";
-import"./index-g0hcxnae.js";
+} from "./index-cs3g624n.js";
+import"./index-hkexw5er.js";
+import"./index-y4vgqz1w.js";
 import"./index-1de529jm.js";
 export {
   getSolutionAuthContext
 };
 
-//# debugId=434EB7083BB9C46564756E2164756E21
+//# debugId=C1859EA14CD133DF64756E2164756E21

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

@@ -0,0 +1,104 @@
+import { type DeploymentActivationStatus, type DeploymentOperationStatus, type DeploymentSearchItemDto2, type InitOverrideFunction } from "../generated/src/index.js";
+import type { SolutionAuthContext } from "./solution-auth.js";
+export type DeploymentSearchSource = "pipelines" | "legacy-v3";
+/** One page of the deployment search, in the terms both routes understand. */
+export interface DeploymentSearchQuery {
+    take: number;
+    skip: number;
+    /**
+     * Exact name. Filtered by the server on the Pipelines route; a substring
+     * term on the legacy one, so callers keep their exact match.
+     */
+    deploymentName?: string;
+    packageName?: string;
+    /** The row's parent folder by full path: exact, case-insensitive, subfolders excluded. */
+    targetFolderName?: string;
+    searchTerm?: string;
+    orderByColumn?: string;
+    orderByDirection?: "Ascending" | "Descending";
+    operationStatuses?: DeploymentOperationStatus[];
+    activationStatuses?: DeploymentActivationStatus[];
+}
+export interface DeploymentSearchPage {
+    /** The filtered total; `undefined` when the server omits it. */
+    count?: number;
+    values: DeploymentSearchItemDto2[];
+    /** Which route answered — for logs and tests, never for output. */
+    source: DeploymentSearchSource;
+}
+/**
+ * The server has only the legacy search, and that one reads user tokens only.
+ * Thrown instead of making a request that can only answer 403, so a caller can
+ * tell "cannot be read with this login" from an outage.
+ */
+export declare class DeploymentSearchNeedsUserSessionError extends Error {
+    constructor();
+}
+/**
+ * Why {@link searchDeployments} stopped before the end of the feed:
+ * - `page-cap`: it read as many pages as it may, and more rows remain.
+ * - `skip-ignored`: the server handed the same page back, so it ignores
+ *   `skip` and the rest cannot be reached.
+ * - `short-page`: the server counted more rows than it handed out — a page
+ *   came back short or empty before the count was reached (rows deleted
+ *   while paging, or a server that stops early).
+ */
+export type DeploymentSearchTruncationReason = "page-cap" | "skip-ignored" | "short-page";
+/**
+ * {@link searchDeployments} could not read the whole feed. Thrown rather than
+ * returning a partial list that looks complete; `reason` says why.
+ */
+export declare class DeploymentSearchTruncatedError extends Error {
+    readonly rowsRead: number;
+    readonly reason: DeploymentSearchTruncationReason;
+    constructor(rowsRead: number, reason: DeploymentSearchTruncationReason);
+}
+/**
+ * One page of the deployment search. Goes to the Pipelines route
+ * (`POST /v1/pipelines/deployments/search`), which reads application sessions
+ * too and filters an exact name on the server. Only on a server without that
+ * route does it use the deprecated `POST /api/v3/search/deployments`, and that
+ * one reads user sessions only: for an application session it throws
+ * {@link DeploymentSearchNeedsUserSessionError} instead.
+ *
+ * Rows come back as this package's DTO either way — the Pipelines row is a
+ * superset of it, so its extra fields are dropped.
+ */
+export declare function searchDeploymentsPage(auth: SolutionAuthContext, query: DeploymentSearchQuery, scope?: RequestInit | InitOverrideFunction): Promise<DeploymentSearchPage>;
+export interface SearchDeploymentsOptions {
+    /** Narrows the search to this package. Sent to the server as `packageName`. */
+    readonly packageName?: string;
+    /**
+     * Also drop rows whose `packageName` is not exactly `packageName`. Off by
+     * default: the server's package filter is not guaranteed exact (the V3
+     * route matches it as a substring too), and a caller that compares names
+     * its own way needs the near matches.
+     */
+    readonly exactPackageMatch?: boolean;
+    /**
+     * Keep only rows whose parent folder is this full path. Sent to the server
+     * as `targetFolderName`: exact, case-insensitive, subfolders excluded.
+     */
+    readonly folderPath?: string;
+    readonly orderByColumn?: string;
+    readonly orderByDirection?: "Ascending" | "Descending";
+    /** Passed to every page request as its init override (for example a feed header). */
+    readonly scope?: RequestInit | InitOverrideFunction;
+    /** Rows per page. Defaults to 50. */
+    readonly pageSize?: number;
+    /** Pages read before giving up. Defaults to 20. */
+    readonly maxPages?: number;
+}
+/**
+ * Every deployment row the search returns, paged to the end through
+ * {@link searchDeploymentsPage}.
+ *
+ * Statuses are not filtered and rows come back as the service sent them:
+ * what counts as "installed", "blocking" or "current" differs per caller.
+ *
+ * Throws {@link DeploymentSearchTruncatedError} when it cannot read the whole
+ * feed (its `reason` says why), a `RangeError` when `pageSize` or `maxPages`
+ * is not a whole number of 1 or more, and whatever the page request throws
+ * otherwise.
+ */
+export declare function searchDeployments(auth: SolutionAuthContext, options?: SearchDeploymentsOptions): Promise<DeploymentSearchItemDto2[]>;

package/dist/src/legacy-deployment-search-v3.d.ts

@@ -0,0 +1,24 @@
+import "./user-agent.js";
+import { type InitOverrideFunction } from "../generated/src/index.js";
+import type { DeploymentSearchQuery } from "./deployment-search.js";
+import type { SolutionAuthContext } from "./solution-auth.js";
+/** @deprecated See {@link searchDeploymentsLegacyV3}. */
+export declare const LEGACY_V3_SEARCH_ROUTE = "POST /api/v3/search/deployments";
+/**
+ * The deployment search as it was before the Pipelines route:
+ * `POST /api/v3/search/deployments`. It reads user tokens only, and has no
+ * exact-name filter, so a name travels as the substring `searchTerm` and the
+ * callers keep their own exact match. Answers the raw JSON body, which the
+ * caller parses with the same page parser as the Pipelines route's.
+ *
+ * @deprecated A bridge for rings that predate
+ * `POST /v1/pipelines/deployments/search` (SOL-7807), not a second path.
+ * Reached only through `searchDeploymentsPage` in `deployment-search.ts`, and
+ * only when the server answers the Pipelines route with "no such route".
+ * Remove this file, its branch and `DeploymentSearchNeedsUserSessionError` in
+ * `packages/solution-sdk/src/deployment-search.ts`, and the
+ * `/api/v3/search/deployments` entry in
+ * `packages/solution-sdk/src/scripts/generate-sdk.ts`, once the Pipelines
+ * route is on every production ring.
+ */
+export declare function searchDeploymentsLegacyV3(auth: SolutionAuthContext, query: DeploymentSearchQuery, scope?: RequestInit | InitOverrideFunction): Promise<unknown>;

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

@@ -0,0 +1,25 @@
+import "./user-agent.js";
+import { type InitOverrideFunction } from "../generated/src/index.js";
+import type { PackageSearchQuery } from "./package-search.js";
+import type { SolutionAuthContext } from "./solution-auth.js";
+/** @deprecated See {@link searchPackagesLegacy}. */
+export declare const LEGACY_PACKAGE_SEARCH_ROUTE = "POST /api/search/packages";
+/**
+ * The package search as it was before the Pipelines route:
+ * `POST /api/search/packages`. It reads user tokens only (it declares no S2S
+ * scheme and no OAuth scope), and takes the same filter as the Pipelines
+ * route. Answers the raw JSON body, which the caller parses with the same page
+ * parser as the Pipelines route's.
+ *
+ * @deprecated A bridge for rings that predate
+ * `POST /v1/pipelines/packages/search` (Automation.Solutions #9963), not a
+ * second path. Reached only through `searchPackagesPage` in
+ * `package-search.ts`, and only when the server answers the Pipelines route
+ * with "no such route". Remove this file, its branch and
+ * `PackageSearchNeedsUserSessionError` in
+ * `packages/solution-sdk/src/package-search.ts`, and the
+ * `/api/search/packages` entry in
+ * `packages/solution-sdk/src/scripts/generate-sdk.ts`, once the Pipelines
+ * route is on every production ring.
+ */
+export declare function searchPackagesLegacy(auth: SolutionAuthContext, query: PackageSearchQuery, scope?: RequestInit | InitOverrideFunction): Promise<unknown>;

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

@@ -0,0 +1,41 @@
+import { type InitOverrideFunction, type PackageInfo } from "../generated/src/index.js";
+import type { SolutionAuthContext } from "./solution-auth.js";
+export type PackageSearchSource = "pipelines" | "legacy";
+/** One page of the package search, in the terms both routes understand. */
+export interface PackageSearchQuery {
+    take: number;
+    skip: number;
+    /** Substring match on the package name. */
+    searchTerm?: string;
+    /** `name`, `latestVersion` (semantic order) or `publishDate`. */
+    orderByColumn?: string;
+    orderByDirection?: "Ascending" | "Descending";
+}
+export interface PackageSearchPage {
+    /** The filtered total; `undefined` when the server omits it. */
+    count?: number;
+    /** One row per package, carrying its latest release version. */
+    values: PackageInfo[];
+    /** Which route answered — for logs and tests, never for output. */
+    source: PackageSearchSource;
+}
+/**
+ * The server has only the legacy package search, and that one reads user
+ * tokens only. Thrown instead of making a request that can only answer 401, so
+ * a caller can tell "cannot be read with this login" from an outage.
+ */
+export declare class PackageSearchNeedsUserSessionError extends Error {
+    constructor();
+}
+/**
+ * One page of the package search. Goes to the Pipelines route
+ * (`POST /v1/pipelines/packages/search`), which reads application sessions
+ * too. Only on a server without that route does it use the deprecated
+ * `POST /api/search/packages`, and that one reads user sessions only: for an
+ * application session it throws {@link PackageSearchNeedsUserSessionError}
+ * instead.
+ *
+ * Both routes answer the same query with the same rows, so the caller cannot
+ * tell them apart except by `source`.
+ */
+export declare function searchPackagesPage(auth: SolutionAuthContext, query: PackageSearchQuery, scope?: RequestInit | InitOverrideFunction): Promise<PackageSearchPage>;

package/dist/src/pipelines-route.d.ts

@@ -0,0 +1,43 @@
+import type { SolutionAuthContext } from "./solution-auth.js";
+/**
+ * Whether an error from a Pipelines search route means the server has no such
+ * route (and the deprecated search it replaces should answer), as opposed to
+ * a failure of the route itself. Measured on servers without them: the POST
+ * falls onto the GET route sharing its path prefix (`deployments/{key}`,
+ * `packages/{packageName}`) and answers **405** with no body; a path matching
+ * nothing answers 404 with no body. A 404 with *any* body — an `errorCode`, or
+ * a plain ProblemDetails — is the route answering, and must reach the caller.
+ */
+export declare function isMissingPipelinesRoute(error: unknown): Promise<boolean>;
+/**
+ * Whether the session acts as an application. The identity on the auth
+ * context comes first: the login status resolved it from the token's claims
+ * and the auth flow saved at login, which decoding the token cannot know. The
+ * decode is the fallback for a context that carries none.
+ */
+export declare function isApplicationSession(auth: SolutionAuthContext): boolean;
+/** The nouns a search page's refusals use, e.g. `deployment` / `deployments`. */
+export interface SearchRowKind<T> {
+    readonly singular: string;
+    readonly plural: string;
+    /** This package's own deserializer for one row. */
+    readonly fromJSON: (row: unknown) => T;
+    /**
+     * Whether an object is a row at all. The generated deserializers never
+     * throw on a missing field — `{}` reads as a row of `undefined`s — so a
+     * search whose rows a caller identifies by some field says which here.
+     * Without it every object is accepted.
+     */
+    readonly isRow?: (row: object) => boolean;
+}
+/**
+ * One page of a search route, from its raw JSON body: `{ count?, values? }`,
+ * every row parsed by this package's own deserializer. A page that is not
+ * that shape must not read as "no rows": a caller checking for an existing
+ * name would act on it. A missing or null `values` is an empty page; a
+ * `count` that is not a number of 0 or more is unknown.
+ */
+export declare function parseSearchPage<T>(body: unknown, route: string, kind: SearchRowKind<T>): {
+    count?: number;
+    values: T[];
+};

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

@@ -14,12 +14,15 @@
  */
 export * from "./commands/project-utils";
 export * from "./providers/resource-builder-init";
+export { CatalogLookupError, type CatalogLookupFailure, type UncheckedBinding, } from "./services/catalog-lookup-failure";
 export * from "./services/entry-point-spec-enhancer";
 export * from "./services/local-resource-matcher";
 export * from "./services/project-artifacts-service";
 export * from "./services/project-template-types";
 export * from "./services/remote-resources";
 export { normalizeResourceCasing, normalizeResourceFileCasing, saveCasingNormalized, } from "./services/resource-casing";
+export * from "./services/resource-configurations";
+export * from "./services/resource-lookup";
 export * from "./services/resource-name";
 export * from "./services/resource-refresh-service";
 export * from "./services/resource-remote-sync";

package/dist/src/resources/providers/artefact-pair-binding-provider.d.ts

@@ -9,6 +9,10 @@ import { MultiFileSolutionDefinitionFactory, MultiFileSolutionDefinitionProvider
  * `undefined`-valued metadata-declared spec keys.
  */
 export declare class ArtefactPairBindingProvider extends MultiFileSolutionDefinitionProvider {
+    readAsync(context: ISolutionContext, cancellationToken?: AbortSignal): Promise<SolutionDefinition>;
+    protected replaceDuplicateKeysAsync(solution: SolutionDefinition): Promise<void>;
+    private describeDuplicateKeys;
+    private readResourceKey;
     writeAsync(context: ISolutionContext, solution: SolutionDefinition, cancellationToken?: AbortSignal): Promise<void>;
 }
 /**

package/dist/src/resources/services/catalog-lookup-failure.d.ts

@@ -0,0 +1,50 @@
+import type { CliErrorCode, RetryHint } from "@uipath/common";
+/** A binding the sync could not resolve against the cloud. */
+export interface UncheckedBinding {
+    kind: string;
+    name: string;
+}
+/**
+ * - `no_session`: no login, so the SDK could not build a catalog client.
+ * - `refused`: the catalog answered 401 or 403.
+ * - `failed`: anything else (an outage, a 4xx for one binding, a network error).
+ */
+export type CatalogFailureKind = "no_session" | "refused" | "failed";
+/** Why the sync could not resolve a binding against the cloud. */
+export interface CatalogLookupFailure {
+    /** The failed call's message, as the SDK reported it. */
+    message: string;
+    kind: CatalogFailureKind;
+    /** The HTTP status the message carried, when it carried one. */
+    status?: number;
+}
+/**
+ * The SDK's catalog proxy wraps every failure in an `InvalidOperationException`
+ * and keeps the HTTP status only in its text (`... Resource Catalog: HTTP 401
+ * - <detail>`, from `extractHttpErrorDetails`), so the status is read back off
+ * the message.
+ */
+export declare function classifyCatalogFailure(error: unknown): CatalogLookupFailure;
+/** Every later call would fail the same way, so the sync stops asking. */
+export declare function stopsCatalogLookups(failure: CatalogLookupFailure): boolean;
+/**
+ * The one warning a sync with a failed cloud call reports. `kept` are the
+ * bindings the solution already covers (left as they are); `unresolved` have
+ * nothing in the solution, and nothing was created for them — a local stub
+ * there would deploy as a new, empty resource instead of the cloud one.
+ */
+export declare function catalogLookupWarning(failure: CatalogLookupFailure, kept: number, unresolved: readonly UncheckedBinding[]): string;
+/**
+ * Thrown by a gating sync (pack, upload) when a binding has nothing in the
+ * solution and the cloud could not be asked for it. Carries `errorCode`,
+ * `retry` and `instructions` duck-typed, because it crosses a bundle boundary
+ * on its way to the envelope (`carriedErrorCode` / `carriedRetry` /
+ * `carriedInstructions`).
+ */
+export declare class CatalogLookupError extends Error {
+    readonly errorCode: CliErrorCode;
+    readonly retry: RetryHint;
+    readonly instructions: string;
+    readonly unresolved: readonly UncheckedBinding[];
+    constructor(failure: CatalogLookupFailure, unresolved: readonly UncheckedBinding[]);
+}

package/dist/src/resources/services/remote-resources.d.ts

@@ -15,6 +15,8 @@ export interface CatalogQuery {
 }
 /** Pages through the resource catalog and returns the first row `match` accepts. */
 export declare function findCatalogEntityAsync(catalog: IResourceCatalogClientProxy, query: CatalogQuery, match: (entity: CatalogEntity) => boolean): Promise<CatalogEntity | undefined>;
+/** Pages through the whole resource catalog and returns every row `match` accepts. */
+export declare function findCatalogEntitiesAsync(catalog: IResourceCatalogClientProxy, query: CatalogQuery, match: (entity: CatalogEntity) => boolean): Promise<CatalogEntity[]>;
 export declare function toResourceReference(entity: CatalogEntity): ResourceReferenceModel;
 /** A catalog entity named by what a cached catalog row already holds. */
 export interface CatalogReference {

package/dist/src/resources/services/resource-configurations.d.ts

@@ -0,0 +1,44 @@
+import type { IResourceBuilderServices } from "@uipath/resource-builder-sdk";
+import type { AllResourceConfigurations, ResourceConfiguration } from "@uipath/resource-builder-sdk/models";
+import type { ISolutionBuilder, ResourceDefinition } from "@uipath/resource-builder-sdk/solution";
+/**
+ * Whether a local configuration read failed because the solution does not
+ * declare `resourceKey` — as opposed to a broken solution (a missing resource
+ * file, dependency or metadata), which must not fall back to a tenant copy.
+ */
+export declare function isResourceKeyNotFound(error: unknown, resourceKey: string): boolean;
+/**
+ * Refresh each project-backed configuration's spec from its live
+ * `entry-points.json`. The SDK registers the enhancer but does not run it on
+ * reads, so without this a read returns the snapshot taken at `projects add`.
+ * Returns the solution resource behind each configuration it found, by key;
+ * an unreadable solution leaves the specs as they are.
+ */
+export declare function refreshArtefactSpecsAsync(builder: ISolutionBuilder, configurations: readonly ResourceConfiguration[]): Promise<Map<string, ResourceDefinition>>;
+/** What the caller already knows about a resource, used to narrow the catalog search for its key. */
+export interface ResourceLookupHint {
+    name?: string;
+}
+/**
+ * A resource the solution does not declare, read the way Studio Web's
+ * "retrieve configuration" does: the catalog row by key, then the FPS export,
+ * which carries the resource plus its transitive dependencies.
+ */
+export declare function exportResourceConfigurationsAsync(services: IResourceBuilderServices, resourceKey: string, hint?: ResourceLookupHint): Promise<AllResourceConfigurations>;
+/**
+ * A resource's configuration graph (itself plus its dependencies): from the
+ * local solution when `builder` declares the key, with project-backed specs
+ * refreshed, and from the tenant otherwise.
+ */
+export declare function readResourceConfigurationsAsync(services: IResourceBuilderServices, builder: ISolutionBuilder | undefined, resourceKey: string, hint?: ResourceLookupHint): Promise<AllResourceConfigurations>;
+export interface ResourceConfigurationRead {
+    configuration: ResourceConfiguration;
+    /** The local declaration behind `configuration`; absent for a tenant read. */
+    resource?: ResourceDefinition;
+}
+/**
+ * One resource's configuration, without its dependencies: from the local
+ * solution when `builder` declares the key, with its project-backed spec
+ * refreshed, and from the tenant otherwise.
+ */
+export declare function readResourceConfigurationAsync(services: IResourceBuilderServices, builder: ISolutionBuilder | undefined, resourceKey: string): Promise<ResourceConfigurationRead>;

package/dist/src/resources/services/resource-lookup.d.ts

@@ -0,0 +1,29 @@
+import type { IResourceBuilderServices } from "@uipath/resource-builder-sdk";
+import type { ISolutionBuilder } from "@uipath/resource-builder-sdk/solution";
+/** What a resource picker names: a kind, the resource's exact name, and optionally the subtypes and folder it narrows to. */
+export interface ResourceNameLookup {
+    kind: string;
+    name: string;
+    /** Only these subtypes match (e.g. `["Native"]` for a Data Fabric entity), compared case-insensitively. */
+    subTypes?: readonly string[];
+    /** Narrows catalog rows to one folder; local resources carry no folder key. */
+    folderKey?: string;
+}
+export interface ResourceNameMatch {
+    key: string;
+    /** Declared in the local solution. */
+    local: boolean;
+    folderPath?: string;
+    folderKey?: string;
+}
+/**
+ * Every resource of `kind` named exactly `name` (both case-insensitive), of
+ * one of `subTypes` when given. When the local solution declares any, those
+ * are the resources it means and the tenant is not searched; otherwise every
+ * page of the resource catalog is read, narrowed by `folderKey`. Read-only.
+ *
+ * Unlike `findMatchingLocalResource`, this returns every match, so a caller
+ * can report a name that is ambiguous, and it does not accept the `name_<N>`
+ * suffixes an add may have minted: a picker names the resource as it is.
+ */
+export declare function findResourcesByNameAsync(services: IResourceBuilderServices, builder: ISolutionBuilder | undefined, { kind, name, subTypes, folderKey }: ResourceNameLookup): Promise<ResourceNameMatch[]>;

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

@@ -1,3 +1,4 @@
+import { type ContributedBinding } from "./sync-resources-from-bindings";
 /** 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 {
@@ -12,6 +13,12 @@ export interface ResourceRefreshOptions {
      * for them on a run that is otherwise going to proceed.
      */
     resolveProjectSubTypesAsync?: () => Promise<ReadonlyMap<string, string>>;
+    /**
+     * Resolves the bindings a project's own tool contributed, keyed by the
+     * `.uipx` project `Id`. Called right after `resolveProjectSubTypesAsync`,
+     * so a caller can answer both from one collect.
+     */
+    resolveProjectBindingsAsync?: () => Promise<ReadonlyMap<string, readonly ContributedBinding[]>>;
 }
 export interface ResourceRefreshSuccess {
     ok: true;
@@ -23,6 +30,12 @@ export interface ResourceRefreshSuccess {
     skipped: number;
     /** Stale `name_<N>` clones of the solution's own member projects removed this run. */
     pruned: number;
+    /**
+     * Project artefact resources (package, process, ...) the `.uipx` project
+     * reconcile added this run. Not part of `created`, which counts
+     * binding-driven resources only. `0` on a rerun with nothing new.
+     */
+    projectResourcesCreated: number;
     /** Non-fatal advisories (e.g. unresolved connections, link-before-deploy hints). */
     warnings: string[];
 }

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

@@ -1,5 +1,6 @@
 import type { IResourceBuilderServices } from "@uipath/resource-builder-sdk";
-import type { ISolutionBuilder, ResourceDefinition } from "@uipath/resource-builder-sdk/solution";
+import { type ISolutionBuilder, type ResourceDefinition } from "@uipath/resource-builder-sdk/solution";
+import { type CatalogLookupFailure, type UncheckedBinding } from "./catalog-lookup-failure";
 interface RequiredPropertyDefault {
     property: string;
     /** Empty placeholder value matching the property's declared type. */
@@ -32,13 +33,37 @@ export interface ResolvedKindMetadata {
 export { findMatchingLocalResource, findMatchingMemberResource, findMemberCloneResources, normalizeFolderPath, } from "./local-resource-matcher";
 export declare function formatResourceSubtypes(subtypes: string[]): string;
 export declare function sameResourceSubtype(a: string | undefined, b: string | undefined): boolean;
+/**
+ * One `bindings_v2.json` `resources[]` entry, as a project's tool contributed
+ * it. Plain data: the project type that produced it is not this layer's
+ * concern (AGENTS.md Hard Rule #19).
+ */
+export interface ContributedBinding {
+    resource: string;
+    key?: string;
+    [field: string]: unknown;
+}
 interface SyncResult {
     created: number;
     imported: number;
     skipped: number;
     /** Stale `name_<N>` clones of member projects removed this run (UV-15817). */
     pruned: number;
+    /**
+     * Project artefact resources (package, process, ...) the `.uipx` project
+     * reconcile added this run. Separate from `created`, which counts
+     * binding-driven virtuals only; `0` on a rerun with nothing new.
+     */
+    projectResourcesCreated: number;
     warnings: string[];
+    /**
+     * Bindings with nothing in the solution whose Resource Catalog search
+     * failed. Nothing was created for them: "could not search" is not "not
+     * found", and a local stub would deploy as a new, empty resource.
+     */
+    unresolved: UncheckedBinding[];
+    /** Why the catalog could not be searched, when a search failed. */
+    catalogLookupFailure?: CatalogLookupFailure;
 }
 /**
  * Reads bindings_v2.json from project paths and creates/imports matching
@@ -46,8 +71,12 @@ interface SyncResult {
  *
  * @param solutionDir - Path to the solution directory
  * @param projectPaths - Specific project paths to scan (if omitted, scans all projects in .uipx)
+ * @param projectBindings - Bindings a project's own tool contributed, keyed by
+ *   `.uipx` project `Id`, as `bindings_v2.json` `resources[]` entries. Read in
+ *   place of that project's `bindings_v2.json`: such a project keeps its
+ *   bindings in its own source format, so a file on disk is a stale copy.
  */
-export declare function syncResourcesFromBindings(solutionDir: string, projectPaths?: string[], projectSubTypes?: ReadonlyMap<string, string>): Promise<SyncResult>;
+export declare function syncResourcesFromBindings(solutionDir: string, projectPaths?: string[], projectSubTypes?: ReadonlyMap<string, string>, projectBindings?: ReadonlyMap<string, readonly ContributedBinding[]>): Promise<SyncResult>;
 /**
  * Mirror of SDK's private `addResourceWithUniqueName`
  * (resource-builder-sdk index.js:673): if any other resource of the same
@@ -98,7 +127,7 @@ export declare function searchRcsResources(builder: ISolutionBuilder, kind: stri
  * auth or network failure.
  */
 export declare function searchRcsResourcesStrict(builder: ISolutionBuilder, kind: string, name: string): Promise<RcsMatch[]>;
-export declare function findResourceInRcs(builder: ISolutionBuilder, kind: string, name: string, folderPath?: string): Promise<RcsMatch | undefined>;
+export declare function findResourceInRcs(builder: ISolutionBuilder, kind: string, name: string, folderPath?: string, propagateErrors?: boolean): Promise<RcsMatch | undefined>;
 /**
  * Build a resolver that answers kind-metadata questions for many (kind, type)
  * pairs off one `getOrderedAsync` fetch, caching per pair. Prefer this over
@@ -158,7 +187,15 @@ export interface UipxProject {
  */
 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.
+ * Sync resources from bindings with logging. Non-gating callers log failures
+ * and continue; pack and upload rethrow them so invalid bindings cannot ship.
+ *
+ * One exception, under `failOnUnresolved` (the gating callers): a binding
+ * the Resource Catalog could not be searched for and that the solution does
+ * not hold throws {@link CatalogLookupError} after the sync is saved. Packing
+ * without that resource ships a solution that deploys without it.
  */
-export declare function syncAndLog(solutionDir: string, projectSubTypes?: ReadonlyMap<string, string>): Promise<void>;
+export declare function syncAndLog(solutionDir: string, projectSubTypes?: ReadonlyMap<string, string>, options?: {
+    projectBindings?: ReadonlyMap<string, readonly ContributedBinding[]>;
+    failOnUnresolved?: boolean;
+}): Promise<void>;

package/dist/src/zip-utils.d.ts

@@ -26,6 +26,11 @@ import type { IFileSystem } from "@uipath/filesystem";
  *                  `.project` (IDE state) and `.agent-builder` (inline agents)
  *                  must still ship.
  *
+ *   .flow-debug    The full result of the last `flow debug --summary` run of
+ *                  each Flow project (`<solution>/.flow-debug/<project>.json`).
+ *                  A local diagnosis record, with tenant data in it; never
+ *                  part of the solution.
+ *
  * Callers can extend this set per-walk via the `additionalExcludeDirs` option.
  * User-authored excludes come from `.uipignore` files and go through
  * `ignoreRules` instead (see {@link UipignoreRules}).

package/package.json

@@ -2,7 +2,7 @@
     "name": "@uipath/solution-sdk",
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.204.0-preview.254",
+    "version": "1.205.0-preview.256",
     "repository": {
         "type": "git",
         "url": "https://github.com/UiPath/cli.git",
@@ -31,6 +31,14 @@
         "./auth": {
             "types": "./dist/src/solution-auth.d.ts",
             "default": "./dist/solution-auth.js"
+        },
+        "./deployments": {
+            "types": "./dist/src/deployment-search.d.ts",
+            "default": "./dist/deployment-search.js"
+        },
+        "./packages": {
+            "types": "./dist/src/package-search.d.ts",
+            "default": "./dist/package-search.js"
         }
     },
     "bin": {
@@ -40,5 +48,5 @@
         "dist"
     ],
     "private": false,
-    "gitHead": "3ee79cdec05b36231a8da9e8de6bf0043585526a"
+    "gitHead": "63740c6cbb7ff282fa9118cc16a148eb030b245f"
 }