@agentxm/registry-client 0.28.4-bootstrap.0

package/dist/src/__generated__/registry-client.js

@@ -0,0 +1,2270 @@
+/**
+ * @generated by registry-client:generate:registry-client (openapigen)
+ * Source:     packages/registry-client/specs/registry-openapi.json
+ * Regenerate: pnpm exec nx run registry-client:generate:registry-client
+ * DO NOT EDIT - changes are overwritten on regeneration.
+ */
+// @effect-diagnostics anyUnknownInErrorContext:off — generated OpenAPI transport errors are translated by the registry adapter
+/* eslint-disable */
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { DateTimeUtcSchema } from "@agentxm/extension-model/unstable/date-time";
+import * as Sse from "effect/unstable/encoding/Sse";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+export const MetaResponse = Schema.Struct({
+    ok: Schema.Literal(true),
+    service: Schema.Literal("registry"),
+    message: Schema.String.annotate({ description: "Human-readable service greeting." }),
+    docs: Schema.Union([
+        Schema.String.annotate({
+            description: "Path to the interactive API documentation, or null when docs are disabled.",
+            format: "uri-reference",
+        }),
+        Schema.Null,
+    ]),
+    openapi: Schema.Union([
+        Schema.String.annotate({
+            description: "Path to the OpenAPI specification, or null when docs are disabled.",
+            format: "uri-reference",
+        }),
+        Schema.Null,
+    ]),
+}).annotate({
+    title: "Meta Response",
+    description: "Registry service metadata including health status and documentation entry points.",
+    identifier: "MetaResponse",
+});
+export const DecodeErrorResponseEncoded = Schema.Struct({
+    kind: Schema.Literal("DecodeErrorResponse"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.String,
+}).annotate({ identifier: "DecodeErrorResponseEncoded" });
+export const DeviceCodeResponse = Schema.Struct({
+    device_code: Schema.String.annotate({
+        description: "Device verification code for the polling client.",
+    }),
+    user_code: Schema.String.annotate({ description: "Short code the user enters in the browser." }),
+    verification_uri: Schema.String.annotate({
+        description: "URI where the user should navigate to enter the user code.",
+        format: "uri",
+    }),
+    verification_uri_complete: Schema.String.annotate({
+        description: "URI with the one-time code in the user_code query parameter, suitable for QR codes or direct links.",
+        format: "uri",
+    }),
+    expires_in: Schema.Number.annotate({
+        description: "Lifetime of the device code in seconds.",
+    }).check(Schema.isInt().annotate({ expected: "an integer" })),
+    interval: Schema.Number.annotate({ description: "Minimum polling interval in seconds." }).check(Schema.isInt().annotate({ expected: "an integer" })),
+}).annotate({
+    title: "Device Code Response",
+    description: "Response from the OAuth device authorization endpoint (RFC 8628).",
+    identifier: "DeviceCodeResponse",
+});
+export const DeviceCodeOAuthError = Schema.Struct({
+    error: Schema.Literals(["invalid_client", "invalid_scope"]),
+}).annotate({ title: "Device Code OAuth Error", identifier: "DeviceCodeOAuthError" });
+export const PublishDetails = Schema.Struct({
+    retryable: Schema.Boolean.annotate({ description: "Whether the client may retry the request." }),
+    retryAfterSeconds: Schema.optionalKey(Schema.Number.annotate({ description: "Suggested delay in seconds before retrying." }).check(Schema.isFinite().annotate({ expected: "a finite number" }))),
+    requiredScope: Schema.optionalKey(Schema.String.annotate({
+        description: "The scope required to perform the operation, if applicable.",
+    })),
+    tokenScopes: Schema.optionalKey(Schema.Array(Schema.String).annotate({
+        description: "The scopes present on the token used for the request.",
+    })),
+    requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({
+        description: "The management role required, if applicable.",
+    })),
+}).annotate({
+    title: "Publish Details",
+    description: "Extended error details for publish-related and retryable error responses.",
+    identifier: "PublishDetails",
+});
+export const IsoDateTimeString = DateTimeUtcSchema;
+export const ExtensionVisibility = Schema.Literals(["public", "private"]).annotate({
+    title: "Extension Visibility",
+    description: "Whole-Extension Registry visibility applied to every published version.",
+    identifier: "ExtensionVisibility",
+});
+export const Sha256Hex = Schema.String.check(Schema.isPattern(new RegExp("^[a-f0-9]{64}$")).annotate({
+    expected: "a string matching the RegExp ^[a-f0-9]{64}$",
+    identifier: "Sha256Hex",
+}));
+export const Handle = Schema.String.annotate({
+    title: "Handle",
+    description: "A unique username or organization name starting with @, like @my-org.",
+    examples: ["@my-org", "@username"],
+}).check(Schema.isPattern(new RegExp("^@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?$")).annotate({
+    expected: "a string matching the RegExp ^@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?$",
+    identifier: "Handle",
+}));
+export const ExtensionType = Schema.Literals([
+    "skill",
+    "mcp-server",
+    "subagent",
+    "rule",
+    "hook",
+    "knowledge",
+    "pack",
+]).annotate({
+    title: "Extension Type",
+    description: "What kind of extension this is: skill, mcp-server, subagent, rule, hook, knowledge, or pack.",
+    identifier: "ExtensionType",
+});
+export const ExtensionName = Schema.String.annotate({
+    title: "Extension Name",
+    description: "The name of an extension — lowercase letters, numbers, and hyphens (e.g. my-skill).",
+    examples: ["my-skill", "code-review", "prettier"],
+})
+    .check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" }))
+    .check(Schema.isPattern(new RegExp("^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$")).annotate({
+    expected: "a string matching the RegExp ^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$",
+    identifier: "ExtensionName",
+}));
+export const Version = Schema.String.annotate({
+    title: "Version",
+    description: "A semver version like 1.0.0. Ranges are not allowed here.",
+    examples: ["1.0.0", "2.3.1", "0.1.0-beta.1"],
+}).check(Schema.isPattern(new RegExp("^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$")).annotate({
+    expected: "a string matching the RegExp ^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$",
+    identifier: "Version",
+}));
+export const ExtensionFqn = Schema.String.annotate({
+    title: "Extension FQN",
+    description: "Canonical extension identifier in @owner/<type>s/<name> form.",
+    examples: ["@acme/skills/code-review", "@my-org/rules/typescript"],
+}).check(Schema.isPattern(new RegExp("^(@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?)\\/(skills|mcps|subagents|rules|hooks|knowledge|packs)\\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)$")).annotate({
+    expected: "a string matching the RegExp ^(@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?)\\/(skills|mcps|subagents|rules|hooks|knowledge|packs)\\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)$",
+    identifier: "ExtensionFqn",
+}));
+export const VisibilityFingerprint = Schema.String.check(Schema.isPattern(new RegExp("^[a-f0-9]{64}$")).annotate({
+    expected: "a string matching the RegExp ^[a-f0-9]{64}$",
+    identifier: "VisibilityFingerprint",
+}));
+export const VisibilityRevision = Schema.String.annotate({
+    description: "Opaque revision for conditional whole-Extension visibility mutation.",
+}).check(Schema.isMinLength(1).annotate({
+    expected: "a value with a length of at least 1",
+    identifier: "VisibilityRevision",
+}));
+export const VisibilityComparison = Schema.Literals([
+    "not-established",
+    "unconfigured",
+    "match",
+    "drift",
+]).annotate({ identifier: "VisibilityComparison" });
+export const VisibilityFindingCode = Schema.Literals([
+    "visibility/intent-conflict",
+    "visibility/drift",
+    "visibility/unavailable",
+    "visibility/intent-required",
+    "visibility/not-established",
+    "visibility/stale-source",
+    "visibility/stale-revision",
+    "visibility/confirmation-required",
+    "visibility/authorization-denied",
+    "visibility/impersonation-denied",
+    "visibility/verification-required",
+    "visibility/verification-expired",
+    "visibility/verification-cancelled",
+    "visibility/verification-replayed",
+    "visibility/pack-blocked",
+]).annotate({ identifier: "VisibilityFindingCode" });
+export const VersionRange = Schema.String.annotate({
+    title: "Version Range",
+    description: 'A semver version range like ^1.0.0, ~2.3.0, >=1.0.0 <3.0.0, or an exact version 1.2.3. Use "*" to always resolve to the latest available version.',
+    examples: ["^1.0.0", "~2.4", ">=1 <3", "1.2.3", "*"],
+})
+    .check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" }))
+    .check(Schema.isPattern(new RegExp("^[~^<>=*xXvV0-9A-Za-z+| .-]+$")).annotate({
+    expected: "a string matching the RegExp ^[~^<>=*xXvV0-9A-Za-z+| .-]+$",
+    identifier: "VersionRange",
+}));
+export const DeprecationMessage = Schema.String.annotate({
+    description: "Concise publisher guidance for consumers of a deprecated extension.",
+})
+    .check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" }))
+    .check(Schema.isMaxLength(500).annotate({
+    expected: "a value with a length of at most 500",
+    identifier: "DeprecationMessage",
+}));
+export const SuggestedAction = Schema.Struct({
+    description: Schema.String,
+    cmd: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    url: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+}).annotate({ identifier: "SuggestedAction" });
+export const TokenOAuthErrorEncoded = Schema.Struct({
+    kind: Schema.Literal("TokenOAuthError"),
+    error: Schema.Literals([
+        "invalid_request",
+        "invalid_client",
+        "invalid_grant",
+        "unauthorized_client",
+        "unsupported_grant_type",
+        "invalid_scope",
+        "authorization_pending",
+        "slow_down",
+        "expired_token",
+        "access_denied",
+    ]).annotate({ title: "OAuth Token Error", description: "OAuth token endpoint error code." }),
+    error_description: Schema.String.annotate({
+        description: "Human-readable explanation of the error.",
+    }),
+}).annotate({ identifier: "TokenOAuthErrorEncoded" });
+export const AuthWhoamiResponse = Schema.Struct({
+    handle: Schema.String.annotate({
+        description: "The authenticated user's registry handle.",
+        examples: ["@example"],
+    }),
+}).annotate({
+    title: "Auth Whoami Response",
+    description: "Minimal identity response for login checks and CLI whoami.",
+    identifier: "AuthWhoamiResponse",
+});
+export const UserId = Schema.String.annotate({
+    title: "User ID",
+    description: "Identifies a registered user account. Assigned at sign-up and referenced by tokens, memberships, and audit trails.",
+    examples: ["user_01h455vb4pexka56gq5w2r7cpc"],
+}).check(Schema.isPattern(new RegExp("^user_[0-7][0-9a-hjkmnp-tv-z]{25}$")).annotate({
+    expected: "a string matching the RegExp ^user_[0-7][0-9a-hjkmnp-tv-z]{25}$",
+    identifier: "UserId",
+}));
+export const ResourceRestrictions = Schema.Struct({
+    extensions: Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({
+        description: "Extension patterns this token is limited to, or null if unrestricted.",
+    }),
+}).annotate({
+    title: "Resource Restrictions",
+    description: "What this token is allowed to access.",
+    identifier: "ResourceRestrictions",
+});
+export const PublishAuthorizationRequestId = Schema.String.annotate({
+    title: "Publish Authorization Request ID",
+    description: "Identifies one exact browser-reviewed publish authorization request.",
+    examples: ["pubreq_01h455vb4pexka56gq5w2r7cpc"],
+}).check(Schema.isPattern(new RegExp("^pubreq_[0-7][0-9a-hjkmnp-tv-z]{25}$")).annotate({
+    expected: "a string matching the RegExp ^pubreq_[0-7][0-9a-hjkmnp-tv-z]{25}$",
+    identifier: "PublishAuthorizationRequestId",
+}));
+export const TokenId = Schema.String.annotate({
+    title: "Token ID",
+    description: "Identifies an access token or personal access token (PAT) issued to a user. Used to authenticate API requests to the registry.",
+    examples: ["tok_01h455vb4pexka56gq5w2r7cpc"],
+}).check(Schema.isPattern(new RegExp("^tok_[0-7][0-9a-hjkmnp-tv-z]{25}$")).annotate({
+    expected: "a string matching the RegExp ^tok_[0-7][0-9a-hjkmnp-tv-z]{25}$",
+    identifier: "TokenId",
+}));
+export const ScopeCheckDetails = Schema.Struct({
+    requiredScope: Schema.optionalKey(Schema.String.annotate({
+        description: "The scope required to perform the requested operation.",
+    })),
+    grantedScopes: Schema.Array(Schema.String).annotate({
+        description: "The scopes granted to the current credential.",
+    }),
+}).annotate({
+    title: "Scope Check Details",
+    description: "Diagnostic details returned when a request is denied due to insufficient scopes.",
+    identifier: "ScopeCheckDetails",
+});
+export const AuthorizationDenyDetails = Schema.Struct({
+    requiredScope: Schema.optionalKey(Schema.String.annotate({
+        description: "The scope required to perform the requested operation.",
+    })),
+    tokenScopes: Schema.Array(Schema.String).annotate({
+        description: "The scopes present on the token used for the request.",
+    }),
+    requiredRole: Schema.optionalKey(Schema.String.annotate({ description: "The management role required, if applicable." })),
+}).annotate({
+    title: "Authorization Deny Details",
+    description: "Diagnostic details returned when a request is denied due to insufficient authorization.",
+    identifier: "AuthorizationDenyDetails",
+});
+export const StepUpRequestId = Schema.String.annotate({
+    title: "Step-Up Request ID",
+    description: "Identifies one short-lived cross-channel authentication request.",
+    examples: ["step_01h455vb4pexka56gq5w2r7cpc"],
+}).check(Schema.isPattern(new RegExp("^step_[0-7][0-9a-hjkmnp-tv-z]{25}$")).annotate({
+    expected: "a string matching the RegExp ^step_[0-7][0-9a-hjkmnp-tv-z]{25}$",
+    identifier: "StepUpRequestId",
+}));
+export const CreateTokenPermissionsRequest = Schema.Struct({
+    owners: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({
+        description: 'Owner selectors for extension permissions. Use full handles or "all".',
+        examples: [["@example"]],
+    })),
+    extensions: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({
+        description: "Extension selectors in @handle/<plural-type>/<name> form.",
+        examples: [["@example/skills/release-bot"]],
+    })),
+    permission: Schema.optionalKey(Schema.Union([Schema.Literals(["read", "publish", "admin"]), Schema.Null]).annotate({
+        description: "Extension-level permission to grant.",
+    })),
+    org_permission: Schema.optionalKey(Schema.Union([Schema.Literals(["read", "write", "admin"]), Schema.Null]).annotate({
+        description: "Organization-level permission to grant.",
+    })),
+    cidr: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({
+        description: "Optional CIDR allowlist for the token.",
+    })),
+    bypass_mfa: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null]).annotate({
+        description: "Whether this automation token bypasses step-up MFA.",
+    })),
+}).annotate({
+    title: "Create Token Permissions Request",
+    description: "Structured permission request for the token.",
+    identifier: "CreateTokenPermissionsRequest",
+});
+export const IsoDateTimeString_1 = Schema.String.annotate({
+    title: "ISO Date-Time String",
+    description: "A date and time string (e.g. 2024-01-15T12:00:00.000Z).",
+    format: "date-time",
+    identifier: "IsoDateTimeString_1",
+});
+export const OwnerResponse = Schema.Struct({
+    displayName: Schema.String.annotate({ description: "Display name for the owner account." }),
+}).annotate({
+    title: "Owner Response",
+    description: "Minimal owner summary for machine clients.",
+    identifier: "OwnerResponse",
+});
+export const Repository = Schema.Struct({
+    url: Schema.String.annotate({
+        description: "Canonical repository URL for the extension source.",
+        format: "uri",
+    }),
+    type: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Repository type from the manifest, such as git." }),
+        Schema.Null,
+    ])),
+    directory: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Subdirectory containing the extension source." }),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Repository",
+    description: "Repository details for an extension manifest.",
+    identifier: "Repository",
+});
+export const LicenseExpression = Schema.String.annotate({
+    title: "License Expression",
+    description: "SPDX license expression, or `UNLICENSED` for proprietary code.",
+    examples: ["MIT", "Apache-2.0", "MIT OR Apache-2.0", "UNLICENSED"],
+    format: "spdx-expression",
+    identifier: "LicenseExpression",
+});
+export const Author = Schema.Struct({
+    name: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Display name of the extension author." }),
+        Schema.Null,
+    ])),
+    email: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Contact email of the extension author.",
+            format: "email",
+        }),
+        Schema.Null,
+    ])),
+    url: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "URL for the extension author (homepage or profile).",
+            format: "uri",
+        }),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Author",
+    description: "Author details: name, email, and homepage URL.",
+    identifier: "Author",
+});
+export const Bugs = Schema.Struct({
+    url: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Issue tracker URL for the extension.",
+            format: "uri",
+        }),
+        Schema.Null,
+    ])),
+    email: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Contact email for reporting extension issues.",
+            format: "email",
+        }),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Bugs",
+    description: "Bug reporting details for an extension manifest.",
+    identifier: "Bugs",
+});
+export const PackageIdentityPurl = Schema.String.annotate({
+    title: "Package Identity Purl",
+    description: "A Package URL (purl) identity for a companion package. Companion package purls are identities, not pins: omit the purl @version segment and put compatibility constraints in versionRange.",
+    examples: ["pkg:npm/react", "pkg:pypi/requests", "pkg:cargo/serde"],
+})
+    .check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" }))
+    .check(Schema.isPattern(new RegExp("^[Pp][Kk][Gg]:[a-zA-Z][a-zA-Z0-9.+-]*\\/.+$")).annotate({
+    expected: "a string matching the RegExp ^[Pp][Kk][Gg]:[a-zA-Z][a-zA-Z0-9.+-]*\\/.+$",
+    identifier: "PackageIdentityPurl",
+}));
+export const DeleteExtensionBody = Schema.Struct({
+    confirmation: Schema.String.annotate({
+        description: "Exact full Extension FQN typed by the owner to confirm deletion.",
+    }),
+}).annotate({
+    title: "Delete Extension Body",
+    description: "High-intent confirmation for permanent whole-Extension deletion.",
+    identifier: "DeleteExtensionBody",
+});
+export const ExtensionDeletionOperationId = Schema.String.annotate({
+    title: "Extension Deletion Operation ID",
+    description: "Identifies a durable owner-requested whole-Extension deletion operation.",
+    examples: ["edel_01h455vb4pexka56gq5w2r7cpc"],
+}).check(Schema.isPattern(new RegExp("^edel_[0-7][0-9a-hjkmnp-tv-z]{25}$")).annotate({
+    expected: "a string matching the RegExp ^edel_[0-7][0-9a-hjkmnp-tv-z]{25}$",
+    identifier: "ExtensionDeletionOperationId",
+}));
+export const Visibility = Schema.Literals(["public", "private"]).annotate({
+    title: "Visibility",
+    identifier: "Visibility",
+});
+export const PublishFindingLocation = Schema.Struct({
+    file: Schema.String,
+    line: Schema.optionalKey(Schema.Union([
+        Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+        Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+    ])),
+    column: Schema.optionalKey(Schema.Union([
+        Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+        Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+    ])),
+    byteOffset: Schema.optionalKey(Schema.Union([
+        Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+        Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+    ])),
+    byteLength: Schema.optionalKey(Schema.Union([
+        Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+        Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+    ])),
+}).annotate({
+    title: "Finding Location",
+    description: "Accessor-relative location of a lint finding.",
+    identifier: "PublishFindingLocation",
+});
+export const ExtensionLinks = Schema.Struct({
+    html: Schema.String.annotate({ format: "uri" }),
+}).annotate({
+    title: "Extension Links",
+    description: "Hyperlinks for an extension resource. `html` is the canonical web page URL.",
+    identifier: "ExtensionLinks",
+});
+export const SuggestedAction_1 = Schema.Struct({
+    description: Schema.String,
+    cmd: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    url: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+}).annotate({ identifier: "SuggestedAction_1" });
+export const PublishIdentityMismatchEntry = Schema.Struct({
+    field: Schema.Literals(["owner", "type", "name", "version"]),
+    urlPath: Schema.Union([Schema.String, Schema.Null]),
+    content: Schema.Union([Schema.String, Schema.Null]),
+}).annotate({
+    title: "Identity Mismatch Entry",
+    description: "Single divergent identity field between URL-path and archive.",
+    identifier: "PublishIdentityMismatchEntry",
+});
+export const DeprecationRevision = Schema.String.annotate({
+    description: "Opaque publisher lifecycle revision used for conditional writes.",
+}).check(Schema.isMinLength(1).annotate({
+    expected: "a value with a length of at least 1",
+    identifier: "DeprecationRevision",
+}));
+export const YankVersionBody = Schema.Struct({
+    category: Schema.optionalKey(Schema.Union([Schema.Literals(["broken", "security", "accidental", "other"]), Schema.Null])),
+    notice: Schema.optionalKey(Schema.Union([
+        Schema.String.check(Schema.isMaxLength(500).annotate({ expected: "a value with a length of at most 500" })),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Yank Version Body",
+    description: "Optional public context for yanking an extension version.",
+    identifier: "YankVersionBody",
+});
+export const YankAvailableVersionsBody = Schema.Struct({
+    selection: Schema.Literal("all-available"),
+    category: Schema.optionalKey(Schema.Union([Schema.Literals(["broken", "security", "accidental", "other"]), Schema.Null])),
+    notice: Schema.optionalKey(Schema.Union([
+        Schema.String.check(Schema.isMaxLength(500).annotate({ expected: "a value with a length of at most 500" })),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Yank Available Versions Body",
+    description: "Atomically yanks the snapshot of all currently available versions.",
+    identifier: "YankAvailableVersionsBody",
+});
+export const PublishPreviewBatchTooLargeHttpErrorEncoded = Schema.Struct({
+    kind: Schema.Literal("PublishPreviewBatchTooLargeHttpError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.Literal("publish/preflight-batch-too-large"),
+    max_items: Schema.Literal(100),
+}).annotate({ identifier: "PublishPreviewBatchTooLargeHttpErrorEncoded" });
+export const LibraryVisibility = Schema.Literals(["public", "private"]).annotate({
+    title: "Library Visibility",
+    identifier: "LibraryVisibility",
+});
+export const LibraryId = Schema.String.annotate({
+    title: "Library ID",
+    description: "Identifies an account-owned curated collection of extension identities in the registry.",
+    examples: ["lib_01h455vb4pexka56gq5w2r7cpc"],
+}).check(Schema.isPattern(new RegExp("^lib_[0-7][0-9a-hjkmnp-tv-z]{25}$")).annotate({
+    expected: "a string matching the RegExp ^lib_[0-7][0-9a-hjkmnp-tv-z]{25}$",
+    identifier: "LibraryId",
+}));
+export const LibraryName = Schema.String.annotate({
+    title: "Library Name",
+    description: "Canonical Library name within an owner namespace. Uses the same normalized slug grammar as handles.",
+    examples: ["frontend", "team-tools"],
+    identifier: "LibraryName",
+});
+export const LibraryMemberId = Schema.String.annotate({
+    title: "Library Member ID",
+    description: "Identifies an extension identity membership inside a curated registry library.",
+    examples: ["lmem_01h455vb4pexka56gq5w2r7cpc"],
+}).check(Schema.isPattern(new RegExp("^lmem_[0-7][0-9a-hjkmnp-tv-z]{25}$")).annotate({
+    expected: "a string matching the RegExp ^lmem_[0-7][0-9a-hjkmnp-tv-z]{25}$",
+    identifier: "LibraryMemberId",
+}));
+export const DebugStreamEventEncoded = Schema.String.annotate({
+    contentMediaType: "application/json",
+    identifier: "DebugStreamEventEncoded",
+});
+export const ProblemDetails = Schema.Struct({
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
+}).annotate({
+    title: "Problem Details",
+    description: "RFC 9457 Problem Details payload for AgentXM Registry errors.",
+    identifier: "ProblemDetails",
+});
+export const PreconditionFailedErrorEncoded = Schema.Struct({
+    kind: Schema.Literal("PreconditionFailedError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.Literals([
+        "publish/precondition-changed",
+        "visibility/stale-revision",
+        "deprecation/stale-revision",
+    ]),
+    details: Schema.optionalKey(PublishDetails),
+}).annotate({ identifier: "PreconditionFailedErrorEncoded" });
+export const StepUpRequestStatusResponse = Schema.Struct({
+    status: Schema.Literals(["pending", "verified", "consumed", "cancelled", "expired"]),
+    expires_at: IsoDateTimeString,
+}).annotate({
+    title: "Step-up Request Status Response",
+    identifier: "StepUpRequestStatusResponse",
+});
+export const PublishVisibility = Schema.Union([
+    Schema.Struct({
+        value: ExtensionVisibility,
+        disposition: Schema.Literal("establish"),
+        source: Schema.Literals(["manifest", "workspace", "explicit", "account", "platform"]),
+    }),
+    Schema.Struct({
+        value: ExtensionVisibility,
+        disposition: Schema.Literal("preserve"),
+        source: Schema.Literal("existing"),
+    }),
+]).annotate({
+    title: "Publish Visibility",
+    description: "Authoritative whole-Extension visibility and provenance resolved for a publication.",
+    identifier: "PublishVisibility",
+});
+export const PublicationTarget = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+}).annotate({ identifier: "PublicationTarget" });
+export const PublishIdentity = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+}).annotate({
+    title: "Publish Identity",
+    description: "URL-path identity of the extension version under publish.",
+    identifier: "PublishIdentity",
+});
+export const DeprecationReplacement = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("available"), fqn: ExtensionFqn }),
+    Schema.Struct({
+        status: Schema.Literal("unavailable"),
+        fqn: Schema.optionalKey(Schema.Union([ExtensionFqn, Schema.Null])),
+    }),
+]).annotate({
+    description: "Authorization-safe current availability of a recorded replacement identity.",
+    identifier: "DeprecationReplacement",
+});
+export const DeprecationReplacementIntent = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("clear") }),
+    Schema.Struct({ kind: Schema.Literal("set"), fqn: ExtensionFqn }),
+    Schema.Struct({ kind: Schema.Literal("preserve") }),
+]).annotate({ identifier: "DeprecationReplacementIntent" });
+export const VisibilityIntent = Schema.Struct({
+    value: ExtensionVisibility,
+    source: Schema.Literals(["manifest", "workspace"]),
+    fingerprint: VisibilityFingerprint,
+}).annotate({ identifier: "VisibilityIntent" });
+export const VisibilityMutationAuthority = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("operator") }),
+    Schema.Struct({
+        kind: Schema.Literal("repository"),
+        source: Schema.Literals(["manifest", "workspace"]),
+        fingerprint: VisibilityFingerprint,
+    }),
+]).annotate({ identifier: "VisibilityMutationAuthority" });
+export const VisibilityActual = Schema.Struct({
+    value: ExtensionVisibility,
+    revision: VisibilityRevision,
+}).annotate({ identifier: "VisibilityActual" });
+export const VisibilityFinding = Schema.Struct({
+    code: VisibilityFindingCode,
+    severity: Schema.Literals(["error", "warning"]),
+    message: Schema.String,
+}).annotate({ identifier: "VisibilityFinding" });
+export const PackDependencyDescriptor = Schema.Struct({
+    owner: Handle,
+    type: Schema.Literals(["hook", "knowledge", "mcp-server", "rule", "skill", "subagent"]),
+    name: ExtensionName,
+    range: VersionRange,
+}).annotate({ identifier: "PackDependencyDescriptor" });
+export const AuthMeUser = Schema.Struct({
+    id: UserId,
+    handle: Schema.String.annotate({
+        description: "The user's registry handle.",
+        examples: ["@example"],
+    }),
+    email: Schema.Union([
+        Schema.String.annotate({
+            description: "The user's email address, if available.",
+            format: "email",
+        }),
+        Schema.Null,
+    ]),
+}).annotate({
+    title: "Authenticated User",
+    description: "Your profile information.",
+    identifier: "AuthMeUser",
+});
+export const AuthMeToken = Schema.Struct({
+    id: Schema.String.annotate({
+        description: "Opaque identifier of the credential used for this request.",
+    }),
+    type: Schema.Literals(["session", "pat", "oidc", "publish-capability"]).annotate({
+        title: "Token Type",
+        description: "The type of authentication token.",
+    }),
+    name: Schema.Union([
+        Schema.String.annotate({ description: "Human-readable name of the token, if assigned." }),
+        Schema.Null,
+    ]),
+    permissions: Schema.Union([
+        Schema.Json.annotate({ expected: "JSON value" }),
+        Schema.Null,
+    ]).annotate({ description: "Structured permissions associated with this token." }),
+    scopes: Schema.Array(Schema.String).annotate({ description: "Scopes granted to this token." }),
+    resource_restrictions: ResourceRestrictions,
+    expires_at: IsoDateTimeString,
+}).annotate({
+    title: "Token Info",
+    description: "Details about the token you used to authenticate.",
+    identifier: "AuthMeToken",
+});
+export const TokenListItem = Schema.Struct({
+    id: TokenId,
+    name: Schema.Union([
+        Schema.String.annotate({ description: "Human-readable name of the token, if assigned." }),
+        Schema.Null,
+    ]),
+    type: Schema.String.annotate({ description: "Token type (e.g. 'pat', 'session')." }),
+    scopes: Schema.Array(Schema.String).annotate({ description: "Scopes granted to this token." }),
+    permissions: Schema.Union([
+        Schema.Json.annotate({ expected: "JSON value" }),
+        Schema.Null,
+    ]).annotate({ description: "Structured permissions associated with this token." }),
+    created_at: IsoDateTimeString,
+    expires_at: IsoDateTimeString,
+    last_used_at: Schema.Union([IsoDateTimeString, Schema.Null]),
+}).annotate({
+    title: "Token List Item",
+    description: "Summary of an access token.",
+    identifier: "TokenListItem",
+});
+export const CreateTokenResponse = Schema.Struct({
+    id: TokenId,
+    token: Schema.String.annotate({
+        description: "The token value — save this, it won't be shown again.",
+        readOnly: true,
+    }),
+    name: Schema.String,
+    scopes: Schema.Array(Schema.String),
+    permissions: Schema.Json.annotate({ expected: "JSON value" }),
+    created_at: IsoDateTimeString,
+    expires_at: IsoDateTimeString,
+}).annotate({
+    title: "Create Token Response",
+    description: "Your new access token. The token value is only shown once — save it now.",
+    identifier: "CreateTokenResponse",
+});
+export const ForbiddenErrorEncoded = Schema.Struct({
+    kind: Schema.Literal("ForbiddenError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.Literals([
+        "forbidden",
+        "insufficient_scope",
+        "resource_restriction",
+        "scope_escalation",
+        "gat_requires_session",
+        "recent_authentication_required",
+        "step_up_wrong_actor",
+        "team_create_not_authorized",
+        "team_delete_not_authorized",
+        "team_update_not_authorized",
+        "add_team_member_not_authorized",
+        "remove_team_member_not_authorized",
+        "change_team_member_role_not_authorized",
+        "library_mutation_not_authorized",
+        "team_extension_grant_delete_not_authorized",
+        "team_extension_grant_not_authorized",
+        "resource_group_create_not_authorized",
+        "resource_group_update_not_authorized",
+        "resource_group_delete_not_authorized",
+        "resource_group_access_not_authorized",
+        "resource_move_not_authorized",
+        "resource_access_not_authorized",
+        "access_policy_not_authorized",
+        "publish/quota-exceeded",
+        "publish/insufficient-scope",
+        "publish/resource-restriction",
+        "publish/handle-not-owned",
+        "publish/publish-forbidden",
+        "publish/capability-binding-mismatch",
+        "publish/capability-expired",
+        "publish/capability-revoked",
+        "publish/capability-consumed",
+    ]),
+    details: Schema.optionalKey(Schema.Union([ScopeCheckDetails, AuthorizationDenyDetails, PublishDetails])),
+}).annotate({ identifier: "ForbiddenErrorEncoded" });
+export const CreateTokenRequest = Schema.Struct({
+    name: Schema.String.annotate({
+        description: "Human-readable name for the token.",
+        examples: ["CI publish token"],
+    }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+    permissions: CreateTokenPermissionsRequest,
+    expires_in: Schema.Number.annotate({
+        description: "How long the token lasts, in seconds (1 hour to 365 days).",
+    })
+        .check(Schema.isInt().annotate({ expected: "an integer" }))
+        .check(Schema.isGreaterThanOrEqualTo(3600).annotate({
+        expected: "a value greater than or equal to 3600",
+    }))
+        .check(Schema.isLessThanOrEqualTo(31536000).annotate({
+        expected: "a value less than or equal to 31536000",
+    })),
+}).annotate({
+    title: "Create Token Request",
+    description: "Request body for creating a new personal access token.",
+    identifier: "CreateTokenRequest",
+});
+export const StepUpRequiredErrorEncoded = Schema.Struct({
+    kind: Schema.Literal("StepUpRequiredError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.Literal("eotp"),
+    step_up: Schema.optionalKey(Schema.Struct({
+        request_id: StepUpRequestId,
+        verification_url: Schema.String,
+        status_url: Schema.String,
+        expires_at: IsoDateTimeString_1,
+        interval: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+        action: Schema.String,
+        target: Schema.String,
+    })),
+    max_age: Schema.optionalKey(Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" }))),
+}).annotate({ identifier: "StepUpRequiredErrorEncoded" });
+export const CompanionPackage = Schema.Struct({
+    purl: PackageIdentityPurl,
+    versionRange: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            examples: ["vers:npm/>=18.0.0|<19.0.0", "vers:pypi/>=2.31.0", "vers:cargo/>=1.0.0"],
+        }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Companion Package",
+    description: "A companion package purl identity with an optional VERS compatibility range.",
+    identifier: "CompanionPackage",
+});
+export const PublishLintFinding = Schema.Struct({
+    kind: Schema.Literals(["advisory", "autofixable"]),
+    ruleId: Schema.String,
+    severity: Schema.Literals(["error", "warning", "info"]),
+    message: Schema.String,
+    location: Schema.optionalKey(PublishFindingLocation),
+    path: Schema.String,
+    suggestions: Schema.Array(SuggestedAction),
+}).annotate({
+    title: "Publish Lint Finding",
+    description: "One lint finding produced against the publish subject.",
+    identifier: "PublishLintFinding",
+});
+export const PublishLintFinding_1 = Schema.Struct({
+    kind: Schema.Literals(["advisory", "autofixable"]),
+    ruleId: Schema.String,
+    severity: Schema.Literals(["error", "warning", "info"]),
+    message: Schema.String,
+    location: Schema.optionalKey(PublishFindingLocation),
+    path: Schema.String,
+    suggestions: Schema.Array(SuggestedAction_1),
+}).annotate({
+    title: "Publish Lint Finding",
+    description: "One lint finding produced against the publish subject.",
+    identifier: "PublishLintFinding_1",
+});
+export const Library = Schema.Struct({
+    id: LibraryId,
+    owner: Handle,
+    name: LibraryName,
+    title: Schema.String,
+    description: Schema.Union([Schema.String, Schema.Null]),
+    visibility: LibraryVisibility,
+    createdAt: IsoDateTimeString,
+    updatedAt: IsoDateTimeString,
+}).annotate({ title: "Library", identifier: "Library" });
+export const LibraryMember = Schema.Struct({
+    id: LibraryMemberId,
+    libraryId: LibraryId,
+    extensionId: Schema.String,
+    extensionOwner: Handle,
+    extensionType: ExtensionType,
+    extensionName: ExtensionName,
+    addedAt: IsoDateTimeString,
+}).annotate({ title: "Library Member", identifier: "LibraryMember" });
+export const SessionTokenResponse = Schema.Struct({
+    access_token: Schema.String.annotate({ description: "OAuth 2.0 access token." }),
+    refresh_token: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "OAuth 2.0 refresh token for obtaining new token pairs. Omitted for exact publish capabilities.",
+        }),
+        Schema.Null,
+    ])),
+    token_type: Schema.Literal("Bearer"),
+    expires_in: Schema.Number.annotate({
+        description: "Access token lifetime remaining in seconds.",
+    }).check(Schema.isInt().annotate({ expected: "an integer" })),
+    expires_at: IsoDateTimeString,
+    scope: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Space-delimited list of granted scopes." }),
+        Schema.Null,
+    ])),
+    publish_request_id: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Publish authorization request that produced a non-refreshable exact capability.",
+        }),
+        Schema.Null,
+    ])),
+    visibility_contract: Schema.optionalKey(Schema.Union([
+        Schema.Literal("v2").annotate({
+            description: "Visibility binding contract carried by an exact publish capability.",
+        }),
+        Schema.Null,
+    ])),
+    visibility: Schema.optionalKey(Schema.Union([PublishVisibility, Schema.Null])),
+    condition: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Opaque reviewed publish condition to send as If-Match during upload.",
+        }),
+        Schema.Null,
+    ])),
+    publication_set_digest: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    publication_descriptor_digest: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+}).annotate({
+    title: "Session Token Response",
+    description: "OAuth 2.0 token response containing an access/refresh token pair.",
+    identifier: "SessionTokenResponse",
+});
+export const ExtensionIdentityMismatchErrorEncoded = Schema.Struct({
+    kind: Schema.Literal("ExtensionIdentityMismatchError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.Literal("extension_identity_mismatch"),
+    error: Schema.Literal("extension_identity_mismatch"),
+    identity: PublishIdentity,
+    mismatches: Schema.Array(PublishIdentityMismatchEntry),
+}).annotate({ identifier: "ExtensionIdentityMismatchErrorEncoded" });
+export const DeprecationView = Schema.Union([
+    Schema.Struct({
+        deprecatedAt: IsoDateTimeString,
+        message: DeprecationMessage,
+        replacement: Schema.optionalKey(Schema.Union([DeprecationReplacement, Schema.Null])),
+    }),
+    Schema.Struct({
+        deprecatedAt: IsoDateTimeString,
+        message: Schema.optionalKey(Schema.Union([DeprecationMessage, Schema.Null])),
+        replacement: DeprecationReplacement,
+    }),
+]).annotate({
+    description: "Canonical authorization-safe identity deprecation guidance.",
+    identifier: "DeprecationView",
+});
+export const PutDeprecationBody = Schema.Struct({
+    message: Schema.Union([
+        Schema.String.annotate({
+            description: "Publisher migration guidance, normalized by the Registry.",
+        }).check(Schema.isMaxLength(500).annotate({ expected: "a value with a length of at most 500" })),
+        Schema.Null,
+    ]),
+    replacement: DeprecationReplacementIntent,
+}).annotate({ identifier: "PutDeprecationBody" });
+export const PublicationVisibilityInput = Schema.Struct({
+    intent: Schema.Union([VisibilityIntent, Schema.Null]),
+    request: Schema.Union([ExtensionVisibility, Schema.Null]),
+}).annotate({ identifier: "PublicationVisibilityInput" });
+export const VisibilityMutationRequest = Schema.Struct({
+    target: ExtensionFqn,
+    visibility: ExtensionVisibility,
+    revision: VisibilityRevision,
+    authority: VisibilityMutationAuthority,
+    verification: Schema.optionalKey(Schema.Union([
+        Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+        Schema.Null,
+    ])),
+}).annotate({ identifier: "VisibilityMutationRequest" });
+export const VisibilityMutationResult = Schema.Struct({
+    target: ExtensionFqn,
+    before: ExtensionVisibility,
+    after: ExtensionVisibility,
+    authority: VisibilityMutationAuthority,
+    result: Schema.Literals(["already-satisfied", "changed"]),
+    revision: VisibilityRevision,
+}).annotate({ identifier: "VisibilityMutationResult" });
+export const VisibilityEvaluation = Schema.Struct({
+    target: ExtensionFqn,
+    intent: Schema.Union([VisibilityIntent, Schema.Null]),
+    request: Schema.Union([ExtensionVisibility, Schema.Null]),
+    resolved: Schema.Union([PublishVisibility, Schema.Null]),
+    actual: Schema.Union([VisibilityActual, Schema.Null]),
+    comparison: VisibilityComparison,
+    findings: Schema.Array(VisibilityFinding),
+}).annotate({ identifier: "VisibilityEvaluation" });
+export const VisibilityEvaluationUnavailable = Schema.Struct({
+    target: ExtensionFqn,
+    unavailable: Schema.Literal(true),
+    findings: Schema.Array(VisibilityFinding),
+}).annotate({ identifier: "VisibilityEvaluationUnavailable" });
+export const PackDependencyResolution = Schema.Struct({
+    dependency: PackDependencyDescriptor,
+    effectiveVersion: Version,
+}).annotate({ identifier: "PackDependencyResolution" });
+export const AuthMeResponse = Schema.Struct({
+    user: AuthMeUser,
+    orgs: Schema.Tuple([]).annotate({
+        description: "Organizations the user belongs to (reserved, currently empty).",
+    }),
+    token: AuthMeToken,
+}).annotate({
+    title: "Auth Me Response",
+    description: "Your user profile, organizations, and token details.",
+    identifier: "AuthMeResponse",
+});
+export const TokenListResponse = Schema.Struct({
+    tokens: Schema.Array(TokenListItem).annotate({
+        description: "List of access tokens for the authenticated user.",
+    }),
+    has_more: Schema.Boolean.annotate({
+        description: "Whether additional tokens exist beyond this page.",
+    }),
+    cursor: Schema.Union([
+        Schema.String.annotate({ description: "Opaque cursor for fetching the next page of results." }),
+        Schema.Null,
+    ]),
+}).annotate({
+    title: "Token List Response",
+    description: "A page of your access tokens.",
+    identifier: "TokenListResponse",
+});
+export const ExtensionLintFailedErrorEncoded = Schema.Struct({
+    kind: Schema.Literal("ExtensionLintFailedError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.Literal("extension_lint_failed"),
+    error: Schema.Literal("extension_lint_failed"),
+    identity: PublishIdentity,
+    displayRoot: Schema.String,
+    findings: Schema.Array(PublishLintFinding_1),
+}).annotate({ identifier: "ExtensionLintFailedErrorEncoded" });
+export const LibraryDetail = Schema.Struct({
+    library: Library,
+    members: Schema.Array(LibraryMember),
+    accessibleMemberCount: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+}).annotate({ title: "Library Detail", identifier: "LibraryDetail" });
+export const ListLibraryMembersResponse = Schema.Struct({
+    members: Schema.Array(LibraryMember),
+    total: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    limit: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    offset: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    viewerRelative: Schema.Literal(true),
+}).annotate({ title: "List Library Members Response", identifier: "ListLibraryMembersResponse" });
+export const PackDependencyFinding = Schema.Struct({
+    kind: Schema.Literal("advisory"),
+    ruleId: Schema.Literals(["pack/dependency-version-resolvable", "pack/dependency-deprecated"]),
+    severity: Schema.Literals(["error", "warning"]),
+    reason: Schema.Literals([
+        "selected-new-private",
+        "selected-existing-private",
+        "target-unavailable",
+        "lifecycle-unavailable",
+        "no-installable-version",
+        "range-unsatisfied",
+        "deprecated",
+    ]),
+    dependency: PackDependencyDescriptor,
+    effectiveVisibility: Schema.optionalKey(Schema.Union([Schema.Literals(["public", "private"]), Schema.Null])),
+    lifecycle: Schema.optionalKey(Schema.Union([Schema.Literals(["active", "unavailable"]), Schema.Null])),
+    deprecation: Schema.optionalKey(Schema.Union([DeprecationView, Schema.Null])),
+    location: Schema.Struct({ file: Schema.Literal("pack.json") }),
+    path: Schema.Literal("./pack.json"),
+    message: Schema.String,
+    suggestions: Schema.Array(SuggestedAction),
+}).annotate({ identifier: "PackDependencyFinding" });
+export const DeprecationManagementView = Schema.Struct({
+    deprecation: Schema.Union([DeprecationView, Schema.Null]),
+    revision: DeprecationRevision,
+}).annotate({ identifier: "DeprecationManagementView" });
+export const DeprecationTransition = Schema.Struct({
+    target: ExtensionFqn,
+    before: Schema.Union([DeprecationView, Schema.Null]),
+    after: Schema.Union([DeprecationView, Schema.Null]),
+    disposition: Schema.Literals(["created", "edited", "restored", "unchanged"]),
+    revision: DeprecationRevision,
+}).annotate({ identifier: "DeprecationTransition" });
+export const SearchHit = Schema.Struct({
+    name: ExtensionName,
+    owner: Handle,
+    type: ExtensionType,
+    latestVersion: Version,
+    description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    repository: Schema.optionalKey(Schema.Union([Repository, Schema.Null])),
+    license: Schema.optionalKey(Schema.Union([LicenseExpression, Schema.Null])),
+    authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
+    deprecation: Schema.Union([DeprecationView, Schema.Null]),
+    matched_fields: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    visibility: Schema.Literals(["public", "private"]),
+}).annotate({
+    title: "Search Hit",
+    description: "A single extension matched by a search query.",
+    identifier: "SearchHit",
+});
+export const PublicationDescriptor = Schema.Struct({
+    target: PublicationTarget,
+    participation: Schema.Literals(["publish", "verified-existing"]),
+    archiveSha256Hex: Schema.optionalKey(Schema.Union([Sha256Hex, Schema.Null])),
+    visibility: PublicationVisibilityInput,
+    pack: Schema.optionalKey(Schema.Union([
+        Schema.Struct({ dependencies: Schema.Array(PackDependencyDescriptor) }),
+        Schema.Null,
+    ])),
+}).annotate({ identifier: "PublicationDescriptor" });
+export const PreviewPublicationSetResponse = Schema.Struct({
+    contract: Schema.Literal("publication-set-v2"),
+    publicationSetDigest: Sha256Hex,
+    status: Schema.Literals(["admitted", "blocked"]),
+    candidates: Schema.Array(Schema.Union([
+        Schema.Struct({
+            kind: Schema.Literal("resolved"),
+            target: PublicationTarget,
+            participation: Schema.Literals(["publish", "verified-existing"]),
+            descriptorDigest: Sha256Hex,
+            visibility: VisibilityEvaluation,
+            condition: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+        }),
+        Schema.Struct({
+            kind: Schema.Literal("unavailable"),
+            target: PublicationTarget,
+            participation: Schema.Literals(["publish", "verified-existing"]),
+            descriptorDigest: Sha256Hex,
+            code: Schema.Literal("publish/target-unavailable"),
+            visibility: VisibilityEvaluationUnavailable,
+        }),
+    ])),
+    packs: Schema.Array(Schema.Struct({
+        target: PublicationTarget,
+        status: Schema.Literals(["admitted", "blocked"]),
+        findings: Schema.Array(PackDependencyFinding),
+        resolutions: Schema.Array(PackDependencyResolution),
+    })),
+}).annotate({ identifier: "PreviewPublicationSetResponse" });
+export const SearchResponse = Schema.Struct({
+    extensions: Schema.Array(SearchHit).annotate({
+        description: "Extensions matching the query, ordered by recency.",
+    }),
+    has_more: Schema.Boolean.annotate({
+        description: "Whether additional results exist beyond this page.",
+    }),
+    cursor: Schema.Union([
+        Schema.String.annotate({ description: "Opaque cursor for fetching the next page of results." }),
+        Schema.Null,
+    ]),
+    total: Schema.Number.annotate({
+        description: "Exact number of viewer-visible extensions matching the query.",
+    })
+        .check(Schema.isInt().annotate({ expected: "an integer" }))
+        .check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+    total_relation: Schema.Literal("exact"),
+}).annotate({
+    title: "Search Response",
+    description: "A page of extensions matching the search query.",
+    identifier: "SearchResponse",
+});
+export const PreviewPublicationSetRequest = Schema.Struct({
+    contract: Schema.Literal("publication-set-v2"),
+    candidates: Schema.Array(PublicationDescriptor),
+}).annotate({ identifier: "PreviewPublicationSetRequest" });
+export const PublishAuthorizationExchangeResponse = Schema.Union([
+    Schema.Struct({
+        status: Schema.Literal("admitted"),
+        preview: Schema.optionalKey(Schema.Union([PreviewPublicationSetResponse, Schema.Null])),
+        grants: Schema.Array(SessionTokenResponse),
+    }),
+    Schema.Struct({
+        status: Schema.Literal("blocked"),
+        preview: PreviewPublicationSetResponse,
+        grants: Schema.Tuple([]),
+    }),
+]).annotate({ identifier: "PublishAuthorizationExchangeResponse" });
+export const MetaGet200 = MetaResponse;
+export const MetaGet400 = DecodeErrorResponseEncoded;
+export const AuthIssueDeviceCodeRequestFormUrlEncoded = Schema.Struct({
+    client_id: Schema.String.annotate({
+        description: "OAuth public client identifier.",
+        examples: ["example-client"],
+    }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+    scope: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Optional space-delimited registry scopes requested by the client.",
+        }),
+        Schema.Null,
+    ])),
+});
+export const AuthIssueDeviceCode200 = DeviceCodeResponse;
+export const AuthIssueDeviceCode400 = Schema.Union([
+    DeviceCodeOAuthError,
+    DecodeErrorResponseEncoded,
+]);
+export const AuthIssueDeviceCode500 = ProblemDetails;
+export const AuthExchangeTokenRequestFormUrlEncoded = Schema.Struct({
+    grant_type: Schema.String.annotate({
+        description: "OAuth grant type.",
+        examples: [
+            "authorization_code",
+            "urn:ietf:params:oauth:grant-type:device_code",
+            "refresh_token",
+        ],
+    }),
+    code: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Authorization code returned to the loopback callback.",
+        }),
+        Schema.Null,
+    ])),
+    code_verifier: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "PKCE verifier generated by the CLI." }),
+        Schema.Null,
+    ])),
+    client_id: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "OAuth client identifier.",
+            examples: ["example-client"],
+        }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+        Schema.Null,
+    ])),
+    redirect_uri: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Loopback redirect URI the authorization code was bound to.",
+        }),
+        Schema.Null,
+    ])),
+    device_code: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "The device verification code received from the /device/code endpoint.",
+        }),
+        Schema.Null,
+    ])),
+    refresh_token: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Refresh token to exchange for a new token pair." }),
+        Schema.Null,
+    ])),
+    scope: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Optional requested scope for refresh-token exchange.",
+        }),
+        Schema.Null,
+    ])),
+});
+export const AuthExchangeToken200 = Schema.Union([
+    SessionTokenResponse,
+    PublishAuthorizationExchangeResponse,
+]);
+export const AuthExchangeToken400 = Schema.Union([
+    Schema.Union([ProblemDetails, DecodeErrorResponseEncoded]),
+    TokenOAuthErrorEncoded,
+]);
+export const AuthExchangeToken503 = ProblemDetails;
+export const AuthRevokeOAuthTokenRequestFormUrlEncoded = Schema.Struct({
+    token: Schema.String.annotate({
+        description: "The access token or refresh token to revoke. Revocation is idempotent.",
+    }).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+    token_type_hint: Schema.optionalKey(Schema.Union([
+        Schema.Literals(["refresh_token", "access_token"]).annotate({
+            description: "Optional RFC 7009 token type hint. Revocation remains non-enumerating.",
+        }),
+        Schema.Null,
+    ])),
+});
+export const AuthRevokeOAuthToken400 = DecodeErrorResponseEncoded;
+export const AuthRevokeOAuthToken503 = ProblemDetails;
+export const AuthGetWhoami200 = AuthWhoamiResponse;
+export const AuthGetWhoami400 = DecodeErrorResponseEncoded;
+export const AuthGetWhoami401 = ProblemDetails;
+export const AuthGetMe200 = AuthMeResponse;
+export const AuthGetMe400 = DecodeErrorResponseEncoded;
+export const AuthGetMe401 = ProblemDetails;
+export const AuthGetStepUpRequest200 = StepUpRequestStatusResponse;
+export const AuthGetStepUpRequest400 = DecodeErrorResponseEncoded;
+export const AuthGetStepUpRequest401 = ProblemDetails;
+export const AuthGetStepUpRequest404 = ProblemDetails;
+export const AuthCreatePublishAuthorizationRequestRequestJson = Schema.Struct({
+    client_id: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+    redirect_uri: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+    state: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+    code_challenge: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+    code_challenge_method: Schema.Literal("S256"),
+    publication_set: PreviewPublicationSetRequest,
+});
+export const AuthCreatePublishAuthorizationRequest201 = Schema.Struct({
+    request_id: PublishAuthorizationRequestId,
+    authorization_url: Schema.String,
+    expires_at: IsoDateTimeString,
+});
+export const AuthCreatePublishAuthorizationRequest400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const TokensListParams = Schema.Struct({
+    cursor: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Opaque cursor from a previous response for pagination.",
+        }),
+        Schema.Null,
+    ])),
+    limit: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Maximum number of tokens to return (1–100, default 50).",
+        }),
+        Schema.Null,
+    ])),
+});
+export const TokensList200 = TokenListResponse;
+export const TokensList400 = DecodeErrorResponseEncoded;
+export const TokensList401 = ProblemDetails;
+export const TokensList403 = ForbiddenErrorEncoded;
+export const TokensCreateParams = Schema.Struct({
+    "x-axm-step-up-request": Schema.optionalKey(Schema.Union([StepUpRequestId, Schema.Null])),
+});
+export const TokensCreateRequestJson = CreateTokenRequest;
+export const TokensCreate201 = CreateTokenResponse;
+export const TokensCreate400 = DecodeErrorResponseEncoded;
+export const TokensCreate401 = Schema.Union([StepUpRequiredErrorEncoded, ProblemDetails]);
+export const TokensCreate403 = Schema.Union([ForbiddenErrorEncoded, ForbiddenErrorEncoded]);
+export const TokensCreate404 = ProblemDetails;
+export const TokensCreate409 = ProblemDetails;
+export const TokensCreate410 = ProblemDetails;
+export const TokensCreate422 = ProblemDetails;
+export const TokensDelete400 = DecodeErrorResponseEncoded;
+export const TokensDelete401 = ProblemDetails;
+export const TokensDelete403 = ForbiddenErrorEncoded;
+export const OwnersGetOwner200 = OwnerResponse;
+export const OwnersGetOwner400 = DecodeErrorResponseEncoded;
+export const OwnersGetOwner404 = ProblemDetails;
+export const ExtensionsListByOwner200 = Schema.Struct({
+    extensions: Schema.Array(Schema.Struct({
+        name: ExtensionName,
+        owner: Handle,
+        type: ExtensionType,
+        latestVersion: Version,
+        description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+        repository: Schema.optionalKey(Schema.Union([Repository, Schema.Null])),
+        license: Schema.optionalKey(Schema.Union([LicenseExpression, Schema.Null])),
+        authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
+        visibility: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null])),
+        deprecation: Schema.Union([DeprecationView, Schema.Null]),
+    })),
+});
+export const ExtensionsListByOwner400 = DecodeErrorResponseEncoded;
+export const ExtensionsListByTypeParams = Schema.Struct({
+    limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    offset: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+export const ExtensionsListByType200 = Schema.Struct({
+    extensions: Schema.Array(Schema.Struct({
+        name: ExtensionName,
+        owner: Handle,
+        type: ExtensionType,
+        latestVersion: Version,
+        description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+        repository: Schema.optionalKey(Schema.Union([Repository, Schema.Null])),
+        license: Schema.optionalKey(Schema.Union([LicenseExpression, Schema.Null])),
+        authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
+        visibility: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null])),
+        deprecation: Schema.Union([DeprecationView, Schema.Null]),
+    })),
+    total: Schema.Union([
+        Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+        Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+    ]),
+});
+export const ExtensionsListByType400 = DecodeErrorResponseEncoded;
+export const ExtensionsGet200 = Schema.Struct({
+    name: ExtensionName,
+    owner: Handle,
+    type: ExtensionType,
+    publisher_binding_id: Schema.String.annotate({ readOnly: true }),
+    description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    repository: Schema.optionalKey(Schema.Union([Repository, Schema.Null])),
+    bugs: Schema.optionalKey(Schema.Union([Bugs, Schema.Null])),
+    license: Schema.optionalKey(Schema.Union([LicenseExpression, Schema.Null])),
+    authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
+    versions: Schema.Array(Schema.Struct({
+        version: Version,
+        published: IsoDateTimeString,
+        integrity: Schema.String.annotate({ readOnly: true }),
+        dependencies: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, VersionRange), Schema.Null])),
+        packages: Schema.optionalKey(Schema.Union([Schema.Array(CompanionPackage), Schema.Null])),
+        yanked_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
+        yank_category: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+        yank_notice: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    })),
+    visibility: Schema.optionalKey(Schema.Union([
+        Schema.Literals(["public", "private"]).annotate({ readOnly: true }),
+        Schema.Null,
+    ])),
+    deprecation: Schema.Union([DeprecationView, Schema.Null]),
+});
+export const ExtensionsGet400 = DecodeErrorResponseEncoded;
+export const ExtensionsGet404 = ProblemDetails;
+export const ExtensionsDeleteExtensionParams = Schema.Struct({
+    "x-axm-step-up-request": Schema.optionalKey(Schema.Union([StepUpRequestId, Schema.Null])),
+});
+export const ExtensionsDeleteExtensionRequestJson = DeleteExtensionBody;
+export const ExtensionsDeleteExtension202 = Schema.Struct({
+    operationId: ExtensionDeletionOperationId,
+    state: Schema.Literal("pending"),
+    requiredConfirmation: Schema.String,
+    warnings: Schema.Struct({
+        versions: Schema.Array(Schema.String),
+        dependentPackCount: Schema.Union([
+            Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        libraryMembershipCount: Schema.Union([
+            Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        downloadCount: Schema.Union([
+            Schema.Union([
+                Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+                Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+            ]),
+            Schema.Null,
+        ]),
+    }),
+});
+export const ExtensionsDeleteExtension400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const ExtensionsDeleteExtension401 = Schema.Union([
+    StepUpRequiredErrorEncoded,
+    ProblemDetails,
+]);
+export const ExtensionsDeleteExtension403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsDeleteExtension404 = ProblemDetails;
+export const ExtensionsDeleteExtension409 = ProblemDetails;
+export const ExtensionsDeleteExtension410 = ProblemDetails;
+export const ExtensionsUpdateVisibilityParams = Schema.Struct({
+    "x-axm-step-up-request": Schema.optionalKey(Schema.Union([StepUpRequestId, Schema.Null])),
+    "if-match": Schema.String,
+});
+export const ExtensionsUpdateVisibilityRequestJson = VisibilityMutationRequest;
+export const ExtensionsUpdateVisibility200 = VisibilityMutationResult;
+export const ExtensionsUpdateVisibility400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const ExtensionsUpdateVisibility401 = Schema.Union([
+    StepUpRequiredErrorEncoded,
+    ProblemDetails,
+]);
+export const ExtensionsUpdateVisibility403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsUpdateVisibility404 = ProblemDetails;
+export const ExtensionsUpdateVisibility409 = ProblemDetails;
+export const ExtensionsUpdateVisibility410 = ProblemDetails;
+export const ExtensionsUpdateVisibility412 = PreconditionFailedErrorEncoded;
+export const ExtensionsGetVersion200 = Schema.Struct({
+    name: ExtensionName,
+    owner: Handle,
+    type: ExtensionType,
+    publisher_binding_id: Schema.String.annotate({ readOnly: true }),
+    version: Version,
+    status: Schema.Literal("available").annotate({ readOnly: true }),
+    published: IsoDateTimeString,
+    integrity: Schema.String.annotate({ readOnly: true }),
+    description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    repository: Schema.optionalKey(Schema.Union([Repository, Schema.Null])),
+    bugs: Schema.optionalKey(Schema.Union([Bugs, Schema.Null])),
+    license: Schema.optionalKey(Schema.Union([LicenseExpression, Schema.Null])),
+    authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
+    dependencies: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, VersionRange), Schema.Null])),
+    packages: Schema.optionalKey(Schema.Union([Schema.Array(CompanionPackage), Schema.Null])),
+    metadata: Schema.optionalKey(Schema.Union([
+        Schema.Record(Schema.String, Schema.Never).annotate({
+            title: "Extension Metadata",
+            description: "Opaque consumer-defined JSON metadata. The compact UTF-8 JSON representation is limited to 65,536 bytes and container depth 16.",
+        }),
+        Schema.Null,
+    ])),
+    yanked_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
+    yank_category: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    yank_notice: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+export const ExtensionsGetVersion400 = DecodeErrorResponseEncoded;
+export const ExtensionsGetVersion404 = ProblemDetails;
+export const ExtensionsGetVersion410 = ProblemDetails;
+export const ExtensionsPublishVersionParams = Schema.Struct({
+    "if-match": Schema.String,
+    "x-axm-publication-set-digest": Sha256Hex,
+    "x-axm-publication-descriptor-digest": Sha256Hex,
+    "x-axm-visibility-input": Schema.String,
+    visibility: Schema.optionalKey(Schema.Union([Visibility, Schema.Null])),
+});
+export const ExtensionsPublishVersion200 = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+    integrity: Schema.String.annotate({ readOnly: true }),
+    sha256_hex: Schema.String.annotate({ readOnly: true }),
+    published_at: IsoDateTimeString,
+    publish_status: Schema.Literal("available").annotate({ readOnly: true }),
+    visibility: PublishVisibility,
+    warnings: Schema.Array(PublishLintFinding).annotate({ readOnly: true }),
+    links: ExtensionLinks,
+});
+export const ExtensionsPublishVersion201 = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+    integrity: Schema.String.annotate({ readOnly: true }),
+    sha256_hex: Schema.String.annotate({ readOnly: true }),
+    published_at: IsoDateTimeString,
+    publish_status: Schema.Literal("available").annotate({ readOnly: true }),
+    visibility: PublishVisibility,
+    warnings: Schema.Array(PublishLintFinding).annotate({ readOnly: true }),
+    links: ExtensionLinks,
+});
+export const ExtensionsPublishVersion400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const ExtensionsPublishVersion401 = ProblemDetails;
+export const ExtensionsPublishVersion403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsPublishVersion404 = ProblemDetails;
+export const ExtensionsPublishVersion409 = ProblemDetails;
+export const ExtensionsPublishVersion412 = PreconditionFailedErrorEncoded;
+export const ExtensionsPublishVersion413 = ProblemDetails;
+export const ExtensionsPublishVersion415 = ProblemDetails;
+export const ExtensionsPublishVersion422 = Schema.Union([
+    ProblemDetails,
+    ExtensionLintFailedErrorEncoded,
+    ExtensionIdentityMismatchErrorEncoded,
+]);
+export const ExtensionsPublishVersion500 = ProblemDetails;
+export const ExtensionsPublishVersion503 = ProblemDetails;
+export const ExtensionsGetDeletionOperation200 = Schema.Struct({
+    id: ExtensionDeletionOperationId,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    state: Schema.Literals(["pending", "dispatching", "completed", "failed"]),
+    requestedAt: IsoDateTimeString,
+    completedAt: Schema.Union([IsoDateTimeString, Schema.Null]),
+    nameReclaimableAt: Schema.Union([IsoDateTimeString, Schema.Null]),
+    failureCode: Schema.Union([Schema.String, Schema.Null]),
+    failureDetail: Schema.Union([Schema.String, Schema.Null]),
+});
+export const ExtensionsGetDeletionOperation400 = DecodeErrorResponseEncoded;
+export const ExtensionsGetDeletionOperation401 = ProblemDetails;
+export const ExtensionsGetDeletionOperation403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsGetDeletionOperation404 = ProblemDetails;
+export const ExtensionsDownloadArchive400 = DecodeErrorResponseEncoded;
+export const ExtensionsDownloadArchive404 = ProblemDetails;
+export const ExtensionsDownloadArchive500 = ProblemDetails;
+export const ExtensionsGetVisibilityParams = Schema.Struct({
+    intent_visibility: Schema.optionalKey(Schema.Union([Visibility, Schema.Null])),
+    intent_source: Schema.optionalKey(Schema.Union([Schema.Literals(["manifest", "workspace"]), Schema.Null])),
+    intent_fingerprint: Schema.optionalKey(Schema.Union([VisibilityFingerprint, Schema.Null])),
+});
+export const ExtensionsGetVisibility200 = VisibilityEvaluation;
+export const ExtensionsGetVisibility400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const ExtensionsGetVisibility401 = ProblemDetails;
+export const ExtensionsGetVisibility403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsGetVisibility404 = ProblemDetails;
+export const ExtensionsGetDeprecation200 = DeprecationManagementView;
+export const ExtensionsGetDeprecation400 = DecodeErrorResponseEncoded;
+export const ExtensionsGetDeprecation401 = ProblemDetails;
+export const ExtensionsGetDeprecation403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsGetDeprecation404 = ProblemDetails;
+export const ExtensionsPutDeprecationParams = Schema.Struct({ "if-match": Schema.String });
+export const ExtensionsPutDeprecationRequestJson = PutDeprecationBody;
+export const ExtensionsPutDeprecation200 = DeprecationTransition;
+export const ExtensionsPutDeprecation400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const ExtensionsPutDeprecation401 = ProblemDetails;
+export const ExtensionsPutDeprecation403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsPutDeprecation404 = ProblemDetails;
+export const ExtensionsPutDeprecation409 = ProblemDetails;
+export const ExtensionsPutDeprecation412 = PreconditionFailedErrorEncoded;
+export const ExtensionsDeleteDeprecationParams = Schema.Struct({ "if-match": Schema.String });
+export const ExtensionsDeleteDeprecation200 = DeprecationTransition;
+export const ExtensionsDeleteDeprecation400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const ExtensionsDeleteDeprecation401 = ProblemDetails;
+export const ExtensionsDeleteDeprecation403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsDeleteDeprecation404 = ProblemDetails;
+export const ExtensionsDeleteDeprecation409 = ProblemDetails;
+export const ExtensionsDeleteDeprecation412 = PreconditionFailedErrorEncoded;
+export const ExtensionsYankVersionParams = Schema.Struct({
+    "x-axm-step-up-request": Schema.optionalKey(Schema.Union([StepUpRequestId, Schema.Null])),
+});
+export const ExtensionsYankVersionRequestJson = YankVersionBody;
+export const ExtensionsYankVersion200 = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+    yankedAt: Schema.Union([IsoDateTimeString, Schema.Null]),
+    yankCategory: Schema.Union([Schema.String, Schema.Null]),
+    yankNotice: Schema.Union([Schema.String, Schema.Null]),
+    links: ExtensionLinks,
+});
+export const ExtensionsYankVersion400 = DecodeErrorResponseEncoded;
+export const ExtensionsYankVersion401 = Schema.Union([StepUpRequiredErrorEncoded, ProblemDetails]);
+export const ExtensionsYankVersion403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsYankVersion404 = ProblemDetails;
+export const ExtensionsYankVersion409 = ProblemDetails;
+export const ExtensionsYankVersion410 = ProblemDetails;
+export const ExtensionsUnyankVersionParams = Schema.Struct({
+    "x-axm-step-up-request": Schema.optionalKey(Schema.Union([StepUpRequestId, Schema.Null])),
+});
+export const ExtensionsUnyankVersion200 = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+    yankedAt: Schema.Null,
+    yankCategory: Schema.Null,
+    yankNotice: Schema.Null,
+    links: ExtensionLinks,
+});
+export const ExtensionsUnyankVersion400 = DecodeErrorResponseEncoded;
+export const ExtensionsUnyankVersion401 = Schema.Union([
+    StepUpRequiredErrorEncoded,
+    ProblemDetails,
+]);
+export const ExtensionsUnyankVersion403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsUnyankVersion404 = ProblemDetails;
+export const ExtensionsUnyankVersion409 = ProblemDetails;
+export const ExtensionsUnyankVersion410 = ProblemDetails;
+export const ExtensionsYankAvailableVersionsParams = Schema.Struct({
+    "x-axm-step-up-request": Schema.optionalKey(Schema.Union([StepUpRequestId, Schema.Null])),
+});
+export const ExtensionsYankAvailableVersionsRequestJson = YankAvailableVersionsBody;
+export const ExtensionsYankAvailableVersions200 = Schema.Struct({
+    selection: Schema.Literal("all-available"),
+    affectedVersions: Schema.Array(Version),
+    futureVersionsAffected: Schema.Literal(false),
+});
+export const ExtensionsYankAvailableVersions400 = DecodeErrorResponseEncoded;
+export const ExtensionsYankAvailableVersions401 = Schema.Union([
+    StepUpRequiredErrorEncoded,
+    ProblemDetails,
+]);
+export const ExtensionsYankAvailableVersions403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsYankAvailableVersions404 = ProblemDetails;
+export const ExtensionsYankAvailableVersions409 = ProblemDetails;
+export const ExtensionsYankAvailableVersions410 = ProblemDetails;
+export const ExtensionsGetDeletionPreview200 = Schema.Struct({
+    requiredConfirmation: Schema.String,
+    warnings: Schema.Struct({
+        versions: Schema.Array(Schema.String),
+        dependentPackCount: Schema.Union([
+            Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        libraryMembershipCount: Schema.Union([
+            Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        downloadCount: Schema.Union([
+            Schema.Union([
+                Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+                Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+            ]),
+            Schema.Null,
+        ]),
+    }),
+});
+export const ExtensionsGetDeletionPreview400 = DecodeErrorResponseEncoded;
+export const ExtensionsGetDeletionPreview401 = ProblemDetails;
+export const ExtensionsGetDeletionPreview403 = Schema.Union([
+    ForbiddenErrorEncoded,
+    ForbiddenErrorEncoded,
+]);
+export const ExtensionsGetDeletionPreview404 = ProblemDetails;
+export const PublishPreviewsPreviewExtensionPublishesRequestJson = PreviewPublicationSetRequest;
+export const PublishPreviewsPreviewExtensionPublishes200 = PreviewPublicationSetResponse;
+export const PublishPreviewsPreviewExtensionPublishes400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponseEncoded,
+]);
+export const PublishPreviewsPreviewExtensionPublishes401 = ProblemDetails;
+export const PublishPreviewsPreviewExtensionPublishes403 = ForbiddenErrorEncoded;
+export const PublishPreviewsPreviewExtensionPublishes413 = PublishPreviewBatchTooLargeHttpErrorEncoded;
+export const PublishPreviewsPreviewExtensionPublishes503 = ProblemDetails;
+export const LibrariesListLibrariesParams = Schema.Struct({
+    limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    offset: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    q: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    "filter[visibility]": Schema.optionalKey(Schema.Union([LibraryVisibility, Schema.Null])),
+});
+export const LibrariesListLibraries200 = Schema.Struct({
+    libraries: Schema.Array(Library),
+    total: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    limit: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    offset: Schema.Number.check(Schema.isInt().annotate({ expected: "an integer" })),
+    viewerRelative: Schema.Literal(true),
+});
+export const LibrariesListLibraries400 = DecodeErrorResponseEncoded;
+export const LibrariesListLibraries404 = ProblemDetails;
+export const LibrariesGetLibrary200 = LibraryDetail;
+export const LibrariesGetLibrary400 = DecodeErrorResponseEncoded;
+export const LibrariesGetLibrary404 = ProblemDetails;
+export const LibrariesGetLibrary422 = ProblemDetails;
+export const LibrariesListLibraryMembersParams = Schema.Struct({
+    limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    offset: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    q: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    "filter[type]": Schema.optionalKey(Schema.Union([ExtensionType, Schema.Null])),
+});
+export const LibrariesListLibraryMembers200 = ListLibraryMembersResponse;
+export const LibrariesListLibraryMembers400 = DecodeErrorResponseEncoded;
+export const LibrariesListLibraryMembers404 = ProblemDetails;
+export const LibrariesListLibraryMembers422 = ProblemDetails;
+export const DiscoveryPostDiscoveryRequestJson = Schema.Struct({
+    client: Schema.Struct({ axmVersion: Schema.String }),
+    packages: Schema.Array(Schema.Struct({
+        purl: Schema.String,
+        version: Schema.String,
+        declaredExtensions: Schema.Array(Schema.Struct({
+            ref: ExtensionFqn,
+            versionRange: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+        })),
+    })),
+});
+export const DiscoveryPostDiscovery200 = Schema.Struct({
+    results: Schema.Array(Schema.Struct({
+        purl: Schema.String,
+        version: Schema.String,
+        status: Schema.Literals(["resolved", "invalid_purl"]),
+        extensions: Schema.Array(Schema.Struct({
+            ref: Schema.String,
+            resolved: Schema.Boolean,
+            extension: Schema.optionalKey(Schema.Union([
+                Schema.Struct({
+                    owner: Schema.String,
+                    type: Schema.String,
+                    name: Schema.String,
+                    installVersion: Schema.String,
+                }),
+                Schema.Null,
+            ])),
+            attestedBy: Schema.Array(Schema.Literals(["package", "extension"])),
+            official: Schema.Boolean,
+            packageVersionInRange: Schema.Boolean,
+        })),
+    })),
+});
+export const DiscoveryPostDiscovery400 = Schema.Union([ProblemDetails, DecodeErrorResponseEncoded]);
+export const HealthGetShallowHealth200 = Schema.Struct({
+    status: Schema.Literals(["pass", "warn", "fail"]),
+});
+export const HealthGetShallowHealth400 = DecodeErrorResponseEncoded;
+export const HealthGetDeepHealthParams = Schema.Struct({
+    "x-health-key": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+export const HealthGetDeepHealth200 = Schema.Struct({
+    status: Schema.Literals(["pass", "warn", "fail"]),
+    serviceId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    version: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    releaseId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    commit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    environment: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    region: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    checks: Schema.optionalKey(Schema.Union([
+        Schema.Record(Schema.String, Schema.Array(Schema.Struct({
+            componentName: Schema.String,
+            componentType: Schema.Literals(["datastore", "system", "component"]),
+            measurementName: Schema.String,
+            status: Schema.Literals(["pass", "warn", "fail"]),
+            observedValue: Schema.Number.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+            observedUnit: Schema.String,
+            time: IsoDateTimeString,
+            output: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+        }))),
+        Schema.Null,
+    ])),
+    output: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+export const HealthGetDeepHealth400 = DecodeErrorResponseEncoded;
+export const SearchSearchExtensionsParams = Schema.Struct({
+    q: Schema.String.annotate({
+        description: "Search query string. Use an empty string to list the public catalog.",
+        examples: ["git commit", ""],
+    }),
+    cursor: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Opaque cursor from a previous response for pagination.",
+        }),
+        Schema.Null,
+    ])),
+    limit: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Maximum number of results to return (1–100, default 20).",
+        }),
+        Schema.Null,
+    ])),
+    type: Schema.optionalKey(Schema.Union([ExtensionType, Schema.Null])),
+    sort: Schema.optionalKey(Schema.Union([
+        Schema.Literals(["relevance", "popular", "newest", "updated", "name"]),
+        Schema.Null,
+    ])),
+    owner: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    package: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    license: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    lifecycle: Schema.optionalKey(Schema.Union([Schema.Literals(["all", "active", "deprecated"]), Schema.Null])),
+    visibility: Schema.optionalKey(Schema.Union([Schema.Literals(["all", "public", "private"]), Schema.Null])),
+});
+export const SearchSearchExtensions200 = SearchResponse;
+export const SearchSearchExtensions400 = Schema.Union([ProblemDetails, DecodeErrorResponseEncoded]);
+export const DebugDebugStreamParams = Schema.Struct({
+    count: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Number of events to emit (0–100, default 3)." }),
+        Schema.Null,
+    ])),
+    failAfter: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Emit this many events, then terminate the stream with a typed DebugStreamInterrupted failure. Used to exercise client mid-stream failure decoding.",
+        }),
+        Schema.Null,
+    ])),
+});
+export const DebugDebugStream200Sse = Schema.Union([
+    Schema.Struct({
+        id: Schema.optional(Schema.String),
+        event: Schema.String,
+        data: DebugStreamEventEncoded,
+    }),
+    Schema.Struct({
+        id: Schema.optional(Schema.String),
+        event: Schema.Literal("effect/httpapi/stream/failure"),
+        data: Schema.String,
+    }),
+]);
+export const DebugDebugStream400 = DecodeErrorResponseEncoded;
+export const make = (httpClient, options = {}) => {
+    const unexpectedStatus = (response) => Effect.flatMap(Effect.orElseSucceed(response.json, () => "Unexpected status code"), (description) => Effect.fail(new HttpClientError.HttpClientError({
+        reason: new HttpClientError.StatusCodeError({
+            request: response.request,
+            response,
+            description: typeof description === "string" ? description : JSON.stringify(description),
+        }),
+    })));
+    const withResponse = (config) => (f) => {
+        const withOptionalResponse = (config?.includeResponse
+            ? (response) => Effect.map(f(response), (a) => [a, response])
+            : (response) => f(response));
+        return options?.transformClient
+            ? (request) => Effect.flatMap(Effect.flatMap(options.transformClient(httpClient), (client) => client.execute(request)), withOptionalResponse)
+            : (request) => Effect.flatMap(httpClient.execute(request), withOptionalResponse);
+    };
+    const sseEventRequest = (schema) => (request) => HttpClient.filterStatusOk(httpClient)
+        .execute(request)
+        .pipe(Effect.map((response) => response.stream), Stream.unwrap, Stream.decodeText(), Stream.pipeThroughChannel(Sse.decodeSchema(schema)));
+    const decodeBinary = (response) => Effect.map(response.arrayBuffer, (buffer) => new Uint8Array(buffer));
+    const binaryRequest = (request) => HttpClient.filterStatusOk(httpClient)
+        .execute(request)
+        .pipe(Effect.map((response) => response.stream), Stream.unwrap);
+    const decodeVoidError = (tag) => (response) => Effect.fail(RegistryClientError(tag, undefined, response));
+    const decodeSuccess = (schema) => (response) => HttpClientResponse.schemaBodyJson(schema)(response);
+    const decodeError = (tag, schema) => (response) => Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)(response), (cause) => Effect.fail(RegistryClientError(tag, cause, response)));
+    return {
+        httpClient,
+        MetaGet: (options) => HttpClientRequest.get(`/v1`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(MetaGet200),
+            "400": decodeError("MetaGet400", MetaGet400),
+            orElse: unexpectedStatus,
+        }))),
+        AuthIssueDeviceCode: (options) => HttpClientRequest.post(`/v1/auth/device/code`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthIssueDeviceCode200),
+            "400": decodeError("AuthIssueDeviceCode400", AuthIssueDeviceCode400),
+            "500": decodeError("AuthIssueDeviceCode500", AuthIssueDeviceCode500),
+            orElse: unexpectedStatus,
+        }))),
+        AuthExchangeToken: (options) => HttpClientRequest.post(`/v1/auth/token`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthExchangeToken200),
+            "400": decodeError("AuthExchangeToken400", AuthExchangeToken400),
+            "503": decodeError("AuthExchangeToken503", AuthExchangeToken503),
+            orElse: unexpectedStatus,
+        }))),
+        AuthRevokeOAuthToken: (options) => HttpClientRequest.post(`/v1/auth/revoke`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("AuthRevokeOAuthToken400", AuthRevokeOAuthToken400),
+            "503": decodeError("AuthRevokeOAuthToken503", AuthRevokeOAuthToken503),
+            "200": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        AuthGetWhoami: (options) => HttpClientRequest.get(`/v1/auth/whoami`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthGetWhoami200),
+            "400": decodeError("AuthGetWhoami400", AuthGetWhoami400),
+            "401": decodeError("AuthGetWhoami401", AuthGetWhoami401),
+            orElse: unexpectedStatus,
+        }))),
+        AuthGetMe: (options) => HttpClientRequest.get(`/v1/auth/me`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthGetMe200),
+            "400": decodeError("AuthGetMe400", AuthGetMe400),
+            "401": decodeError("AuthGetMe401", AuthGetMe401),
+            orElse: unexpectedStatus,
+        }))),
+        AuthGetStepUpRequest: (requestId, options) => HttpClientRequest.get(`/v1/auth/step-up/requests/${requestId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthGetStepUpRequest200),
+            "400": decodeError("AuthGetStepUpRequest400", AuthGetStepUpRequest400),
+            "401": decodeError("AuthGetStepUpRequest401", AuthGetStepUpRequest401),
+            "404": decodeError("AuthGetStepUpRequest404", AuthGetStepUpRequest404),
+            orElse: unexpectedStatus,
+        }))),
+        AuthCreatePublishAuthorizationRequest: (options) => HttpClientRequest.post(`/v1/auth/publish-requests`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthCreatePublishAuthorizationRequest201),
+            "400": decodeError("AuthCreatePublishAuthorizationRequest400", AuthCreatePublishAuthorizationRequest400),
+            orElse: unexpectedStatus,
+        }))),
+        TokensList: (options) => HttpClientRequest.get(`/v1/tokens`).pipe(HttpClientRequest.setUrlParams({
+            cursor: options?.params?.["cursor"],
+            limit: options?.params?.["limit"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(TokensList200),
+            "400": decodeError("TokensList400", TokensList400),
+            "401": decodeError("TokensList401", TokensList401),
+            "403": decodeError("TokensList403", TokensList403),
+            orElse: unexpectedStatus,
+        }))),
+        TokensCreate: (options) => HttpClientRequest.post(`/v1/tokens`).pipe(HttpClientRequest.setHeaders({
+            "x-axm-step-up-request": options.params?.["x-axm-step-up-request"] ?? undefined,
+        }), HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(TokensCreate201),
+            "400": decodeError("TokensCreate400", TokensCreate400),
+            "401": decodeError("TokensCreate401", TokensCreate401),
+            "403": decodeError("TokensCreate403", TokensCreate403),
+            "404": decodeError("TokensCreate404", TokensCreate404),
+            "409": decodeError("TokensCreate409", TokensCreate409),
+            "410": decodeError("TokensCreate410", TokensCreate410),
+            "422": decodeError("TokensCreate422", TokensCreate422),
+            orElse: unexpectedStatus,
+        }))),
+        TokensDelete: (tokenId, options) => HttpClientRequest.delete(`/v1/tokens/${tokenId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("TokensDelete400", TokensDelete400),
+            "401": decodeError("TokensDelete401", TokensDelete401),
+            "403": decodeError("TokensDelete403", TokensDelete403),
+            "204": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        OwnersGetOwner: (handle, options) => HttpClientRequest.get(`/v1/owners/${handle}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(OwnersGetOwner200),
+            "400": decodeError("OwnersGetOwner400", OwnersGetOwner400),
+            "404": decodeError("OwnersGetOwner404", OwnersGetOwner404),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsListByOwner: (owner, options) => HttpClientRequest.get(`/v1/extensions/${owner}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsListByOwner200),
+            "400": decodeError("ExtensionsListByOwner400", ExtensionsListByOwner400),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsListByType: (owner, type, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}`).pipe(HttpClientRequest.setUrlParams({
+            limit: options?.params?.["limit"],
+            offset: options?.params?.["offset"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsListByType200),
+            "400": decodeError("ExtensionsListByType400", ExtensionsListByType400),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsGet: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "200": decodeSuccess(ExtensionsGet200),
+            "400": decodeError("ExtensionsGet400", ExtensionsGet400),
+            "404": decodeError("ExtensionsGet404", ExtensionsGet404),
+            "304": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsDeleteExtension: (owner, type, name, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}`).pipe(HttpClientRequest.setHeaders({
+            "x-axm-step-up-request": options.params?.["x-axm-step-up-request"] ?? undefined,
+        }), HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsDeleteExtension202),
+            "400": decodeError("ExtensionsDeleteExtension400", ExtensionsDeleteExtension400),
+            "401": decodeError("ExtensionsDeleteExtension401", ExtensionsDeleteExtension401),
+            "403": decodeError("ExtensionsDeleteExtension403", ExtensionsDeleteExtension403),
+            "404": decodeError("ExtensionsDeleteExtension404", ExtensionsDeleteExtension404),
+            "409": decodeError("ExtensionsDeleteExtension409", ExtensionsDeleteExtension409),
+            "410": decodeError("ExtensionsDeleteExtension410", ExtensionsDeleteExtension410),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsHead: (owner, type, name, options) => HttpClientRequest.head(`/v1/extensions/${owner}/${type}/${name}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "200": () => Effect.void,
+            "400": decodeVoidError("400"),
+            "404": decodeVoidError("404"),
+            "500": decodeVoidError("500"),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsUpdateVisibility: (owner, type, name, options) => HttpClientRequest.patch(`/v1/extensions/${owner}/${type}/${name}`).pipe(HttpClientRequest.setHeaders({
+            "x-axm-step-up-request": options.params["x-axm-step-up-request"] ?? undefined,
+            "if-match": options.params["if-match"] ?? undefined,
+        }), HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsUpdateVisibility200),
+            "400": decodeError("ExtensionsUpdateVisibility400", ExtensionsUpdateVisibility400),
+            "401": decodeError("ExtensionsUpdateVisibility401", ExtensionsUpdateVisibility401),
+            "403": decodeError("ExtensionsUpdateVisibility403", ExtensionsUpdateVisibility403),
+            "404": decodeError("ExtensionsUpdateVisibility404", ExtensionsUpdateVisibility404),
+            "409": decodeError("ExtensionsUpdateVisibility409", ExtensionsUpdateVisibility409),
+            "410": decodeError("ExtensionsUpdateVisibility410", ExtensionsUpdateVisibility410),
+            "412": decodeError("ExtensionsUpdateVisibility412", ExtensionsUpdateVisibility412),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsGetVersion: (owner, type, name, version, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/${version}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsGetVersion200),
+            "400": decodeError("ExtensionsGetVersion400", ExtensionsGetVersion400),
+            "404": decodeError("ExtensionsGetVersion404", ExtensionsGetVersion404),
+            "410": decodeError("ExtensionsGetVersion410", ExtensionsGetVersion410),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsPublishVersion: (owner, type, name, version, options) => HttpClientRequest.put(`/v1/extensions/${owner}/${type}/${name}/${version}`).pipe(HttpClientRequest.setUrlParams({ visibility: options.params["visibility"] }), HttpClientRequest.setHeaders({
+            "if-match": options.params["if-match"] ?? undefined,
+            "x-axm-publication-set-digest": options.params["x-axm-publication-set-digest"] ?? undefined,
+            "x-axm-publication-descriptor-digest": options.params["x-axm-publication-descriptor-digest"] ?? undefined,
+            "x-axm-visibility-input": options.params["x-axm-visibility-input"] ?? undefined,
+        }), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "200": decodeSuccess(ExtensionsPublishVersion200),
+            "201": decodeSuccess(ExtensionsPublishVersion201),
+            "400": decodeError("ExtensionsPublishVersion400", ExtensionsPublishVersion400),
+            "401": decodeError("ExtensionsPublishVersion401", ExtensionsPublishVersion401),
+            "403": decodeError("ExtensionsPublishVersion403", ExtensionsPublishVersion403),
+            "404": decodeError("ExtensionsPublishVersion404", ExtensionsPublishVersion404),
+            "409": decodeError("ExtensionsPublishVersion409", ExtensionsPublishVersion409),
+            "412": decodeError("ExtensionsPublishVersion412", ExtensionsPublishVersion412),
+            "413": decodeError("ExtensionsPublishVersion413", ExtensionsPublishVersion413),
+            "415": decodeError("ExtensionsPublishVersion415", ExtensionsPublishVersion415),
+            "422": decodeError("ExtensionsPublishVersion422", ExtensionsPublishVersion422),
+            "500": decodeError("ExtensionsPublishVersion500", ExtensionsPublishVersion500),
+            "503": decodeError("ExtensionsPublishVersion503", ExtensionsPublishVersion503),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsGetDeletionOperation: (operationId, options) => HttpClientRequest.get(`/v1/extensions/deletions/${operationId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsGetDeletionOperation200),
+            "400": decodeError("ExtensionsGetDeletionOperation400", ExtensionsGetDeletionOperation400),
+            "401": decodeError("ExtensionsGetDeletionOperation401", ExtensionsGetDeletionOperation401),
+            "403": decodeError("ExtensionsGetDeletionOperation403", ExtensionsGetDeletionOperation403),
+            "404": decodeError("ExtensionsGetDeletionOperation404", ExtensionsGetDeletionOperation404),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsDownloadArchive: (owner, type, name, version, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/${version}/archive`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeBinary,
+            "400": decodeError("ExtensionsDownloadArchive400", ExtensionsDownloadArchive400),
+            "404": decodeError("ExtensionsDownloadArchive404", ExtensionsDownloadArchive404),
+            "500": decodeError("ExtensionsDownloadArchive500", ExtensionsDownloadArchive500),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsDownloadArchiveStream: (owner, type, name, version) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/${version}/archive`).pipe(binaryRequest),
+        ExtensionsHeadArchive: (owner, type, name, version, options) => HttpClientRequest.head(`/v1/extensions/${owner}/${type}/${name}/${version}/archive`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "200": () => Effect.void,
+            "400": decodeVoidError("400"),
+            "404": decodeVoidError("404"),
+            "500": decodeVoidError("500"),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsGetVisibility: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/visibility`).pipe(HttpClientRequest.setUrlParams({
+            intent_visibility: options?.params?.["intent_visibility"],
+            intent_source: options?.params?.["intent_source"],
+            intent_fingerprint: options?.params?.["intent_fingerprint"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsGetVisibility200),
+            "400": decodeError("ExtensionsGetVisibility400", ExtensionsGetVisibility400),
+            "401": decodeError("ExtensionsGetVisibility401", ExtensionsGetVisibility401),
+            "403": decodeError("ExtensionsGetVisibility403", ExtensionsGetVisibility403),
+            "404": decodeError("ExtensionsGetVisibility404", ExtensionsGetVisibility404),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsGetDeprecation: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/deprecation`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsGetDeprecation200),
+            "400": decodeError("ExtensionsGetDeprecation400", ExtensionsGetDeprecation400),
+            "401": decodeError("ExtensionsGetDeprecation401", ExtensionsGetDeprecation401),
+            "403": decodeError("ExtensionsGetDeprecation403", ExtensionsGetDeprecation403),
+            "404": decodeError("ExtensionsGetDeprecation404", ExtensionsGetDeprecation404),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsPutDeprecation: (owner, type, name, options) => HttpClientRequest.put(`/v1/extensions/${owner}/${type}/${name}/deprecation`).pipe(HttpClientRequest.setHeaders({ "if-match": options.params["if-match"] ?? undefined }), HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsPutDeprecation200),
+            "400": decodeError("ExtensionsPutDeprecation400", ExtensionsPutDeprecation400),
+            "401": decodeError("ExtensionsPutDeprecation401", ExtensionsPutDeprecation401),
+            "403": decodeError("ExtensionsPutDeprecation403", ExtensionsPutDeprecation403),
+            "404": decodeError("ExtensionsPutDeprecation404", ExtensionsPutDeprecation404),
+            "409": decodeError("ExtensionsPutDeprecation409", ExtensionsPutDeprecation409),
+            "412": decodeError("ExtensionsPutDeprecation412", ExtensionsPutDeprecation412),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsDeleteDeprecation: (owner, type, name, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/deprecation`).pipe(HttpClientRequest.setHeaders({ "if-match": options.params["if-match"] ?? undefined }), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsDeleteDeprecation200),
+            "400": decodeError("ExtensionsDeleteDeprecation400", ExtensionsDeleteDeprecation400),
+            "401": decodeError("ExtensionsDeleteDeprecation401", ExtensionsDeleteDeprecation401),
+            "403": decodeError("ExtensionsDeleteDeprecation403", ExtensionsDeleteDeprecation403),
+            "404": decodeError("ExtensionsDeleteDeprecation404", ExtensionsDeleteDeprecation404),
+            "409": decodeError("ExtensionsDeleteDeprecation409", ExtensionsDeleteDeprecation409),
+            "412": decodeError("ExtensionsDeleteDeprecation412", ExtensionsDeleteDeprecation412),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsYankVersion: (owner, type, name, version, options) => HttpClientRequest.post(`/v1/extensions/${owner}/${type}/${name}/${version}/yank`).pipe(HttpClientRequest.setHeaders({
+            "x-axm-step-up-request": options.params?.["x-axm-step-up-request"] ?? undefined,
+        }), HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsYankVersion200),
+            "400": decodeError("ExtensionsYankVersion400", ExtensionsYankVersion400),
+            "401": decodeError("ExtensionsYankVersion401", ExtensionsYankVersion401),
+            "403": decodeError("ExtensionsYankVersion403", ExtensionsYankVersion403),
+            "404": decodeError("ExtensionsYankVersion404", ExtensionsYankVersion404),
+            "409": decodeError("ExtensionsYankVersion409", ExtensionsYankVersion409),
+            "410": decodeError("ExtensionsYankVersion410", ExtensionsYankVersion410),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsUnyankVersion: (owner, type, name, version, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/${version}/yank`).pipe(HttpClientRequest.setHeaders({
+            "x-axm-step-up-request": options?.params?.["x-axm-step-up-request"] ?? undefined,
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsUnyankVersion200),
+            "400": decodeError("ExtensionsUnyankVersion400", ExtensionsUnyankVersion400),
+            "401": decodeError("ExtensionsUnyankVersion401", ExtensionsUnyankVersion401),
+            "403": decodeError("ExtensionsUnyankVersion403", ExtensionsUnyankVersion403),
+            "404": decodeError("ExtensionsUnyankVersion404", ExtensionsUnyankVersion404),
+            "409": decodeError("ExtensionsUnyankVersion409", ExtensionsUnyankVersion409),
+            "410": decodeError("ExtensionsUnyankVersion410", ExtensionsUnyankVersion410),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsYankAvailableVersions: (owner, type, name, options) => HttpClientRequest.post(`/v1/extensions/${owner}/${type}/${name}/versions/yank`).pipe(HttpClientRequest.setHeaders({
+            "x-axm-step-up-request": options.params?.["x-axm-step-up-request"] ?? undefined,
+        }), HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsYankAvailableVersions200),
+            "400": decodeError("ExtensionsYankAvailableVersions400", ExtensionsYankAvailableVersions400),
+            "401": decodeError("ExtensionsYankAvailableVersions401", ExtensionsYankAvailableVersions401),
+            "403": decodeError("ExtensionsYankAvailableVersions403", ExtensionsYankAvailableVersions403),
+            "404": decodeError("ExtensionsYankAvailableVersions404", ExtensionsYankAvailableVersions404),
+            "409": decodeError("ExtensionsYankAvailableVersions409", ExtensionsYankAvailableVersions409),
+            "410": decodeError("ExtensionsYankAvailableVersions410", ExtensionsYankAvailableVersions410),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsGetDeletionPreview: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/deletion`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsGetDeletionPreview200),
+            "400": decodeError("ExtensionsGetDeletionPreview400", ExtensionsGetDeletionPreview400),
+            "401": decodeError("ExtensionsGetDeletionPreview401", ExtensionsGetDeletionPreview401),
+            "403": decodeError("ExtensionsGetDeletionPreview403", ExtensionsGetDeletionPreview403),
+            "404": decodeError("ExtensionsGetDeletionPreview404", ExtensionsGetDeletionPreview404),
+            orElse: unexpectedStatus,
+        }))),
+        PublishPreviewsPreviewExtensionPublishes: (options) => HttpClientRequest.post(`/v1/publish-previews`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(PublishPreviewsPreviewExtensionPublishes200),
+            "400": decodeError("PublishPreviewsPreviewExtensionPublishes400", PublishPreviewsPreviewExtensionPublishes400),
+            "401": decodeError("PublishPreviewsPreviewExtensionPublishes401", PublishPreviewsPreviewExtensionPublishes401),
+            "403": decodeError("PublishPreviewsPreviewExtensionPublishes403", PublishPreviewsPreviewExtensionPublishes403),
+            "413": decodeError("PublishPreviewsPreviewExtensionPublishes413", PublishPreviewsPreviewExtensionPublishes413),
+            "503": decodeError("PublishPreviewsPreviewExtensionPublishes503", PublishPreviewsPreviewExtensionPublishes503),
+            orElse: unexpectedStatus,
+        }))),
+        LibrariesListLibraries: (owner, options) => HttpClientRequest.get(`/v1/libraries/${owner}`).pipe(HttpClientRequest.setUrlParams({
+            limit: options?.params?.["limit"],
+            offset: options?.params?.["offset"],
+            q: options?.params?.["q"],
+            "filter[visibility]": options?.params?.["filter[visibility]"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(LibrariesListLibraries200),
+            "400": decodeError("LibrariesListLibraries400", LibrariesListLibraries400),
+            "404": decodeError("LibrariesListLibraries404", LibrariesListLibraries404),
+            orElse: unexpectedStatus,
+        }))),
+        LibrariesGetLibrary: (owner, name, options) => HttpClientRequest.get(`/v1/libraries/${owner}/${name}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(LibrariesGetLibrary200),
+            "400": decodeError("LibrariesGetLibrary400", LibrariesGetLibrary400),
+            "404": decodeError("LibrariesGetLibrary404", LibrariesGetLibrary404),
+            "422": decodeError("LibrariesGetLibrary422", LibrariesGetLibrary422),
+            orElse: unexpectedStatus,
+        }))),
+        LibrariesListLibraryMembers: (owner, name, options) => HttpClientRequest.get(`/v1/libraries/${owner}/${name}/members`).pipe(HttpClientRequest.setUrlParams({
+            limit: options?.params?.["limit"],
+            offset: options?.params?.["offset"],
+            q: options?.params?.["q"],
+            "filter[type]": options?.params?.["filter[type]"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(LibrariesListLibraryMembers200),
+            "400": decodeError("LibrariesListLibraryMembers400", LibrariesListLibraryMembers400),
+            "404": decodeError("LibrariesListLibraryMembers404", LibrariesListLibraryMembers404),
+            "422": decodeError("LibrariesListLibraryMembers422", LibrariesListLibraryMembers422),
+            orElse: unexpectedStatus,
+        }))),
+        DiscoveryPostDiscovery: (options) => HttpClientRequest.post(`/v1/discovery`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(DiscoveryPostDiscovery200),
+            "400": decodeError("DiscoveryPostDiscovery400", DiscoveryPostDiscovery400),
+            orElse: unexpectedStatus,
+        }))),
+        HealthGetShallowHealth: (options) => HttpClientRequest.get(`/v1/health`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(HealthGetShallowHealth200),
+            "400": decodeError("HealthGetShallowHealth400", HealthGetShallowHealth400),
+            orElse: unexpectedStatus,
+        }))),
+        HealthGetDeepHealth: (options) => HttpClientRequest.get(`/v1/health/dependencies`).pipe(HttpClientRequest.setHeaders({
+            "x-health-key": options?.params?.["x-health-key"] ?? undefined,
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(HealthGetDeepHealth200),
+            "400": decodeError("HealthGetDeepHealth400", HealthGetDeepHealth400),
+            orElse: unexpectedStatus,
+        }))),
+        SearchSearchExtensions: (options) => HttpClientRequest.get(`/v1/search`).pipe(HttpClientRequest.setUrlParams({
+            q: options.params["q"],
+            cursor: options.params["cursor"],
+            limit: options.params["limit"],
+            type: options.params["type"],
+            sort: options.params["sort"],
+            owner: options.params["owner"],
+            package: options.params["package"],
+            license: options.params["license"],
+            lifecycle: options.params["lifecycle"],
+            visibility: options.params["visibility"],
+        }), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(SearchSearchExtensions200),
+            "400": decodeError("SearchSearchExtensions400", SearchSearchExtensions400),
+            orElse: unexpectedStatus,
+        }))),
+        DebugDebugStream: (options) => HttpClientRequest.get(`/v1/debug/stream`).pipe(HttpClientRequest.setUrlParams({
+            count: options?.params?.["count"],
+            failAfter: options?.params?.["failAfter"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("DebugDebugStream400", DebugDebugStream400),
+            orElse: unexpectedStatus,
+        }))),
+        DebugDebugStreamSse: (options) => HttpClientRequest.get(`/v1/debug/stream`).pipe(HttpClientRequest.setUrlParams({
+            count: options?.params?.["count"],
+            failAfter: options?.params?.["failAfter"],
+        }), sseEventRequest(DebugDebugStream200Sse)),
+    };
+};
+class RegistryClientErrorImpl extends Data.Error {
+}
+export const RegistryClientError = (tag, cause, response) => new RegistryClientErrorImpl({
+    _tag: tag,
+    cause,
+    response,
+    request: response.request,
+});
+//# sourceMappingURL=registry-client.js.map