@wix/auto_sdk_containers_projects 1.0.5 → 1.0.7

package/build/internal/es/index.d.mts

@@ -6,21 +6,20 @@ export { AccountInfo, ActionEvent, CreateAgentSessionRequest, CreateAgentSession
 declare function createProject$1(httpClient: HttpClient): CreateProjectSignature;
 interface CreateProjectSignature {
     /**
-     * Creates a new Project from a template.
-     * Looks up the template to find its backing source code, creates a dev-center app,
-     * registers an AppProject, clones the template's git repository into a new
-     * code-store project, and persists the Project.
-     * @param - Project to be created.
-     * @returns The created Project.
+     * Creates a project from a template.
+     *
+     * The project is created with `PLANNING` status.
+     * @param - Project to create.
+     * @returns Created project.
      */
     (project: NonNullablePaths<Project, `platform` | `templateId`, 0>): Promise<NonNullablePaths<Project, `name` | `status` | `sandboxStatus` | `metaSiteIds` | `platform`, 0>>;
 }
 declare function getProject$1(httpClient: HttpClient): GetProjectSignature;
 interface GetProjectSignature {
     /**
-     * Retrieves a Project by ID.
-     * @param - ID of the Project to retrieve.
-     * @returns The requested Project.
+     * Retrieves a project.
+     * @param - ID of the project to retrieve.
+     * @returns Retrieved project.
      */
     (projectId: string): Promise<NonNullablePaths<Project, `name` | `status` | `sandboxStatus` | `metaSiteIds` | `platform`, 0>>;
 }
@@ -28,9 +27,13 @@ interface GetProjectSignature {
 declare function updateProject$1(httpClient: HttpClient): UpdateProjectSignature;
 interface UpdateProjectSignature {
     /**
-     * Updates an existing Project.
+     * Updates a project.
+     *
+     * Each time the project is updated, `revision` increments by 1. The current `revision` must be
+     * passed when updating the project. This ensures you're working with the latest project and
+     * prevents unintended overwrites.
      * @param - Project ID.
-     * @returns Updated Project.
+     * @returns Updated project.
      */
     (_id: string, project: NonNullablePaths<UpdateProject, `revision`, 0>): Promise<NonNullablePaths<Project, `name` | `status` | `sandboxStatus` | `metaSiteIds` | `platform`, 0>>;
 }
@@ -38,16 +41,24 @@ interface UpdateProjectSignature {
 declare function deleteProject$1(httpClient: HttpClient): DeleteProjectSignature;
 interface DeleteProjectSignature {
     /**
-     * Deletes a Project.
-     * @param - Id of the Project to delete.
+     * Deletes a project.
+     * @param - ID of the project to delete.
      */
     (projectId: string): Promise<void>;
 }
 declare function resumeProject$1(httpClient: HttpClient): ResumeProjectSignature;
 interface ResumeProjectSignature {
     /**
-     * Requests Project resume by starting or reusing its configured remote machine asynchronously.
-     * @param - ID of the Project to resume.
+     * Resumes work on a project by starting its remote development environment, or by reusing an
+     * environment that's already running.
+     *
+     * Call this method when a user returns to a project with `BUILDING` status, before they send new
+     * requests to the coding agent. The environment starts in the background, and the method returns
+     * the project without waiting for it. The API doesn't report when the environment is ready. The
+     * coding agent picks up new work as soon as it is.
+     *
+     * The project's `status` must be `BUILDING`.
+     * @param - ID of the project to resume.
      */
     (projectId: string): Promise<NonNullablePaths<ResumeProjectResponse, `project.name` | `project.status` | `project.sandboxStatus` | `project.metaSiteIds` | `project.platform`, 1>>;
 }
@@ -55,12 +66,11 @@ interface ResumeProjectSignature {
 declare function regenerateProjectName$1(httpClient: HttpClient): RegenerateProjectNameSignature;
 interface RegenerateProjectNameSignature {
     /**
-     * Generates a candidate display name for a Project from a user instruction, via the published
-     * "Regenerate app name" Prompt Hub prompt. The current name and the project's description are
-     * resolved server-side; the caller supplies only the instruction. Does not persist the result —
-     * the caller saves an accepted name with UpdateProject.
-     * @param - ID of the Project to generate a new name for.
-     * @param - The user's free-text renaming instruction, passed to the name-generation prompt.
+     * Generates a suggested name for a project, based on the user's instruction.
+     *
+     * The suggested name isn't saved. To save it, call Update Project.
+     * @param - ID of the project to generate a name for.
+     * @param - User's instruction for the new name. For example, `Make it shorter and more playful`.
      */
     (projectId: string, prompt: string): Promise<NonNullablePaths<RegenerateProjectNameResponse, `name`, 0>>;
 }
@@ -68,46 +78,58 @@ interface RegenerateProjectNameSignature {
 declare function regenerateProjectIcon$1(httpClient: HttpClient): RegenerateProjectIconSignature;
 interface RegenerateProjectIconSignature {
     /**
-     * Generates a candidate icon for a Project from a user instruction. The current project name,
-     * icon, app description, and brand colors are resolved server-side. Does not persist the result —
-     * the caller saves an accepted icon with UpdateProject.
-     * @param - ID of the Project to generate a new icon for.
-     * @param - The user's free-text icon instruction, passed to the icon-generation prompt.
+     * Generates a suggested icon for a project, based on the user's instruction.
+     *
+     * The icon is based on the project's current name, icon, description, and brand colors. The
+     * suggested icon isn't saved. To save it, call Update Project.
+     * @param - ID of the project to generate an icon for.
+     * @param - User's instruction for the new icon. For example, `Use a minimal coffee cup`.
      */
     (projectId: string, prompt: string): Promise<NonNullablePaths<RegenerateProjectIconResponse, `iconUrl`, 0>>;
 }
 declare function saveProjectDesign$1(httpClient: HttpClient): SaveProjectDesignSignature;
 interface SaveProjectDesignSignature {
     /**
-     * Persists a complete design-token document as a new Himalaya draft release, branched from the
-     * release the client currently has displayed.
-     *
-     * Synchronous: the Himalaya write completes before this call returns. Never touches the project's
-     * sandbox, runs a build, or activates the app — the saved release stays a draft, so what the live
-     * app serves is unaffected. Persists no entity of its own. When `conversation_id` is supplied it
-     * posts a CHECKPOINT message for the saved release into that conversation (best-effort — a chat
-     * failure never fails the save); omit it to skip the checkpoint.
-     * @param - Project whose design is being saved. The caller must own it.
-     * @param - The Himalaya release ID currently displayed by the client. The saved draft branches from
-     * exactly this release, even when a newer release exists for the app.
+     * Saves a project's design as a new draft release.
+     *
+     * Specify the complete design-token document in `tokensJson`, and the release that the user is
+     * currently viewing in `baseReleaseId`. The new draft release branches from `baseReleaseId`, even
+     * if a newer release exists. Saving a design doesn't change the project's live app.
+     *
+     * The response includes the ID of the new release and a short-lived token for previewing it. After
+     * the save, the project's `headReleaseId` is set to the new release.
+     *
+     * To record the saved version in a conversation, specify the conversation's ID in `conversationId`.
+     * A `CHECKPOINT` message is then added to the conversation. If the checkpoint can't be added, the
+     * design is still saved.
+     *
+     * For projects whose `platform` is `HIMALAYA_MOBILE`, call
+     * [Get Himalaya Authorization](https://dev.wix.com/docs/api-reference/mobile/containers-app/containers-projects/project-v1/get-himalaya-authorization)
+     * first, and specify the returned `canonicalApp`.
+     * @param - ID of the project whose design to save.
+     * @param - ID of the release that the user is currently viewing.
+     *
+     * The new draft release branches from this release, even if a newer release exists.
      */
     (projectId: string, baseReleaseId: string, options?: NonNullablePaths<SaveProjectDesignOptions, `himalayaControlToken` | `tokensJson`, 0>): Promise<NonNullablePaths<SaveProjectDesignResponse, `himalayaReleaseId` | `previewToken`, 0>>;
 }
 declare function restoreRelease$1(httpClient: HttpClient): RestoreReleaseSignature;
 interface RestoreReleaseSignature {
     /**
-     * Restores an earlier version by pointing the project's editable head at `release_id`: the client
-     * then previews that release and the next edit (design save or AI edit) branches from it. Pure
-     * project state — sets `head_release_id` and nothing in Himalaya: it does NOT activate the release,
-     * so the live app end-users run is untouched (a later publish/build is what carries head live).
-     *
-     * `release_id` is a Himalaya release id the caller already holds from the project's own release
-     * ledger, scoped to this project's app; the server stores it as head without re-reading Himalaya.
-     * When `conversation_id` is supplied, a CHECKPOINT message for the restored release is posted into
-     * it (best-effort — a chat failure never fails the restore); omit it to skip the checkpoint.
-     * @param - Project whose head is being moved. The caller must own it.
-     * @param - The Himalaya release to make the project's editable head. Not a GUID — a Himalaya release id
-     * (e.g. `rel-<hash>` / `<sha>-<hash>`), taken from the project's own release ledger.
+     * Restores an earlier version of a project.
+     *
+     * Sets the project's `headReleaseId` to the release specified in `releaseId`. Your app then
+     * previews that release, and the next design save or edit by the coding agent branches from it.
+     * Restoring a release doesn't change the project's live app.
+     *
+     * Only the project's owner can restore a release.
+     *
+     * To confirm that the release belongs to the project before it's restored, specify
+     * `himalayaControlToken`. To record the restored version in a conversation, specify the
+     * conversation's ID in `conversationId`. A `CHECKPOINT` message is then added to the conversation.
+     * If the checkpoint can't be added, the release is still restored.
+     * @param - ID of the project to restore a release for.
+     * @param - ID of the release to restore. For example, `rel-4f9c2a1b7d3e`.
      */
     (projectId: string, releaseId: string, options?: RestoreReleaseOptions): Promise<NonNullablePaths<RestoreReleaseResponse, `project.name` | `project.status` | `project.sandboxStatus` | `project.metaSiteIds` | `project.platform`, 1>>;
 }
@@ -115,19 +137,24 @@ interface RestoreReleaseSignature {
 declare function listProjects$1(httpClient: HttpClient): ListProjectsSignature;
 interface ListProjectsSignature {
     /**
-     * Lists the Projects of the current site — the MetaSite in the call scope — regardless of who owns
-     * them. Anyone with access to the site sees the site's projects; other sites in the same account are
-     * separate tenants and never appear here. The dashboard uses this; ListProjectsForCurrentUser stays
-     * owner-scoped for callers that still depend on it.
+     * Retrieves the projects of the current site, regardless of who created them.
+     *
+     * Projects of other sites in the same account aren't included.
      */
     (options?: ListProjectsOptions): Promise<NonNullablePaths<ListProjectsResponse, `projects` | `projects.${number}.name` | `projects.${number}.status` | `projects.${number}.sandboxStatus` | `projects.${number}.platform`, 2>>;
 }
 declare function getHimalayaAuthorization$1(httpClient: HttpClient): GetHimalayaAuthorizationSignature;
 interface GetHimalayaAuthorizationSignature {
     /**
-     * Repeats authenticated Himalaya authorization for the current collaborator. This response is
-     * a capability check only; every worker/design mutation performs a fresh check.
-     * @param - Site-tenanted Containers project being authorized.
+     * Checks whether the current user can work on a project's app.
+     *
+     * Supported for projects whose `platform` is `HIMALAYA_MOBILE`. The response returns the canonical
+     * slug of the project's app in `canonicalApp`. Specify this value when you call
+     * [Save Project Design](https://dev.wix.com/docs/api-reference/mobile/containers-app/containers-projects/project-v1/save-project-design).
+     *
+     * The response is a check only and doesn't grant access. Each later change to the project is
+     * authorized again.
+     * @param - ID of the project to check.
      */
     (projectId: string): Promise<NonNullablePaths<GetHimalayaAuthorizationResponse, `authorizationVersion` | `metaSiteId` | `projectId` | `canonicalApp` | `workerLaunch` | `saveDesign`, 0>>;
 }