@pipelex/sdk 0.59.0 → 0.61.0

package/README.md

@@ -177,7 +177,18 @@ const copy = await client.copyMethod(
   { idempotencyKey: crypto.randomUUID() },
 );
 if (copy.outcome === "copied") console.log(copy.method.copied_from); // the original it names
-const copies = await client.listMethodCopies(created.method_id); // where the copies went
+
+// The template catalog: the public methods every organization reads, in the platform's order, with
+// the categories that have a template and each card's thumbnails behind short-lived links.
+const templates = await client.listMethodTemplates({ category: "human-resources", limit: 8 });
+for (const tab of templates.categories) console.log(tab.slug, tab.label);
+// Another organization's public method reads in a narrower shape, its latest published version
+// and no draft: `updated_at` is what tells it from one of your own.
+const first = templates.items[0];
+const template = first === undefined ? undefined : await client.getMethod(first.method_id);
+if (template !== undefined && !("updated_at" in template)) {
+  console.log(template.latest_published.categories);
+}
 
 // The organization's files, newest first: uploads, test files and the files runs made. Each row's
 // `uri` goes into a run's inputs as any address does. A filtered page can be empty and still carry
@@ -285,7 +296,8 @@ These pages ship inside the published package, so a reader who has only installe
 | [`docs/method-trees.md`](./docs/method-trees.md) | A method's tree: the four forms a run, a validation, a save and the crate routes take it in (a directory on disk among them), how it travels inline or by hash and what is uploaded, the files a step reads, the template check's warnings and which step reads which file of the tree, the deployment's limits, the read's listing with its links, `writeMethodTree`, and `MethodFileTransferError` |
 | [`docs/files.md`](./docs/files.md) | An organization's files: `listFiles` and `iterateFiles`, the row, the whole record and its provenance, the query and its repeated filters, paging through filtered pages, one file and its uses, the records of an address, the rename rule, links that name the file, a zip of files and its caps, a run's files, the copy into a method's draft, and an upload recorded as a method's test file with the refusals that come with it |
 | [`docs/method-examples.md`](./docs/method-examples.md) | A method's saved examples: the create, the paged list and its iterator, the edit that raises the input revision, the latest-run write and its `recorded` or `stale` verdict, the build assistant's save and its `kept` or `created` verdict, how an integer past `Number.MAX_SAFE_INTEGER` in the inputs stays exact, and what is refused before sending |
-| [`docs/method-copy.md`](./docs/method-copy.md) | Copying a method into another organization or duplicating it: what a copy holds and the stored files it copies, the `copied` or `refused` verdict, every refusal, the copy's idempotency key, the copies a method lists, and `copied_from` |
+| [`docs/method-copy.md`](./docs/method-copy.md) | Copying a method into another organization or duplicating it: what a copy holds and the stored files it copies, the `copied` or `refused` verdict, every refusal, the copy's idempotency key, and `copied_from` |
+| [`docs/public-methods.md`](./docs/public-methods.md) | Public methods and the template catalog: `listMethodTemplates` and its iterator, the ordering, the categories and the thumbnails' links, another organization's public method read in its narrower shape, the copy of a public method, `visibility` and `categories` on a method, and the refusals a public method's publish adds |
 | [`docs/organization-branding.md`](./docs/organization-branding.md) | An organization's logos and colours: `getBranding`, which every member and API key reads, `updateOrganizationBranding`, an admin's write that sets, clears or keeps each key, and how a refused logo or colour names its slot in `errors` so a settings screen shows the sentence under it |
 | [`docs/exact-integers.md`](./docs/exact-integers.md) | Which reads keep an integer past `Number.MAX_SAFE_INTEGER` exact, as a `bigint` (a run's inputs and outputs, an example's inputs), how a request body writes it back with its digits, and `parseExactJson` and `stringifyExactJson` for code showing such data as JSON text |
 | [`docs/crate-routes.md`](./docs/crate-routes.md) | `resolve`, `codegen` and `pipeIo` — the method's tree as the protocol's `files` map, with its dependencies, the normalized crate, the stamped types, and a method's I/O artifacts without a validation — and the offline `runCodegenCheck` that guards a committed tree |

package/dist/cli/script.d.ts

@@ -15,7 +15,7 @@ import type { CommandIO } from "./io.js";
  * update notice and npm 12's run notices off the script's stderr, which carries the command's
  * own lines, while npm's warnings and errors still print.
  */
-export declare const SCRIPT_RUNNER = "npx --yes --no-update-notifier --loglevel=warn @pipelex/sdk@0.59.0";
+export declare const SCRIPT_RUNNER = "npx --yes --no-update-notifier --loglevel=warn @pipelex/sdk@0.61.0";
 export declare const SCRIPT_WRITER = "@pipelex/sdk";
 export declare const SCRIPT_NEEDS = "Node 22.12 or later";
 /** Run `pipelex-sdk script` and return its exit code. */

package/dist/client.d.ts

@@ -1,10 +1,10 @@
 import type { MTHDSProtocol, ModelCategory, ModelDeck, RunOptions, StartOptions, VersionInfo } from "mthds/protocol";
 import type { CodegenRequest, CodegenResponse, CrateRouteOptions, DictPipeOutput, FormatResponse, LintResponse, ModelCheckCategory, ModelReferenceVerdict, PipeIORequest, PipeIOResponse, PipelexRunResultStart, PipelexValidateSource, PipelexValidationResult, ResolveRequest, ResolveResponse, ValidateMethodSelector } from "./models.js";
 import { type GetRunResultOptions, type RunProgress, type RunRead, type RunResults, type RunResultState, type StartAndWaitForResultOptions, type WaitForResultOptions } from "./runs.js";
-import type { BillingPortalResponse, ChangePlanResponse, CheckoutResponse, DraftFileFromFileInput, DraftFileFromFileResult, FileArchive, FileArchiveRequest, FileDetail, FileLinkTarget, FileLinksResult, FilePage, FileRecord, FileRecordList, FileRenameInput, FileSummary, GetFileQuery, GetFilesByUriOptions, InvoiceView, Membership, MembershipsResponse, OrganizationBranding, OrganizationBrandingUpdate, ListFilesQuery, ListMethodCopiesQuery, ListMethodExamplesQuery, ListMethodsQuery, ListMethodVersionsQuery, ListRunFilesQuery, MethodCopyInput, MethodCopyPage, MethodCopyResult, MethodData, MethodDeletionAccepted, MethodDetail, MethodDraftInput, MethodExample, MethodExampleAssistantSaveInput, MethodExampleAssistantSaveResult, MethodExampleCreateInput, MethodExampleLatestRunInput, MethodExampleLatestRunResult, MethodExamplePage, MethodExampleUpdateInput, MethodPage, MethodPublishInput, MethodPublishResult, MethodRenameInput, MethodSummary, MethodVersion, MethodVersionPage, MethodWriteInput, OnboardingSubmission, PipelexApiKeyCreated, PipelexApiKeyList, ListRunsQuery, RunHistoryItem, RunDetail, RunFilesPage, RunPage, PlanView, ResolvedStorageUrl, SavedMethodFile, SubscriptionResponse, UpdateRunInput, UploadGrant, UploadGrantInput, UploadInput, UploadedFile, UserProfile } from "./product-models.js";
+import type { BillingPortalResponse, ChangePlanResponse, CheckoutResponse, DraftFileFromFileInput, DraftFileFromFileResult, FileArchive, FileArchiveRequest, FileDetail, FileLinkTarget, FileLinksResult, FilePage, FileRecord, FileRecordList, FileRenameInput, FileSummary, GetFileQuery, GetFilesByUriOptions, InvoiceView, Membership, MembershipsResponse, OrganizationBranding, OrganizationBrandingUpdate, ListFilesQuery, ListMethodExamplesQuery, ListMethodsQuery, ListMethodTemplatesQuery, ListMethodVersionsQuery, ListRunFilesQuery, MethodCopyInput, MethodCopyResult, MethodData, MethodDeletionAccepted, MethodDetail, MethodDraftInput, MethodExample, MethodExampleAssistantSaveInput, MethodExampleAssistantSaveResult, MethodExampleCreateInput, MethodExampleLatestRunInput, MethodExampleLatestRunResult, MethodExamplePage, MethodExampleUpdateInput, MethodPage, MethodPublishInput, MethodPublishResult, MethodRenameInput, MethodSummary, MethodTemplate, MethodTemplatePage, MethodVersion, MethodVersionPage, MethodWriteInput, OnboardingSubmission, PublicMethodDetail, PipelexApiKeyCreated, PipelexApiKeyList, ListRunsQuery, RunHistoryItem, RunDetail, RunFilesPage, RunPage, PlanView, ResolvedStorageUrl, SavedMethodFile, SubscriptionResponse, UpdateRunInput, UploadGrant, UploadGrantInput, UploadInput, UploadedFile, UserProfile } from "./product-models.js";
 import type { MethodTreeForms, MethodTreeLimits } from "./method-trees.js";
 import type { AppInfo } from "./user-agent.js";
-import type { WebhookDeliveryDetail, WebhookDeliveryList, WebhookReplayAccepted, WebhookSecret, WebhookSecretRotateOptions } from "./webhooks.js";
+import type { WebhookDeliveryDetail, WebhookDeliveryList, WebhookReplayAccepted, WebhookReplayOptions, WebhookSecret, WebhookSecretRotateOptions } from "./webhooks.js";
 import type { UploadableAsset, UploadFileOptions, UploadRecord } from "./upload.js";
 import type { PrepareInputsRequest, PreparedInputs } from "./prepare-inputs.js";
 import type { BulkResolveStorageUrlsInput, BulkResolvedStorageUrls, DownloadArtifactsRequest, DownloadArtifactsResult, FetchArtifactOptions, ResolvedArtifact } from "./artifacts.js";
@@ -284,7 +284,8 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * `url` is a fully resolved absolute URL. `mayStartRun` marks a request that may create a run,
      * whose errors then say whether it may have (see `RunCreation`).
      * `idempotencyKey`, already checked by `idempotencyKeyOf`, is sent as the
-     * `Idempotency-Key` header; only `start` and `copyMethod` pass one.
+     * `Idempotency-Key` header; only `start`, `copyMethod`, `rotateWebhookSecret` and
+     * `replayRunWebhookDelivery` pass one.
      */
     private requestRaw;
     /**
@@ -614,10 +615,10 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      *
      * The mapping is what makes their no-verdict arms usable: a crate route answers `422`
      * for a request it cannot act on (a pipe selection `pipe-io` refuses; an unknown
-     * `kind`/`target`, or a `pipe_ref` on the concept-set-wide `types` kind, on `codegen`)
-     * and `501` for the reserved registry-form `method_ref` (the address form is resolved
-     * server-side as of pipelex-api 0.21.0). A caller branches on `ApiResponseError.status`,
-     * never on a message.
+     * `kind`/`target`, or a `pipe_ref` on the concept-set-wide `types` kind, on `codegen`;
+     * the reserved registry-form `method_ref`, coded `request.unsupported`, on all three, the
+     * address form being resolved server-side as of pipelex-api 0.21.0). A caller branches on
+     * the problem's `code`, never on a message.
      *
      * All of these are static and inference-free, so they default to the management-call
      * timeout. The internal raise is `crateRequestTimeoutMs`'s: the fetch-sized budget a
@@ -704,7 +705,7 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * protocol's `files` map or as a `directory`, `tree` or `contents` the client sends
      * inline when small and by hash otherwise (see {@link CrateRequestBase}); an
      * address-form `method_ref` (server-resolved, pipelex-api >= 0.21.0; the registry form
-     * stays a `501`); or a hosted `method_id` (platform-resolved — see
+     * is a `422` `request.unsupported`); or a hosted `method_id` (platform-resolved — see
      * {@link PipelexHostedToolingExtensions}). An empty map or string is absent.
      *
      * `options.signal` stops the call between the steps a `directory`, `tree` or `contents`
@@ -729,7 +730,8 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * Same 200-verdict discipline and same three-form closure selector as
      * {@link resolve}. Only a no-verdict condition throws `ApiResponseError`: an
      * unknown `kind`/`target`, a `pipe_ref` on the concept-set-wide `types` kind, or
-     * a malformed selector is a 422; a registry-form `method_ref` is a `501`.
+     * a malformed selector is a 422, and so is a registry-form `method_ref`, coded
+     * `request.unsupported`.
      */
     codegen(request: CodegenRequest, options?: CrateRouteOptions): Promise<CodegenResponse>;
     /**
@@ -760,9 +762,9 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * Only a no-verdict condition throws `ApiResponseError`: a malformed selector and an
      * over-limit file are `422` problems; a selection the route refuses is a `422` whose
      * `code` is `request.pipe_not_found` (an unknown `pipe_ref`), `request.pipe_unspecified`
-     * (no entry pipe) or `request.pipe_ambiguous` (an ambiguous code, several entry pipes), the
-     * candidates in its `params`; a registry-form `method_ref` is a `501`; a pipe whose
-     * artifacts cannot be derived is a `500`.
+     * (no entry pipe, or several bundles' `main_pipe` declarations) or `request.pipe_ambiguous`
+     * (an ambiguous bare code), the candidates in its `params`; a registry-form `method_ref` is a
+     * `422` `request.unsupported`; a pipe whose artifacts cannot be derived is a `500`.
      *
      * A `method_ref` gets the fetch-sized budget, as on the other crate routes. On the
      * hosted API the gateway caps a request at about 30 seconds whatever the client allows,
@@ -986,7 +988,49 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      */
     iterateMethods(query?: Omit<ListMethodsQuery, "cursor">): AsyncGenerator<MethodSummary, void, undefined>;
     /**
-     * Read one method with its draft's files — `GET /v1/methods/{id}`: its identity, its draft
+     * One page of the template catalog — `GET /v1/method-templates`: the public methods of the
+     * organization the deployment names as its templates organization, the same for every caller.
+     *
+     * The templates the ordering lists lead, in its order, and every other template follows by name.
+     * `ordering` names the ordering to serve, such as `default` or an arm of a test; an absent,
+     * unknown or malformed name serves `default`, and the page's `ordering` names the one served,
+     * `null` when there is none. `category` keeps one category's templates, by slug, in the same
+     * order; an unknown slug keeps none. Whatever the filter, the page's `categories` names, with its
+     * label, every category at least one template shows, in the catalog's order, so no tab drawn
+     * from it is ever empty.
+     *
+     * Each `MethodTemplate` carries the method's id and name, its latest published version's number,
+     * description and categories, its organization's display name and each thumbnail with its size
+     * and a link to its bytes valid for about fifteen minutes. A template reads, runs and copies by
+     * its `method_id`, as another organization's public method does (`getMethod`, `copyMethod`).
+     *
+     * Pass the page's `nextCursor` back as `cursor` with the same `ordering` and `category`, which the
+     * cursor does not hold; `null` is the last page. `iterateMethodTemplates` follows it for you.
+     *
+     * Throws `ApiResponseError`: `422` `request.invalid` for a `limit` outside 1 to 200 or a cursor of
+     * another listing, `422` `request.malformed` for a cursor that does not decode, `500`
+     * `runtime.misconfigured` when the templates organization the deployment names has no record or
+     * a link cannot be signed, and `503` `runtime.unavailable`, safe to retry. A page whose `items`
+     * or `categories` is not an array, whose `next_cursor` or `ordering` is neither a string nor
+     * `null`, a template lacking a member a card is drawn from (a string `method_id`, `name` and
+     * `organization_name`, a `description` that is a string or `null`, a positive integer
+     * `latest_version`, an array of string `categories`, and `thumbnails` each with a string `path`,
+     * `media_type`, `sha256`, `url` and `expires_at` and a positive integer `width` and `height`), and a
+     * category without a string `slug` and `label` are an answer the SDK cannot read, thrown as an
+     * `ApiResponseError` too, its links redacted.
+     */
+    listMethodTemplates(query?: ListMethodTemplatesQuery): Promise<MethodTemplatePage>;
+    /**
+     * Every template of the catalog, in the order served — follows `listMethodTemplates`'s cursor
+     * for you, with the same `ordering` and `category` on every page. It stops on a `null` cursor or
+     * on a cursor the server failed to advance, and throws `PagingNotTerminatingError` past a page
+     * ceiling no real catalog reaches. The ordering served and the categories are on each page, so
+     * read one page with `listMethodTemplates` when you need them.
+     */
+    iterateMethodTemplates(query?: Omit<ListMethodTemplatesQuery, "cursor">): AsyncGenerator<MethodTemplate, void, undefined>;
+    /**
+     * Read one method with its files — `GET /v1/methods/{id}`. One of the caller's organization's
+     * methods answers a `MethodDetail`: its identity, its draft
      * (`files`, `input_data`) with the draft's token (`updated_at`) and digest (`draft_digest`),
      * and its latest published version's summary (`latest_version`, `latest_published`), whatever
      * the publish state. A method never published reads with both `null`, never as an error.
@@ -994,6 +1038,11 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * link to its bytes valid for about fifteen minutes, and is empty for an empty draft;
      * `writeMethodTree` brings the tree to disk.
      *
+     * **Another organization's public method reads too, in a narrower shape**, a
+     * `PublicMethodDetail`: its latest published version, that version's description, categories
+     * and files, and nothing of its draft or of the owner's people, so no `updated_at` to write or
+     * publish with. Narrow the answer with `"updated_at" in method` before reading the draft.
+     *
      * Takes a bare catalog id: the method routes address the method itself, never a version of
      * it. A caller holding `mt_…@3` strips the suffix with `parseMethodSelector` and reads that
      * version with `getMethodVersion`. Every method route throws `RequestArgumentError` for a
@@ -1001,13 +1050,18 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * and for an id that is empty, `.` or `..`, which the URL would resolve into another route's
      * path.
      *
-     * Throws `ApiResponseError`: `404` `pipelex.catalog.not_found` for an unknown or foreign-org
-     * method, `409` `pipelex.catalog.being_deleted` while its erasure runs, and a `500`
-     * `runtime.unexpected` for a method whose draft names a tree the platform holds no record of. An
-     * answer whose `files` is not a listing is an answer the SDK cannot read, thrown as an
-     * `ApiResponseError` too.
+     * Throws `ApiResponseError`: `404` `pipelex.catalog.not_found` for an unknown method, for
+     * another organization's internal one, and for a public one made internal again or being
+     * erased; `409` `pipelex.catalog.being_deleted` while the erasure of the caller's own method
+     * runs; and a `500` `runtime.unexpected` for a method whose tree the platform holds no record
+     * of. An answer whose `files` is not a listing is an answer the SDK cannot read, thrown as an
+     * `ApiResponseError` too, its links redacted, and so is one that lacks `updated_at` while it
+     * carries a member only the owner's read has (`draft_digest`, `created_by_user_id`,
+     * `input_data`, `pipe_output`, `copied_from`, `deletion_state`), which would otherwise pass for
+     * another organization's public method, and a public read without an integer `latest_version`
+     * and a `latest_published` object.
      */
-    getMethod(methodId: string): Promise<MethodDetail>;
+    getMethod(methodId: string): Promise<MethodDetail | PublicMethodDetail>;
     /**
      * Create a method — `POST /v1/methods`. The new method holds its tree as its draft and has no
      * published version, so its bare id answers `409` `pipelex.catalog.not_published` on the run and
@@ -1237,9 +1291,12 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      *
      * The answer is a `MethodPublishResult` discriminated on `outcome` — branch on it:
      * `published` with the new `version`; `unchanged` with the existing latest `version`;
-     * `refused` with a `reason` (`invalid`, or `not_runnable` for a draft that validates with
-     * pending signatures), a `message` and the runner's `validation` verdict, whose problem items
-     * are read member by member as `validate` reads them. Every arm carries the `method`. A publish
+     * `refused` with a `reason`, a `message` and the runner's `validation` verdict, whose problem
+     * items are read member by member as `validate` reads them. The reason is `invalid`, or
+     * `not_runnable` for a draft that validates with pending signatures, and for a public method
+     * also `thumbnail_missing`, `thumbnail_invalid` or `storage_reference` (see
+     * `MethodPublishRefusalReason`); a reason this SDK does not know is passed through as its raw
+     * string, still a verdict, so show its `message`. Every arm carries the `method`. A publish
      * moves no token.
      *
      * Takes a bare catalog id, as `getMethod` does. Throws `RequestArgumentError` when
@@ -1254,11 +1311,14 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * cannot be reached, answers unusably or does not finish within the platform's deadline is a
      * `502` or a `503` with nothing written, so a retry is safe; a runner that refuses the request
      * itself is relayed under its own status. A retry of a publish that landed while its answer was
-     * lost, as on a client timeout, answers `unchanged` with the version it wrote.
+     * lost, as on a client timeout, answers `unchanged` with the version it wrote. A method made
+     * public while its publish ran is a `503` with nothing written, safe to retry, which a retry
+     * judges as a public method's publish.
      *
      * An answer whose `outcome` is not one of the outcomes above, that carries no `method` object,
-     * or a refusal whose `validation` is not a verdict object with a boolean `is_valid`, is an answer
-     * the SDK cannot read, thrown as an `ApiResponseError` too.
+     * or a refusal whose `reason` or `message` is not a string or whose `validation` is not a verdict
+     * object with a boolean `is_valid`, is an answer the SDK cannot read, thrown as an
+     * `ApiResponseError` too.
      */
     publishMethod(methodId: string, input: MethodPublishInput): Promise<MethodPublishResult>;
     /**
@@ -1267,11 +1327,13 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      *
      * Pass the page's `nextCursor` back as `cursor` to continue; `null` is the last page. A page
      * may be short while `nextCursor` is set, because the platform reads versions whole. A method
-     * never published answers an empty page.
+     * never published answers an empty page. Another organization's public method lists its
+     * versions too, each without its `published_by`.
      *
      * Takes a bare catalog id, as `getMethod` does. Throws `ApiResponseError`: `404`
-     * `pipelex.catalog.not_found` for an unknown method, `409` `pipelex.catalog.being_deleted`, and
-     * `422` `request.invalid` for a cursor the listing did not issue for this method or a `limit`
+     * `pipelex.catalog.not_found` for an unknown method and for another organization's internal
+     * one, `409` `pipelex.catalog.being_deleted` while the erasure of the caller's own method runs,
+     * and `422` `request.invalid` for a cursor the listing did not issue for this method or a `limit`
      * outside 1 to 100. A page whose `items` is not an array or whose `next_cursor` is neither a
      * string nor `null` is an answer the SDK cannot read, thrown as an `ApiResponseError` too.
      */
@@ -1279,12 +1341,15 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
     /**
      * One published version of a method, with its files — `GET /v1/methods/{id}/versions/{n}`.
      * `files` lists the version's tree as `getMethod` lists the draft's, each file with a link to
-     * its bytes valid for about fifteen minutes, which `writeMethodTree` writes to disk.
+     * its bytes valid for about fifteen minutes, which `writeMethodTree` writes to disk. Another
+     * organization's public method reads its versions too, without their `published_by`, the files
+     * linked in the organization that holds it.
      *
      * Takes a bare catalog id, as `getMethod` does, and the version number. Throws
      * `RequestArgumentError` for a `version` that is not a positive integer, before any request.
      * Throws `ApiResponseError`: `404` `pipelex.catalog.not_found` for a version the method never
-     * published and for an unknown method, `409` `pipelex.catalog.being_deleted`, and `500`
+     * published, for an unknown method and for another organization's internal one, `409`
+     * `pipelex.catalog.being_deleted` while the erasure of the caller's own method runs, and `500`
      * `runtime.unexpected` for a version stored before methods were trees and never rewritten as
      * one, which names no tree to serve.
      */
@@ -1301,10 +1366,16 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * original stays as it was. The copy takes the draft, never the latest published version; with
      * `expected_draft_updated_at`, it takes exactly the draft the caller last saw.
      *
+     * **Another organization's public method copies too**, a template of the catalog among them,
+     * from its latest published version rather than its draft: that version's tree, description and
+     * categories, and the method's examples, never the owner's form inputs, with `copied_from`
+     * naming the `version`. Leave `expected_draft_updated_at` out then: sent with such a method, it
+     * is refused with a `422` `request.invalid` naming it.
+     *
      * The answer is a `MethodCopyResult` discriminated on `outcome` — branch on it: `copied` with
      * the copy as `method`, `examples_copied` and `stored_files_copied`; `refused` with the
      * `reason` `bundle_names_other_storage`, a `message` and every `references` entry (`{ path, uri
-     * }`) a `.mthds` file of the draft holds that the destination cannot read and, in a duplicate,
+     * }`) a `.mthds` file of the tree holds that the destination cannot read and, in a duplicate,
      * that names a file under the original's run files, which erasing the original would remove,
      * nothing written.
      *
@@ -1323,7 +1394,8 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * that is not from a web session, or for a role that may not change methods, in the method's
      * organization or in the destination; `404` `pipelex.org.not_found` for a destination the
      * caller does not belong to, still being set up or unknown, alike; `404`
-     * `pipelex.catalog.not_found` for an unknown method; `409` `pipelex.catalog.being_deleted`;
+     * `pipelex.catalog.not_found` for an unknown method and for another organization's internal
+     * one; `409` `pipelex.catalog.being_deleted` while the erasure of the caller's own method runs;
      * `409` `pipelex.catalog.update_conflict` for a draft that moved since
      * `expected_draft_updated_at`; a `409` whose `domain` is `runtime` and `retry` `no`, for a
      * draft whose tree the method's organization holds no record of or no longer holds every file
@@ -1346,26 +1418,6 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * an `ApiResponseError` too.
      */
     copyMethod(methodId: string, input: MethodCopyInput, options?: MethodCopyRequestOptions): Promise<MethodCopyResult>;
-    /**
-     * One page of the copies made of a method, in the order of the copies' ids, which says nothing
-     * of when each was made — `GET /v1/methods/{id}/copies`.
-     *
-     * Each row is the `MethodCopyMarker` the original keeps of a copy: the copy's id, the
-     * destination's id, the member who made it and when. The destination is named by its id alone,
-     * never its name, so a surface shows a destination's name only from the reader's own
-     * memberships, and a copy in an organization the reader does not belong to stays a bare id. A
-     * marker stays when its copy is erased, and the copy then reads as not found. Pass the page's
-     * `nextCursor` back as `cursor` to continue; `null` is the last page. A method never copied,
-     * and a copy itself, answer an empty page. The listing is open to every member of the method's
-     * organization, a runner included, as every read of a method is.
-     *
-     * Takes a bare catalog id, as `getMethod` does. Throws `ApiResponseError`: `404`
-     * `pipelex.catalog.not_found` for an unknown method, `409` `pipelex.catalog.being_deleted`, and
-     * `422` `request.invalid` for a cursor the listing did not issue for this method or a `limit`
-     * outside 1 to 100. A page whose `items` is not an array or whose `next_cursor` is neither a
-     * string nor `null` is an answer the SDK cannot read, thrown as an `ApiResponseError` too.
-     */
-    listMethodCopies(methodId: string, query?: ListMethodCopiesQuery): Promise<MethodCopyPage>;
     /**
      * Erase a method and everything it produced — `DELETE /v1/methods/{id}`.
      *
@@ -2127,9 +2179,13 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      */
     listRunWebhookDeliveries(runId: string): Promise<WebhookDeliveryList>;
     /**
-     * One delivery of a run's webhooks, with its event as sent —
-     * `GET /v1/runs/{id}/webhook-deliveries/{delivery_id}`: the body of its latest attempt, which a
-     * receiver's log can be matched against byte for byte once written as compact JSON.
+     * One delivery of a run's webhooks, with its event —
+     * `GET /v1/runs/{id}/webhook-deliveries/{delivery_id}`: the body its latest attempt sent, or,
+     * before any attempt, the body its first attempt will send. Every attempt and replay of the
+     * delivery sends that body, only its `attempt` changing, so the event matches what a receiver
+     * logged only once an attempt was made: it then equals, as JSON, the body that attempt brought
+     * the receiver. Compare the two as parsed JSON values, never as text: the read promises the same
+     * value, not the same bytes.
      * `deliveryId` is the delivery's `delivery_id`, the receiver's `webhook-id`.
      *
      * Throws `RequestArgumentError` for an id that is empty, `.` or `..`, or holds a lone surrogate,
@@ -2147,16 +2203,27 @@ export declare class PipelexApiClient implements HostedProtocolSurface {
      * can read the run asks for one, an API key included, under the organization's replay rate.
      *
      * Answers the attempt number the replay is sent under; a replay asked again before it is sent is
-     * that same attempt. Throws `RequestArgumentError` for an id that is empty, `.` or `..`, or holds
-     * a lone surrogate, before any request. Throws `ApiResponseError`: `404` `run.not_found` for a
-     * run the caller cannot read; `422` `request.invalid` naming `delivery_id` for a delivery the run
-     * does not have; `409` `pipelex.org.not_manageable` with the reason `webhook_delivery_pending`
-     * for a delivery still on its retry schedule, or `webhook_delivery_attempts_exhausted` for one
-     * holding the most attempts a delivery holds; `429` `account.rate_limited`, with its
-     * `retry_after`, past the organization's replay rate; and a `500` or `503` when the replay could
-     * not be queued, which then counts nothing against the rate.
-     */
-    replayRunWebhookDelivery(runId: string, deliveryId: string): Promise<WebhookReplayAccepted>;
+     * that same attempt.
+     *
+     * `options.idempotencyKey` is sent as the `Idempotency-Key` header, and nothing is sent when it
+     * is absent or `null`. The platform stores the replay's answer under the key, so the same replay
+     * sent again under the same key, as after an answer lost to a time limit, gets the stored answer,
+     * naming the same attempt, and the delivery is not sent twice. A key reused for another request
+     * is refused `409` `request.idempotency_conflict`, and one whose earlier request is still being
+     * handled `409` `request.idempotency_key_in_use`, whose `retry` is `yes`: send it again under the
+     * same key after its `retry_after`. See `WebhookReplayOptions`.
+     *
+     * Throws `RequestArgumentError` for an id that is empty, `.` or `..`, or holds a lone surrogate,
+     * or for an idempotency key that is not 1 to 255 visible ASCII characters, before any request.
+     * Throws `ApiResponseError`: `404` `run.not_found` for a run the caller cannot read; `422`
+     * `request.invalid` naming `delivery_id` for a delivery the run does not have; `409`
+     * `pipelex.org.not_manageable` with the reason `webhook_delivery_pending` for a delivery still on
+     * its retry schedule, or `webhook_delivery_attempts_exhausted` for one holding the most attempts
+     * a delivery holds; `429` `account.rate_limited`, with its `retry_after`, past the
+     * organization's replay rate; and a `500` or `503` when the replay could not be queued, which
+     * then counts nothing against the rate.
+     */
+    replayRunWebhookDelivery(runId: string, deliveryId: string, options?: WebhookReplayOptions): Promise<WebhookReplayAccepted>;
     /** Patch a run's status (admin/manual) — `PUT /v1/runs/{id}`. */
     updateRun(runId: string, input: UpdateRunInput): Promise<void>;
     /**