@onplo/sdk 0.0.0-stage → 0.0.1

package/generated/software.d.ts

@@ -0,0 +1,1466 @@
+export interface paths {
+    "/software-projects": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * The software projects you may see
+         * @description EVERY SOFTWARE PROJECT YOU MAY SEE, in the account environment this credential acts in, in
+         *     the order they were marked. A project you hold no grant on is absent, never masked.
+         *
+         *     AN UNMARKED PROJECT IS LEFT OUT unless `include_unmarked` asks for it: it is archived, and
+         *     stays readable with all it holds.
+         *
+         *     EACH ROW SAYS WHAT STORAGE LAST SAID OF ITS FOLDER (`folder_state`): there, in Trash, or gone
+         *     for good.
+         */
+        get: operations["listSoftwareProjects"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects-in-own-folders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mark a folder of your own as a software project
+         * @description A STORAGE FOLDER BECOMES A SOFTWARE PROJECT. Any folder of your own, a nested one too. The
+         *     code stays in it, with Storage keeping its versions; Software never moves, renames or copies
+         *     it.
+         *
+         *     TWO PERMISSIONS, EACH ASKED OF ITS OWN OBJECT. "Mark a folder as a software project" is asked
+         *     of the account environment, and the right to share the folder in Storage is asked of the
+         *     folder: sharing is asked, not just reading, because marking lets the project's viewers see
+         *     what is built from the code. A refusal is one 403.
+         *
+         *     WHOEVER MARKS IT HOLDS ADMINISTRATOR ON THE PROJECT, and looks after it, until it is handed
+         *     on. A folder of your own is yours, so the project is yours too.
+         *
+         *     A COMPANY FOLDER IS MARKED BY ITS OWN OPERATION, `markCompanyFolderAsSoftwareProject`, because
+         *     its folder permission is a different one (decision 0831).
+         *
+         *     A FOLDER THAT IS NOT THERE IS REFUSED with `folder_not_found`, and nothing is made: no such
+         *     folder, one in Trash, a file, one in a colleague's tree. The answer does not say which.
+         *
+         *     A FOLDER ALREADY A SOFTWARE PROJECT IS REFUSED with `folder_already_a_software_project`. A
+         *     folder inside another project's folder is its own folder, and may be marked.
+         *
+         *     ONLY A PERSON MARKS A FOLDER. A machine is refused with a 422 on `/body/folder_id`, code
+         *     `agents_never_mark_a_folder`: there is no person whose share it would be.
+         */
+        post: operations["markOwnFolderAsSoftwareProject"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects-in-company-folders": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mark a company folder as a software project
+         * @description The same act as `markOwnFolderAsSoftwareProject`, on a folder of the company's, and the
+         *     project is the company's. Its folder permission is "Set who may reach a company folder".
+         *
+         *     A PERSONAL ACCOUNT ENVIRONMENT HAS NO COMPANY FOLDERS: there, this is refused with 409
+         *     `company_project_in_a_personal_environment`, and nothing is made.
+         *
+         *     WHOEVER MARKS IT HOLDS ADMINISTRATOR ON THE PROJECT from the moment it exists: the identity
+         *     service places that role in the same act that makes the project (ONPLO-4976), so a company
+         *     project nobody may manage is never made.
+         */
+        post: operations["markCompanyFolderAsSoftwareProject"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects/{software_project_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        /**
+         * Read one software project
+         * @description THE PROJECT AND ITS SETTINGS, an unmarked one too. Seeing it never opens the code: a file
+         *     opens in Storage only for someone Storage lets read it.
+         */
+        get: operations["getSoftwareProject"];
+        put?: never;
+        post?: never;
+        /**
+         * Unmark a software project
+         * @description THE FOLDER IS UNTOUCHED: it stays in Storage with its code and versions, and is no longer a
+         *     software project, so it may be marked again. The project is archived, and its builds,
+         *     checks, screens and releases stay readable to whoever could read them.
+         *
+         *     UNMARKING ONE ALREADY UNMARKED IS NOT AN ERROR: nothing is left to unmark.
+         */
+        delete: operations["unmarkSoftwareProject"];
+        options?: never;
+        head?: never;
+        /**
+         * Change a software project's settings
+         * @description NAME, STAGING SITE, PRODUCTION SITE, WHERE SCREENS COME FROM. Every field is optional; an
+         *     omitted field is untouched, and an explicit `null` clears a site.
+         *
+         *     NOT HERE: the folder (`chooseOwnFolderForSoftwareProject`), who looks after it
+         *     (`handOnSoftwareProject`), and GitHub (`connectSoftwareProjectToGitHub`), each an act of its
+         *     own.
+         *
+         *     AN UNMARKED PROJECT IS NOT CHANGED: 409 `software_project_unmarked`.
+         */
+        patch: operations["updateSoftwareProject"];
+        trace?: never;
+    };
+    "/software-projects/{software_project_id}/looked-after-by": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Hand on a software project
+         * @description WHO LOOKS AFTER IT changes to another member of the account environment, who takes
+         *     Administrator on the project with it. The one before steps down: their access on the project
+         *     becomes Editor, a share they were given included, because a person holds one grant on a
+         *     project (decision 0650). When the folder is their own, they still own it, so they keep full
+         *     rights over the project for as long as the folder is theirs.
+         *
+         *     HANDING IT TO THE PERSON WHO LOOKS AFTER IT NOW CHANGES NOTHING and refuses nothing.
+         *
+         *     SOMEONE WHO IS NOT A MEMBER IS REFUSED with a 422 on `/body/person_id`, code `not_a_member`.
+         *     An unmarked project is not handed on: 409 `software_project_unmarked`.
+         */
+        put: operations["handOnSoftwareProject"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects/{software_project_id}/github": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Connect a software project to a GitHub repository
+         * @description "CODE ALSO ON GITHUB": a GitHub connection the Integrations app holds, and the repository on
+         *     it. Connecting sends the code outside Onplo, so it is an act of its own, held from Manager up,
+         *     and using the connection is asked of the account environment as Integrations gives it.
+         *
+         *     CONNECTING AGAIN REPLACES the connection and the repository the project had.
+         *
+         *     A CONNECTION THAT IS NOT A GITHUB ONE, OR NOT USABLE HERE, is refused with a 422 on
+         *     `/body/connection_id`, code `github_connection_not_usable`. An unmarked project is not
+         *     connected: 409 `software_project_unmarked`.
+         */
+        put: operations["connectSoftwareProjectToGitHub"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects/{software_project_id}/own-folder": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Choose another folder of your own for a software project
+         * @description "FOLDER GONE — CHOOSE ANOTHER FOLDER OR UNMARK IT". Once Trash removes a project's folder for
+         *     good, the project asks for another. Choosing one asks the same as marking one: the right to
+         *     share the new folder. The project keeps its id, its name, its settings and its history; old
+         *     builds keep naming the folder they were built from.
+         *
+         *     ONLY A PROJECT IN A FOLDER OF YOUR OWN chooses one of yours. A company project chooses a
+         *     company folder (`chooseCompanyFolderForSoftwareProject`), and its id is not found here.
+         *
+         *     A PROJECT WHOSE FOLDER IS STILL THERE OR IN TRASH IS REFUSED with 409 `folder_still_there`:
+         *     it follows its folder, and a project is never pointed away from a folder that exists.
+         *     A folder that is not there is refused with `folder_not_found`, one already a software project
+         *     with `folder_already_a_software_project`, and nothing changes.
+         */
+        put: operations["chooseOwnFolderForSoftwareProject"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects/{software_project_id}/company-folder": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Choose another company folder for a software project
+         * @description The same act as `chooseOwnFolderForSoftwareProject`, for a company project and a company
+         *     folder, whose folder permission is "Set who may reach a company folder".
+         */
+        put: operations["chooseCompanyFolderForSoftwareProject"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects/{software_project_id}/grants": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Share a software project
+         * @description ONE OF FOUR ROLES — Viewer, Editor, Manager, Administrator — each the register's
+         *     `software.role.<this word>`. Commenter is not offered on a project, because comments live on
+         *     a build or a screen.
+         *
+         *     WITH A MEMBER OR A TEAM OF THIS ACCOUNT ENVIRONMENT. Nobody by that id here, or no such team,
+         *     is refused (409 `recipient_not_found`). SHARING WITH AN OUTSIDE TESTER IS NOT HERE YET: a
+         *     share outside the account environment asks Account's permission as well (decision 0658), so
+         *     `recipient.kind` has no word for an outside person until that half is declared.
+         *
+         *     SHARING AGAIN CHANGES THE SHARE THAT IS THERE. A holder has one grant per object (decision
+         *     0650), so a person or a team shared with again takes the new role and the new end and keeps
+         *     the id. `created` says which it was and the status is `200` either way.
+         *
+         *     `access_until` IS THE MOMENT THIS SHARE ENDS, and the time zone it was chosen in (decision
+         *     0650). Left out, the share has no end. A moment that has already passed is refused (422
+         *     naming `access_until`, `access_until_passed`).
+         *
+         *     NEVER AN AI AGENT'S TO DO, and never a raw key's: a share is a grant of access (403
+         *     `ring_requires_person`).
+         *
+         *     THE IDENTITY SERVICE KEEPS THE GRANT, AND WRITES IT ITSELF. When it cannot be reached, 503
+         *     `identity_unavailable`: whether the share landed is not known, so send the same request
+         *     again.
+         */
+        post: operations["shareSoftwareProject"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/software-projects/{software_project_id}/grants/{grant_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+                /** @description The id sharing the project answered. A share is a grant, and the identity service gives it its id. */
+                grant_id: components["parameters"]["SoftwareProjectShareId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * End a share of a software project
+         * @description THE ACCESS STOPS AT ONCE. The share is ended and never deleted, and ending one that has
+         *     already ended is not an error.
+         *
+         *     ENDED WHERE IT WAS PLACED, as a share is changed (409 `share_placed_elsewhere`). An id that
+         *     names no share reaching this project is the 404.
+         *
+         *     When the identity service cannot be reached, 503 `identity_unavailable`: whether the share
+         *     ended is not known, so send the same request again.
+         */
+        delete: operations["endSoftwareProjectShare"];
+        options?: never;
+        head?: never;
+        /**
+         * Change a share of a software project
+         * @description A DIFFERENT ROLE, OR A DIFFERENT END. Every field is optional; an omitted field is untouched,
+         *     and an explicit `null` on `access_until` removes the end. Both edits land or neither does.
+         *
+         *     CHANGED WHERE IT WAS PLACED. A role held across the whole account environment reaches the
+         *     project too, and is changed where it was given (409 `share_placed_elsewhere`). An id that
+         *     names no share reaching this project is the 404.
+         *
+         *     A SHARE THAT HAS ENDED IS NEVER BROUGHT BACK BY CHANGING ITS END (409 `share_ended`).
+         *
+         *     When the identity service cannot be reached, 503 `identity_unavailable`: whether the change
+         *     landed is not known, so send the same request again.
+         */
+        patch: operations["changeSoftwareProjectShare"];
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /**
+         * Format: uuid
+         * @description A UUID version 7 (RFC 9562) — sortable by creation, and never a counter. A software project's
+         *     id is its own, never its folder's: the project can outlive its folder and be given another.
+         * @example 019250e1-8f3c-7c21-9a4d-3a2f7b6c1d90
+         */
+        Id: string;
+        /**
+         * @description WHOSE FOLDERS THE PROJECT IS IN. `personal`: a folder of your own, so the project is yours.
+         *     `company`: a company folder, so the project is the company's; only in a business account
+         *     environment.
+         * @enum {string}
+         */
+        OwnerScope: "personal" | "company";
+        /**
+         * @description What the project is called on every page of Software. One line.
+         * @example Customer portal
+         */
+        SoftwareProjectName: string;
+        /**
+         * Format: uri
+         * @example https://www.example.com
+         */
+        SiteAddress: string;
+        /**
+         * @description Where the project's screens come from: its specification, a robot walking the staging site,
+         *     or both.
+         * @enum {string}
+         */
+        ScreensComeFrom: "specification" | "robot" | "both";
+        /**
+         * @description WHAT STORAGE LAST SAID OF THE PROJECT'S FOLDER. `there`: the folder is in Storage, wherever it
+         *     was moved and whatever it is called now. `in_trash`: "Folder in Trash" — no new build starts,
+         *     everything stays readable, and restoring the folder brings the project back as it was.
+         *     `gone`: Trash removed it for good — "choose another folder or unmark it".
+         * @enum {string}
+         */
+        FolderState: "there" | "in_trash" | "gone";
+        /**
+         * @description The repository on GitHub, as GitHub writes it, `owner/name`.
+         * @example example-org/customer-portal
+         */
+        GitHubRepository: string;
+        /**
+         * @description A STORAGE FOLDER MARKED AS A SOFTWARE PROJECT, and the project's own settings. Nothing of the
+         *     folder's is here: its name, its place and its files are Storage's to answer.
+         */
+        SoftwareProject: {
+            id: components["schemas"]["Id"];
+            name: components["schemas"]["SoftwareProjectName"];
+            /** @description The Storage folder the code is in, by its id. A move or a rename keeps it. */
+            folder_id: components["schemas"]["Id"];
+            folder_state: components["schemas"]["FolderState"];
+            owner_scope: components["schemas"]["OwnerScope"];
+            /** @description Where builds are tried before release. `null` when none is set. */
+            staging_site: components["schemas"]["SiteAddress"] | null;
+            /** @description The address people use. `null` when none is set. */
+            production_site: components["schemas"]["SiteAddress"] | null;
+            screens_come_from: components["schemas"]["ScreensComeFrom"];
+            /** @description The member who looks after the project and holds Administrator on it. `null` once that person asked to be forgotten: the project stays the company's and names nobody until it is handed on. */
+            looked_after_by: components["schemas"]["Id"] | null;
+            /** @description "Code also on GitHub": the repository it is connected to. `null` when it is not. */
+            github_repository: components["schemas"]["GitHubRepository"] | null;
+            /** @description `true` once the project is unmarked: archived, and read and nothing else. */
+            unmarked: boolean;
+            /** @description When the folder was marked. */
+            created_at: components["schemas"]["Timestamp"];
+        };
+        /** @description Which folder becomes a software project, and what the project is called. */
+        NewSoftwareProject: {
+            /** @description The Storage folder, by its id. */
+            folder_id: components["schemas"]["Id"];
+            name: components["schemas"]["SoftwareProjectName"];
+        };
+        /** @description A new name, sites, or where screens come from. At least one. */
+        SoftwareProjectUpdate: {
+            name?: components["schemas"]["SoftwareProjectName"];
+            /** @description A new staging site, or `null` to clear it. */
+            staging_site?: components["schemas"]["SiteAddress"] | null;
+            /** @description A new production site, or `null` to clear it. */
+            production_site?: components["schemas"]["SiteAddress"] | null;
+            screens_come_from?: components["schemas"]["ScreensComeFrom"];
+        };
+        SoftwareProjectHandOn: {
+            /** @description The member who looks after the project from now on. */
+            person_id: components["schemas"]["Id"];
+        };
+        /** @description Which GitHub connection the code goes out through, and to which repository on it. */
+        GitHubRepositoryChoice: {
+            /** @description A GitHub connection the Integrations app holds, by its id. */
+            connection_id: components["schemas"]["Id"];
+            repository: components["schemas"]["GitHubRepository"];
+        };
+        FolderChoice: {
+            /** @description The Storage folder the project is in from now on, by its id. */
+            folder_id: components["schemas"]["Id"];
+        };
+        /**
+         * @description WHO A PROJECT IS SHARED WITH, by id and never by name: a member of this account environment,
+         *     or one of its teams. The outside tester is not here yet (`shareSoftwareProject` says why).
+         */
+        SoftwareProjectShareRecipient: {
+            /** @enum {string} */
+            kind: "person" | "team";
+            id: components["schemas"]["Id"];
+        };
+        /**
+         * @description WHAT A SHARE LETS ITS HOLDER DO — the ladder every app has (decision 0969), each the
+         *     register's `software.role.<this word>`. No Commenter: comments live on a build or a screen.
+         * @enum {string}
+         */
+        SoftwareProjectShareRole: "viewer" | "editor" | "manager" | "administrator";
+        /**
+         * @description WHEN A SHARE ENDS: A MOMENT AND THE TIME ZONE IT WAS CHOSEN IN (decision 0650). The shape is
+         *     Storage's `AccessUntil`, key for key, so a share reads the same in every app.
+         */
+        SoftwareProjectShareAccessUntil: {
+            /**
+             * Format: date-time
+             * @description The moment the share ends, RFC 3339 with its offset written out. A request may write
+             *     it in any offset; an answer writes it in UTC, as every moment here is.
+             * @example 2026-11-03T16:00:00Z
+             */
+            at: string;
+            /**
+             * @description The IANA time zone the moment was chosen in.
+             * @example Europe/Brussels
+             */
+            zone: string;
+        };
+        /**
+         * @description ONE SHARE OF ONE SOFTWARE PROJECT. It is a grant the identity service keeps, so every field
+         *     of it is that service's answer and Software stores none of it.
+         */
+        SoftwareProjectShare: {
+            /** @description The grant's id, given by the identity service. */
+            id: components["schemas"]["Id"];
+            /** @description The project the share was placed on. */
+            software_project_id: components["schemas"]["Id"];
+            recipient: components["schemas"]["SoftwareProjectShareRecipient"];
+            role: components["schemas"]["SoftwareProjectShareRole"];
+            /** @description `null` when the share has no end. */
+            access_until: components["schemas"]["SoftwareProjectShareAccessUntil"] | null;
+            /** @description When it was first given. A later change leaves this as it was. */
+            created_at: components["schemas"]["Timestamp"];
+        };
+        /** @description What sharing a project answers — the share, and whether this request made it. */
+        PlacedSoftwareProjectShare: {
+            share: components["schemas"]["SoftwareProjectShare"];
+            /**
+             * @description `true` when this request made the share. `false` when the person or team already held
+             *     one placed on this project and this request changed it: the id is the one they had.
+             */
+            created: boolean;
+        };
+        /** @description Who to share the project with, what they may do, and when it ends. */
+        NewSoftwareProjectShare: {
+            recipient: components["schemas"]["SoftwareProjectShareRecipient"];
+            role: components["schemas"]["SoftwareProjectShareRole"];
+            /** @description Left out or `null`, the share has no end. */
+            access_until?: components["schemas"]["SoftwareProjectShareAccessUntil"] | null;
+        };
+        /** @description A different role, a different end, or both. At least one. */
+        SoftwareProjectShareChange: {
+            role?: components["schemas"]["SoftwareProjectShareRole"];
+            /** @description A new end, or `null` to remove the end. Left out, the end is untouched. */
+            access_until?: components["schemas"]["SoftwareProjectShareAccessUntil"] | null;
+        };
+        /**
+         * Format: date-time
+         * @description RFC 3339, always UTC, always with the offset written out.
+         * @example 2026-09-13T06:06:00Z
+         */
+        Timestamp: string;
+        /**
+         * @description Pass it as `cursor` for the next page. `null` means this was the last page — the only
+         *     honest end signal, because a short page is not one.
+         */
+        NextCursor: string | null;
+        /**
+         * @description RFC 9457. Served as `application/problem+json`, on every failure, from every operation —
+         *     one shape to handle rather than one per endpoint. CLOSED, like every other object here:
+         *     the server validates its own answers against this schema, and an open object is the one
+         *     shape that check cannot see through.
+         */
+        Problem: {
+            /**
+             * Format: uri
+             * @description A stable URI naming the kind of problem. Dereferenceable; documentation lives there.
+             * @example https://onplo.com/problems/folder_already_a_software_project
+             */
+            type: string;
+            /** @example This folder is a software project already */
+            title: string;
+            status: number;
+            /** @description What went wrong THIS time, in a sentence a person could be shown. */
+            detail?: string;
+            /**
+             * Format: uri-reference
+             * @description The request path this happened on.
+             */
+            instance?: string;
+            /**
+             * @description The machine name, stable across wording changes. `type` is the URI a human opens; this
+             *     is what a client branches on.
+             * @example folder_already_a_software_project
+             */
+            code: string;
+            /**
+             * Format: uuid
+             * @description Quote it in a support request and the exact call can be found. It is also on the
+             *     `Onplo-Request-Id` response header of every response, failed or not.
+             */
+            request_id: string;
+            /** @description One entry per field that is wrong. REQUIRED on a 422. */
+            errors?: {
+                /**
+                 * @description A JSON Pointer (RFC 6901) at the wrong value, rooted at the REQUEST: `/body/...`
+                 *     for a body field, `/query/...` for a query parameter, `/path/...` for a path
+                 *     segment.
+                 * @example /body/name
+                 * @example /query/limit
+                 */
+                pointer: string;
+                code: string;
+                detail: string;
+            }[];
+        };
+    };
+    responses: {
+        /**
+         * @description The request could not be read, so nothing in it was looked at — `malformed_request`. Its body
+         *     is not valid JSON, or its address carries a broken `%`-escape. No field is named, because
+         *     none was read. Declared on every operation, the ones that take no body included: a body is
+         *     read before the server knows which operation it was sent to.
+         */
+        BadRequest: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "malformed_request";
+                };
+            };
+        };
+        /**
+         * @description There is no usable credential on this call — it is missing, malformed, unknown, expired, or
+         *     it has been REVOKED. A revoked credential fails HERE and not with 403, because it is no
+         *     longer a credential.
+         */
+        Unauthorized: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                "WWW-Authenticate": components["headers"]["WwwAuthenticate"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "credential_missing" | "credential_malformed" | "credential_unknown" | "credential_expired" | "credential_revoked";
+                };
+            };
+        };
+        /**
+         * @description The credential is good and this call is refused anyway. `permission_missing`: the
+         *     credential does not carry the permission this operation needs, on this software project —
+         *     and that is the answer whether or not the project exists, so a refusal never tells you one
+         *     does. `ring_requires_person`: a ring-1 act attempted by a raw key or an agent, refused
+         *     regardless of scopes; sharing a project is one. `outside_session_scope`: allowed to this
+         *     subject and not within the scope this session declared at sign-in.
+         *
+         *     ONE COMPONENT ON EVERY OPERATION. THE ENUM IS THE UNION ACROSS EVERY ONPLO CONTRACT, so a
+         *     client writes one branch.
+         */
+        Forbidden: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "permission_missing" | "ring_requires_person" | "outside_session_scope";
+                };
+            };
+        };
+        /**
+         * @description No such thing, for a caller who was allowed to ask. A caller who was not is answered 403,
+         *     the same whether the thing exists or not, so neither answer tells somebody a project
+         *     exists that they hold no role on.
+         */
+        NotFound: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                "Cache-Control": components["headers"]["CacheControl"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "not_found";
+                };
+            };
+        };
+        /**
+         * @description The request body is larger than this API reads — `request_too_large`. `detail` names the
+         *     limit in bytes. Declared on every operation, for the reason `BadRequest` gives. This API never
+         *     takes a file: the code stays in Storage.
+         */
+        ContentTooLarge: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "request_too_large";
+                };
+            };
+        };
+        /**
+         * @description The request body is in a form this API does not read — `unsupported_media_type`. This API
+         *     reads JSON, sent uncompressed as `application/json`, and nothing else.
+         */
+        UnsupportedMediaType: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "unsupported_media_type";
+                };
+            };
+        };
+        /**
+         * @description The request parsed and something in it is wrong. `errors` says what, one entry per field,
+         *     each with a JSON Pointer at it. ONE `code`, because the detail is in `errors`.
+         */
+        Unprocessable: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "unprocessable_request";
+                };
+            };
+        };
+        /**
+         * @description Something failed that this contract cannot describe — including an answer this API produced
+         *     and then refused to send, because the contract does not describe that answer either
+         *     (`response_not_in_contract`). Response validation stays on in production (decision 0551).
+         *     `request_id` is what finds the call.
+         */
+        ServerError: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "internal_error" | "response_not_in_contract";
+                };
+            };
+        };
+        /**
+         * @description The authorization service could not be asked, so whether this credential carries the
+         *     permission is UNKNOWN — `authorization_unavailable`. Never a 403, which would claim the
+         *     credential lacks the permission when all that is known is that we could not ask.
+         */
+        ServiceUnavailable: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "authorization_unavailable";
+                };
+            };
+        };
+        /**
+         * @description One of two things could not be reached. `authorization_unavailable`: the authorization
+         *     service could not be asked, so whether this credential carries the permission is unknown,
+         *     and nothing was written. `identity_unavailable`: the call was allowed, and the identity
+         *     service, which writes a share's grant itself, could not then be asked to write it. Whether
+         *     the share changed is NOT KNOWN, so send the same request again: it is the same act, and its
+         *     answer says how the share stands. The three operations on a project's share answer this in
+         *     place of the shared `503`.
+         */
+        IdentityUnavailable: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "authorization_unavailable" | "identity_unavailable";
+                };
+            };
+        };
+        /**
+         * @description **Onplo has not built this operation yet** — `not_implemented` (decision 0580). It is
+         *     declared here because the contract is written before the code; it is not a 404, because the
+         *     address is right, and not a 503, because there is nothing to retry. Treat the operation as
+         *     absent for now. Nothing about your credential or your request caused this.
+         */
+        NotImplemented: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                "Cache-Control": components["headers"]["CacheControl"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "not_implemented";
+                };
+            };
+        };
+        /**
+         * @description Refused, and nothing is made: the folder is not there (`folder_not_found`), or it is a
+         *     software project already (`folder_already_a_software_project`).
+         */
+        MarkRefused: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "folder_not_found" | "folder_already_a_software_project";
+                };
+            };
+        };
+        /**
+         * @description Refused, and nothing is made: the folder is not there (`folder_not_found`), it is a software
+         *     project already (`folder_already_a_software_project`), or this account environment is a
+         *     personal one, with no company folders (`company_project_in_a_personal_environment`).
+         */
+        CompanyMarkRefused: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "folder_not_found" | "folder_already_a_software_project" | "company_project_in_a_personal_environment";
+                };
+            };
+        };
+        /** @description Refused, and nothing changed: the project is unmarked, and an archived project is read and nothing else (`software_project_unmarked`). */
+        ProjectUnmarked: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "software_project_unmarked";
+                };
+            };
+        };
+        /**
+         * @description Refused, and nothing changed: the project's folder is still there or in Trash, and the
+         *     project follows it (`folder_still_there`); the folder chosen is not there
+         *     (`folder_not_found`) or is a software project already (`folder_already_a_software_project`);
+         *     or the project is unmarked (`software_project_unmarked`).
+         */
+        FolderChoiceRefused: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "folder_still_there" | "folder_not_found" | "folder_already_a_software_project" | "software_project_unmarked";
+                };
+            };
+        };
+        /**
+         * @description One of three things could not be asked, and in each NOTHING WAS MADE.
+         *     `authorization_unavailable`: what this credential may do is unknown. `storage_unavailable`:
+         *     the Storage app, which says whether the folder is there and holds it for the project.
+         *     `identity_unavailable`: the identity service, which is told the project exists. The same
+         *     request can be sent again.
+         */
+        MarkUnavailable: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "authorization_unavailable" | "storage_unavailable" | "identity_unavailable";
+                };
+            };
+        };
+        /**
+         * @description One of two things could not be asked, and in both NOTHING CHANGED.
+         *     `authorization_unavailable`: what this credential may do is unknown. `storage_unavailable`:
+         *     the Storage app, which says whether the folder chosen is there and holds it for the project.
+         *     The same request can be sent again.
+         */
+        StorageUnavailable: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "authorization_unavailable" | "storage_unavailable";
+                };
+            };
+        };
+        /**
+         * @description One of two things could not be asked, and in both NOTHING CHANGED.
+         *     `authorization_unavailable`: what this credential may do is unknown.
+         *     `integrations_unavailable`: the Integrations app, which says whether the connection may be
+         *     used and keeps its list of what uses it. The same request can be sent again.
+         */
+        IntegrationsUnavailable: {
+            headers: {
+                "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": components["schemas"]["Problem"] & {
+                    /** @enum {unknown} */
+                    code?: "authorization_unavailable" | "integrations_unavailable";
+                };
+            };
+        };
+    };
+    parameters: {
+        /** @description How many to return. */
+        Limit: number;
+        /**
+         * @description The `next_cursor` of the previous page. Opaque on purpose — its contents are the server's
+         *     business and change without notice.
+         */
+        Cursor: string;
+        /** @description Only projects in folders of your own, or only the company's. Left out, both. */
+        OwnerScopeFilter: components["schemas"]["OwnerScope"];
+        /** @description List unmarked projects too, each carrying that it is unmarked. */
+        IncludeUnmarked: boolean;
+        SoftwareProjectId: components["schemas"]["Id"];
+        /** @description The id sharing the project answered. A share is a grant, and the identity service gives it its id. */
+        SoftwareProjectShareId: components["schemas"]["Id"];
+    };
+    requestBodies: never;
+    headers: {
+        /**
+         * @description The id of this call. Minted by the server as a UUID version 7 and **never taken from a
+         *     request header** (decision 0553). It rides EVERY response, and it is the same value as the
+         *     problem document's `request_id` when there is one. Quote it in a support request and the
+         *     exact call can be found.
+         */
+        OnploRequestId: string;
+        /**
+         * @description The challenge RFC 9110 §11.6.1 and RFC 6750 §3 require on a 401 under a bearer scheme
+         *     (decision 0569). `Bearer realm="onplo"` alone when no credential was sent; otherwise
+         *     `Bearer realm="onplo", error="invalid_token"`. It never carries `error_description` and never
+         *     `scope`. A 403 carries no challenge at all.
+         */
+        WwwAuthenticate: string;
+        /**
+         * @description `no-store`, on the statuses RFC 9110 §15.1 makes cacheable by default — a 404 and a 501
+         *     (decision 0580). A cached "not built yet" would outlive the day the operation is built, and
+         *     a cached "no such project" the day the project is shared with you.
+         */
+        CacheControl: "no-store";
+    };
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    listSoftwareProjects: {
+        parameters: {
+            query?: {
+                /** @description How many to return. */
+                limit?: components["parameters"]["Limit"];
+                /**
+                 * @description The `next_cursor` of the previous page. Opaque on purpose — its contents are the server's
+                 *     business and change without notice.
+                 */
+                cursor?: components["parameters"]["Cursor"];
+                /** @description Only projects in folders of your own, or only the company's. Left out, both. */
+                owner_scope?: components["parameters"]["OwnerScopeFilter"];
+                /** @description List unmarked projects too, each carrying that it is unmarked. */
+                include_unmarked?: components["parameters"]["IncludeUnmarked"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The software projects. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["SoftwareProject"][];
+                        next_cursor: components["schemas"]["NextCursor"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    markOwnFolderAsSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["NewSoftwareProject"];
+            };
+        };
+        responses: {
+            /** @description The software project, as it now stands. */
+            201: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            409: components["responses"]["MarkRefused"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["MarkUnavailable"];
+        };
+    };
+    markCompanyFolderAsSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["NewSoftwareProject"];
+            };
+        };
+        responses: {
+            /** @description The software project, as it now stands. */
+            201: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            409: components["responses"]["CompanyMarkRefused"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["MarkUnavailable"];
+        };
+    };
+    getSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The software project. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    unmarkSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The folder is no longer a software project. */
+            204: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    updateSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SoftwareProjectUpdate"];
+            };
+        };
+        responses: {
+            /** @description The software project as it now stands. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["ProjectUnmarked"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["ServiceUnavailable"];
+        };
+    };
+    handOnSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SoftwareProjectHandOn"];
+            };
+        };
+        responses: {
+            /** @description The software project, looked after by the person named. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["ProjectUnmarked"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["IdentityUnavailable"];
+        };
+    };
+    connectSoftwareProjectToGitHub: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GitHubRepositoryChoice"];
+            };
+        };
+        responses: {
+            /** @description The software project, connected. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["ProjectUnmarked"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["IntegrationsUnavailable"];
+        };
+    };
+    chooseOwnFolderForSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["FolderChoice"];
+            };
+        };
+        responses: {
+            /** @description The software project, in its new folder. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["FolderChoiceRefused"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["StorageUnavailable"];
+        };
+    };
+    chooseCompanyFolderForSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["FolderChoice"];
+            };
+        };
+        responses: {
+            /** @description The software project, in its new folder. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProject"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["FolderChoiceRefused"];
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["StorageUnavailable"];
+        };
+    };
+    shareSoftwareProject: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["NewSoftwareProjectShare"];
+            };
+        };
+        responses: {
+            /** @description The share as it now stands, and whether this request made it. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PlacedSoftwareProjectShare"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            /** @description Refused: nobody by that id, or no such team, in this account environment (`recipient_not_found`). Nothing was shared. */
+            409: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["Problem"] & {
+                        /** @enum {unknown} */
+                        code?: "recipient_not_found";
+                    };
+                };
+            };
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["IdentityUnavailable"];
+        };
+    };
+    endSoftwareProjectShare: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+                /** @description The id sharing the project answered. A share is a grant, and the identity service gives it its id. */
+                grant_id: components["parameters"]["SoftwareProjectShareId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Ended. */
+            204: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            /** @description Refused: the access was given across the whole account environment and is ended there (`share_placed_elsewhere`). Nothing was changed. */
+            409: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["Problem"] & {
+                        /** @enum {unknown} */
+                        code?: "share_placed_elsewhere";
+                    };
+                };
+            };
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["IdentityUnavailable"];
+        };
+    };
+    changeSoftwareProjectShare: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                software_project_id: components["parameters"]["SoftwareProjectId"];
+                /** @description The id sharing the project answered. A share is a grant, and the identity service gives it its id. */
+                grant_id: components["parameters"]["SoftwareProjectShareId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SoftwareProjectShareChange"];
+            };
+        };
+        responses: {
+            /** @description The share as it now stands. */
+            200: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SoftwareProjectShare"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            /**
+             * @description Refused, and nothing was changed: the access was given across the whole account
+             *     environment and is changed there (`share_placed_elsewhere`), or the share has ended
+             *     (`share_ended`).
+             */
+            409: {
+                headers: {
+                    "Onplo-Request-Id": components["headers"]["OnploRequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["Problem"] & {
+                        /** @enum {unknown} */
+                        code?: "share_placed_elsewhere" | "share_ended";
+                    };
+                };
+            };
+            413: components["responses"]["ContentTooLarge"];
+            415: components["responses"]["UnsupportedMediaType"];
+            422: components["responses"]["Unprocessable"];
+            500: components["responses"]["ServerError"];
+            501: components["responses"]["NotImplemented"];
+            503: components["responses"]["IdentityUnavailable"];
+        };
+    };
+}