@agentxm/client-core 0.20.0 → 0.21.0

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

@@ -75,7 +75,7 @@ export const PublishDetails = Schema.Struct({
         description: "The scopes present on the token used for the request.",
     })),
     requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({
-        description: "The collaborator role required, if applicable.",
+        description: "The management role required, if applicable.",
     })),
 }).annotate({
     title: "Publish Details",
@@ -176,7 +176,7 @@ export const AuthorizationDenyDetails = Schema.Struct({
     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 collaborator role required, if applicable." })),
+    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.",
@@ -363,8 +363,13 @@ export const PackageIdentityPurl = Schema.String.check(Schema.isMinLength(1)).ch
     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"],
 }));
+export const ExtensionDeletionOperationId = Schema.String.check(Schema.isPattern(new RegExp("^edel_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "Extension Deletion Operation ID",
+    description: "Identifies a durable owner-requested whole-Extension deletion operation.",
+    examples: ["edel_01h455vb4pexka56gq5w2r7cpc"],
+}));
 export const PatchVisibilityBody = Schema.Struct({
-    visibility: Schema.Literals(["public", "internal", "private"]).annotate({
+    visibility: Schema.Literals(["public", "private"]).annotate({
         title: "Visibility",
         description: "Target visibility tier for the extension.",
     }),
@@ -442,6 +447,36 @@ export const PublishIdentityMismatchEntry = Schema.Struct({
     title: "Identity Mismatch Entry",
     description: "Single divergent identity field between URL-path and archive.",
 });
+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)), Schema.Null])),
+}).annotate({
+    title: "Yank Version Body",
+    description: "Optional public context for yanking an extension version.",
+});
+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)), Schema.Null])),
+}).annotate({
+    title: "Yank Available Versions Body",
+    description: "Atomically yanks the snapshot of all currently available versions.",
+});
+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.",
+});
+export const PurgeExtensionVersionBody = Schema.Struct({
+    reason: Schema.Literals(["malware", "exposed_secret", "legal", "privacy", "policy"]),
+    confirmSharedDigest: Schema.Boolean,
+}).annotate({
+    title: "Purge Extension Version Body",
+    description: "Administrative purge reason and explicit acknowledgement of shared-content impact.",
+});
 export const LibraryId = Schema.String.check(Schema.isPattern(new RegExp("^lib_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
     title: "Library ID",
     description: "Identifies a workspace-owned installable collection of extension identities in the registry.",
@@ -452,7 +487,7 @@ export const LibraryName = Schema.String.annotate({
     description: "Canonical Library name within an owner namespace. Uses the same normalized slug grammar as handles.",
     examples: ["frontend", "team-tools"],
 });
-export const LibraryVisibility = Schema.Literals(["public", "internal", "private"]).annotate({
+export const LibraryVisibility = Schema.Literals(["public", "private"]).annotate({
     title: "Library Visibility",
 });
 export const LibraryMemberId = Schema.String.check(Schema.isPattern(new RegExp("^lmem_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
@@ -464,16 +499,6 @@ export const UpdateLibraryBody = Schema.Struct({
     title: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
     description: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
 }).annotate({ title: "Update Library Body" });
-export const PutCollaboratorBody = Schema.Struct({
-    role: Schema.Literals(["write", "read"]).annotate({
-        title: "Collaborator Role",
-        description: "The role to assign to the collaborator.",
-    }),
-}).annotate({
-    title: "Put Collaborator Body",
-    description: "Request body for assigning a collaborator role on an extension.",
-});
-export const UpsertGrantBody = Schema.Struct({ role: Schema.Literals(["read", "write"]) }).annotate({ title: "Upsert Grant Body" });
 export const ExtensionFqn = Schema.String.check(Schema.isPattern(new RegExp("^(@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?)\\/(skills|commands|mcps|subagents|files|rules|hooks|packs)\\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)$"), {
     title: "Extension FQN",
     description: "Canonical extension identifier in @owner/<type>s/<name> form.",
@@ -654,25 +679,6 @@ export const LibraryMaintainerTarget = Schema.Union([
     Schema.Struct({ kind: Schema.Literal("user"), userId: UserId }),
     Schema.Struct({ kind: Schema.Literal("team"), teamId: TeamId }),
 ]).annotate({ title: "Library Maintainer Target" });
-export const ExtensionGrantEntry = Schema.Struct({
-    subject: Schema.Union([
-        Schema.Struct({ kind: Schema.Literal("user"), userId: UserId }),
-        Schema.Struct({ kind: Schema.Literal("team"), teamId: TeamId }),
-    ]),
-    role: Schema.Literals(["read", "write"]),
-    grantedBy: Schema.Union([UserId, Schema.Null]).annotate({ readOnly: true }),
-    createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-}).annotate({ title: "Extension Grant Entry" });
-export const TeamGrant = Schema.Struct({
-    teamId: TeamId,
-    role: Schema.Literals(["read", "write"]),
-    grantedBy: Schema.String,
-    grantedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-}).annotate({ title: "Team Grant" });
-export const UpsertTeamGrantBody = Schema.Struct({
-    teamId: TeamId,
-    role: Schema.Literals(["read", "write"]),
-}).annotate({ title: "Upsert Team Grant Body" });
 export const Maintainer = Schema.Union([
     Schema.Struct({
         kind: Schema.Literal("user"),
@@ -733,6 +739,16 @@ export const PublishIdentity = Schema.Struct({
     title: "Publish Identity",
     description: "URL-path identity of the extension version under publish.",
 });
+export const SharedDigestConfirmationRequiredHttpError = Schema.Struct({
+    kind: Schema.Literal("SharedDigestConfirmationRequiredHttpError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt()),
+    detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
+    code: Schema.Literal("shared_digest_confirmation_required"),
+    affectedCoordinates: Schema.Array(Schema.Struct({ owner: Handle, type: ExtensionType, name: ExtensionName, version: Version })),
+});
 export const SearchHit = Schema.Struct({
     name: ExtensionName,
     owner: Handle,
@@ -829,9 +845,6 @@ export const CreatedLibrary = Schema.Struct({
     createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
     updatedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
 }).annotate({ title: "Created Library" });
-export const ExtensionGrantsResponse = Schema.Struct({
-    grants: Schema.Array(ExtensionGrantEntry),
-}).annotate({ title: "Extension Grants Response" });
 export const TeamList = Schema.Struct({
     items: Schema.Array(Team),
     nextCursor: Schema.Union([Schema.String, Schema.Null]),
@@ -1133,6 +1146,7 @@ export const ExtensionsGet200 = Schema.Struct({
     name: ExtensionName,
     owner: Handle,
     type: ExtensionType,
+    publisher_binding_id: Schema.optionalKey(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])),
@@ -1145,9 +1159,11 @@ export const ExtensionsGet200 = Schema.Struct({
         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", "internal", "private"]).annotate({ readOnly: true }),
+        Schema.Literals(["public", "private"]).annotate({ readOnly: true }),
         Schema.Null,
     ])),
     deprecated_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
@@ -1155,6 +1171,50 @@ export const ExtensionsGet200 = Schema.Struct({
 });
 export const ExtensionsGet400 = DecodeErrorResponse;
 export const ExtensionsGet404 = ProblemDetails;
+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.Union([
+                Schema.Number.check(Schema.isFinite()),
+                Schema.Literal("NaN"),
+                Schema.Literal("Infinity"),
+                Schema.Literal("-Infinity"),
+            ]),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        libraryMembershipCount: Schema.Union([
+            Schema.Union([
+                Schema.Number.check(Schema.isFinite()),
+                Schema.Literal("NaN"),
+                Schema.Literal("Infinity"),
+                Schema.Literal("-Infinity"),
+            ]),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        downloadCount: Schema.Union([
+            Schema.Union([
+                Schema.Union([
+                    Schema.Number.check(Schema.isFinite()),
+                    Schema.Literal("NaN"),
+                    Schema.Literal("Infinity"),
+                    Schema.Literal("-Infinity"),
+                ]),
+                Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+            ]),
+            Schema.Null,
+        ]),
+    }),
+});
+export const ExtensionsDeleteExtension400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
+export const ExtensionsDeleteExtension401 = Schema.Union([StepUpRequiredError, ProblemDetails]);
+export const ExtensionsDeleteExtension403 = Schema.Union([ForbiddenError, ForbiddenError]);
+export const ExtensionsDeleteExtension404 = ProblemDetails;
+export const ExtensionsDeleteExtension409 = ProblemDetails;
 export const ExtensionsUpdateVisibilityRequestJson = PatchVisibilityBody;
 export const ExtensionsUpdateVisibility200 = Schema.Struct({
     id: ExtensionId,
@@ -1169,11 +1229,11 @@ export const ExtensionsUpdateVisibility400 = Schema.Union([ProblemDetails, Decod
 export const ExtensionsUpdateVisibility401 = ProblemDetails;
 export const ExtensionsUpdateVisibility403 = Schema.Union([ForbiddenError, ForbiddenError]);
 export const ExtensionsUpdateVisibility404 = ProblemDetails;
-export const ExtensionsUpdateVisibility422 = ProblemDetails;
 export const ExtensionsGetVersion200 = Schema.Struct({
     name: ExtensionName,
     owner: Handle,
     type: ExtensionType,
+    publisher_binding_id: Schema.optionalKey(Schema.String.annotate({ readOnly: true })),
     version: Version,
     status: Schema.Literals(["pending", "available", "failed"]).annotate({ readOnly: true }),
     published: IsoDateTimeString,
@@ -1186,10 +1246,12 @@ export const ExtensionsGetVersion200 = Schema.Struct({
     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])),
-    deleted_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 = DecodeErrorResponse;
 export const ExtensionsGetVersion404 = ProblemDetails;
+export const ExtensionsGetVersion410 = ProblemDetails;
 export const ExtensionsPublishVersionRequestFormData = Schema.Struct({
     archive: Schema.String.annotate({ description: "Extension archive multipart file part." }),
     integrity: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
@@ -1220,12 +1282,25 @@ export const ExtensionsPublishVersion422 = Schema.Union([
 export const ExtensionsPublishVersion429 = ProblemDetails;
 export const ExtensionsPublishVersion500 = ProblemDetails;
 export const ExtensionsPublishVersion503 = ProblemDetails;
-export const ExtensionsDeleteVersion400 = DecodeErrorResponse;
-export const ExtensionsDeleteVersion401 = ProblemDetails;
-export const ExtensionsDeleteVersion403 = ForbiddenError;
-export const ExtensionsDeleteVersion404 = ProblemDetails;
+export const ExtensionsGetDeletionOperation200 = Schema.Struct({
+    id: ExtensionDeletionOperationId,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    state: Schema.Literals(["pending", "dispatching", "completed", "failed"]),
+    requestedAt: Schema.String,
+    completedAt: Schema.Union([Schema.String, Schema.Null]),
+    nameReclaimableAt: Schema.Union([Schema.String, Schema.Null]),
+    failureCode: Schema.Union([Schema.String, Schema.Null]),
+    failureDetail: Schema.Union([Schema.String, Schema.Null]),
+});
+export const ExtensionsGetDeletionOperation400 = DecodeErrorResponse;
+export const ExtensionsGetDeletionOperation401 = ProblemDetails;
+export const ExtensionsGetDeletionOperation403 = Schema.Union([ForbiddenError, ForbiddenError]);
+export const ExtensionsGetDeletionOperation404 = ProblemDetails;
 export const ExtensionsDownloadArchive400 = DecodeErrorResponse;
 export const ExtensionsDownloadArchive404 = ProblemDetails;
+export const ExtensionsDownloadArchive410 = ProblemDetails;
 export const ExtensionsDownloadArchive500 = ProblemDetails;
 export const ExtensionsDeprecateRequestJson = DeprecateBody;
 export const ExtensionsDeprecate200 = Schema.Struct({
@@ -1253,12 +1328,15 @@ export const ExtensionsUndeprecate400 = DecodeErrorResponse;
 export const ExtensionsUndeprecate401 = ProblemDetails;
 export const ExtensionsUndeprecate403 = ForbiddenError;
 export const ExtensionsUndeprecate404 = ProblemDetails;
+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 = DecodeErrorResponse;
@@ -1271,12 +1349,84 @@ export const ExtensionsUnyankVersion200 = Schema.Struct({
     name: ExtensionName,
     version: Version,
     yankedAt: Schema.Null,
+    yankCategory: Schema.Null,
+    yankNotice: Schema.Null,
     links: ExtensionLinks,
 });
 export const ExtensionsUnyankVersion400 = DecodeErrorResponse;
 export const ExtensionsUnyankVersion401 = Schema.Union([StepUpRequiredError, ProblemDetails]);
 export const ExtensionsUnyankVersion403 = ForbiddenError;
 export const ExtensionsUnyankVersion404 = ProblemDetails;
+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 = DecodeErrorResponse;
+export const ExtensionsYankAvailableVersions401 = Schema.Union([
+    StepUpRequiredError,
+    ProblemDetails,
+]);
+export const ExtensionsYankAvailableVersions403 = ForbiddenError;
+export const ExtensionsYankAvailableVersions404 = ProblemDetails;
+export const ExtensionsGetDeletionPreview200 = Schema.Struct({
+    requiredConfirmation: Schema.String,
+    warnings: Schema.Struct({
+        versions: Schema.Array(Schema.String),
+        dependentPackCount: Schema.Union([
+            Schema.Union([
+                Schema.Number.check(Schema.isFinite()),
+                Schema.Literal("NaN"),
+                Schema.Literal("Infinity"),
+                Schema.Literal("-Infinity"),
+            ]),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        libraryMembershipCount: Schema.Union([
+            Schema.Union([
+                Schema.Number.check(Schema.isFinite()),
+                Schema.Literal("NaN"),
+                Schema.Literal("Infinity"),
+                Schema.Literal("-Infinity"),
+            ]),
+            Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+        ]),
+        downloadCount: Schema.Union([
+            Schema.Union([
+                Schema.Union([
+                    Schema.Number.check(Schema.isFinite()),
+                    Schema.Literal("NaN"),
+                    Schema.Literal("Infinity"),
+                    Schema.Literal("-Infinity"),
+                ]),
+                Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+            ]),
+            Schema.Null,
+        ]),
+    }),
+});
+export const ExtensionsGetDeletionPreview400 = DecodeErrorResponse;
+export const ExtensionsGetDeletionPreview401 = ProblemDetails;
+export const ExtensionsGetDeletionPreview403 = Schema.Union([ForbiddenError, ForbiddenError]);
+export const ExtensionsGetDeletionPreview404 = ProblemDetails;
+export const AdminExtensionsPurgeExtensionVersionRequestJson = PurgeExtensionVersionBody;
+export const AdminExtensionsPurgeExtensionVersion202 = Schema.Struct({
+    operationId: Schema.String,
+    affectedCoordinates: Schema.Array(Schema.Struct({ owner: Handle, type: ExtensionType, name: ExtensionName, version: Version })),
+    archivePurgeState: Schema.Literal("pending"),
+});
+export const AdminExtensionsPurgeExtensionVersion400 = DecodeErrorResponse;
+export const AdminExtensionsPurgeExtensionVersion401 = Schema.Union([
+    StepUpRequiredError,
+    ProblemDetails,
+]);
+export const AdminExtensionsPurgeExtensionVersion403 = Schema.Union([
+    ForbiddenError,
+    ForbiddenError,
+]);
+export const AdminExtensionsPurgeExtensionVersion404 = ProblemDetails;
+export const AdminExtensionsPurgeExtensionVersion409 = SharedDigestConfirmationRequiredHttpError;
 export const LibrariesListLibraries200 = Schema.Struct({ libraries: Schema.Array(Library) });
 export const LibrariesListLibraries400 = DecodeErrorResponse;
 export const LibrariesListLibraries404 = ProblemDetails;
@@ -1336,95 +1486,6 @@ export const LibrariesRemoveLibraryMember401 = ProblemDetails;
 export const LibrariesRemoveLibraryMember403 = Schema.Union([ForbiddenError, ForbiddenError]);
 export const LibrariesRemoveLibraryMember404 = ProblemDetails;
 export const LibrariesRemoveLibraryMember422 = ProblemDetails;
-export const CollaboratorsListCollaborators200 = Schema.Struct({
-    collaborators: Schema.Array(Schema.Struct({
-        userId: UserId,
-        role: Schema.String,
-        grantedBy: Schema.Union([UserId, Schema.Null]).annotate({ readOnly: true }),
-        createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-    })),
-});
-export const CollaboratorsListCollaborators400 = DecodeErrorResponse;
-export const CollaboratorsListCollaborators401 = ProblemDetails;
-export const CollaboratorsListCollaborators403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const CollaboratorsListCollaborators404 = ProblemDetails;
-export const CollaboratorsUpsertCollaboratorRequestJson = PutCollaboratorBody;
-export const CollaboratorsUpsertCollaborator200 = Schema.Struct({
-    userId: UserId,
-    role: Schema.String,
-    grantedBy: Schema.Union([UserId, Schema.Null]).annotate({ readOnly: true }),
-    createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-});
-export const CollaboratorsUpsertCollaborator400 = Schema.Union([
-    ProblemDetails,
-    DecodeErrorResponse,
-]);
-export const CollaboratorsUpsertCollaborator401 = ProblemDetails;
-export const CollaboratorsUpsertCollaborator403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const CollaboratorsUpsertCollaborator404 = ProblemDetails;
-export const CollaboratorsDeleteCollaborator400 = DecodeErrorResponse;
-export const CollaboratorsDeleteCollaborator401 = ProblemDetails;
-export const CollaboratorsDeleteCollaborator403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const CollaboratorsDeleteCollaborator404 = ProblemDetails;
-export const CollaboratorsDeleteCollaborator409 = ProblemDetails;
-export const TeamGrantsListExtensionGrants200 = ExtensionGrantsResponse;
-export const TeamGrantsListExtensionGrants400 = DecodeErrorResponse;
-export const TeamGrantsListExtensionGrants401 = ProblemDetails;
-export const TeamGrantsListExtensionGrants403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const TeamGrantsListExtensionGrants404 = ProblemDetails;
-export const TeamGrantsUpsertTeamExtensionGrantRequestJson = UpsertTeamGrantBody;
-export const TeamGrantsUpsertTeamExtensionGrant200 = TeamGrant;
-export const TeamGrantsUpsertTeamExtensionGrant400 = Schema.Union([
-    ProblemDetails,
-    DecodeErrorResponse,
-]);
-export const TeamGrantsUpsertTeamExtensionGrant401 = ProblemDetails;
-export const TeamGrantsUpsertTeamExtensionGrant403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const TeamGrantsUpsertTeamExtensionGrant404 = ProblemDetails;
-export const TeamGrantsUpsertTeamExtensionGrant422 = ProblemDetails;
-export const TeamGrantsUpsertUserExtensionGrantRequestJson = UpsertGrantBody;
-export const TeamGrantsUpsertUserExtensionGrant200 = Schema.Struct({
-    userId: UserId,
-    role: Schema.String,
-    grantedBy: Schema.Union([UserId, Schema.Null]).annotate({ readOnly: true }),
-    createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-});
-export const TeamGrantsUpsertUserExtensionGrant400 = Schema.Union([
-    ProblemDetails,
-    DecodeErrorResponse,
-]);
-export const TeamGrantsUpsertUserExtensionGrant401 = ProblemDetails;
-export const TeamGrantsUpsertUserExtensionGrant403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const TeamGrantsUpsertUserExtensionGrant404 = ProblemDetails;
-export const TeamGrantsDeleteUserExtensionGrant400 = DecodeErrorResponse;
-export const TeamGrantsDeleteUserExtensionGrant401 = ProblemDetails;
-export const TeamGrantsDeleteUserExtensionGrant403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const TeamGrantsDeleteUserExtensionGrant404 = ProblemDetails;
-export const TeamGrantsDeleteUserExtensionGrant409 = ProblemDetails;
-export const TeamGrantsUpsertTeamExtensionGrantByIdRequestJson = UpsertGrantBody;
-export const TeamGrantsUpsertTeamExtensionGrantById200 = TeamGrant;
-export const TeamGrantsUpsertTeamExtensionGrantById400 = Schema.Union([
-    ProblemDetails,
-    DecodeErrorResponse,
-]);
-export const TeamGrantsUpsertTeamExtensionGrantById401 = ProblemDetails;
-export const TeamGrantsUpsertTeamExtensionGrantById403 = Schema.Union([
-    ForbiddenError,
-    ForbiddenError,
-]);
-export const TeamGrantsUpsertTeamExtensionGrantById404 = ProblemDetails;
-export const TeamGrantsUpsertTeamExtensionGrantById422 = ProblemDetails;
-export const TeamGrantsDeleteTeamExtensionGrantById400 = DecodeErrorResponse;
-export const TeamGrantsDeleteTeamExtensionGrantById401 = ProblemDetails;
-export const TeamGrantsDeleteTeamExtensionGrantById403 = Schema.Union([
-    ForbiddenError,
-    ForbiddenError,
-]);
-export const TeamGrantsDeleteTeamExtensionGrantById404 = ProblemDetails;
-export const TeamGrantsDeleteTeamExtensionGrant400 = DecodeErrorResponse;
-export const TeamGrantsDeleteTeamExtensionGrant401 = ProblemDetails;
-export const TeamGrantsDeleteTeamExtensionGrant403 = Schema.Union([ForbiddenError, ForbiddenError]);
-export const TeamGrantsDeleteTeamExtensionGrant404 = ProblemDetails;
 export const MaintainerGetMaintainer200 = Maintainer;
 export const MaintainerGetMaintainer400 = DecodeErrorResponse;
 export const MaintainerGetMaintainer401 = ProblemDetails;
@@ -1774,6 +1835,15 @@ export const make = (httpClient, options = {}) => {
             "304": () => Effect.void,
             orElse: unexpectedStatus,
         }))),
+        ExtensionsDeleteExtension: (owner, type, name, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}`).pipe(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),
+            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"),
@@ -1787,13 +1857,13 @@ export const make = (httpClient, options = {}) => {
             "401": decodeError("ExtensionsUpdateVisibility401", ExtensionsUpdateVisibility401),
             "403": decodeError("ExtensionsUpdateVisibility403", ExtensionsUpdateVisibility403),
             "404": decodeError("ExtensionsUpdateVisibility404", ExtensionsUpdateVisibility404),
-            "422": decodeError("ExtensionsUpdateVisibility422", ExtensionsUpdateVisibility422),
             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.bodyFormData(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
@@ -1811,18 +1881,19 @@ export const make = (httpClient, options = {}) => {
             "503": decodeError("ExtensionsPublishVersion503", ExtensionsPublishVersion503),
             orElse: unexpectedStatus,
         }))),
-        ExtensionsDeleteVersion: (owner, type, name, version, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/${version}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "400": decodeError("ExtensionsDeleteVersion400", ExtensionsDeleteVersion400),
-            "401": decodeError("ExtensionsDeleteVersion401", ExtensionsDeleteVersion401),
-            "403": decodeError("ExtensionsDeleteVersion403", ExtensionsDeleteVersion403),
-            "404": decodeError("ExtensionsDeleteVersion404", ExtensionsDeleteVersion404),
-            "204": () => Effect.void,
+        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),
+            "410": decodeError("ExtensionsDownloadArchive410", ExtensionsDownloadArchive410),
             "500": decodeError("ExtensionsDownloadArchive500", ExtensionsDownloadArchive500),
             orElse: unexpectedStatus,
         }))),
@@ -1843,7 +1914,7 @@ export const make = (httpClient, options = {}) => {
             "404": decodeError("ExtensionsUndeprecate404", ExtensionsUndeprecate404),
             orElse: unexpectedStatus,
         }))),
-        ExtensionsYankVersion: (owner, type, name, version, options) => HttpClientRequest.post(`/v1/extensions/${owner}/${type}/${name}/${version}/yank`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+        ExtensionsYankVersion: (owner, type, name, version, options) => HttpClientRequest.post(`/v1/extensions/${owner}/${type}/${name}/${version}/yank`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(ExtensionsYankVersion200),
             "400": decodeError("ExtensionsYankVersion400", ExtensionsYankVersion400),
             "401": decodeError("ExtensionsYankVersion401", ExtensionsYankVersion401),
@@ -1859,6 +1930,31 @@ export const make = (httpClient, options = {}) => {
             "404": decodeError("ExtensionsUnyankVersion404", ExtensionsUnyankVersion404),
             orElse: unexpectedStatus,
         }))),
+        ExtensionsYankAvailableVersions: (owner, type, name, options) => HttpClientRequest.post(`/v1/extensions/${owner}/${type}/${name}/versions/yank`).pipe(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),
+            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,
+        }))),
+        AdminExtensionsPurgeExtensionVersion: (owner, type, name, version, options) => HttpClientRequest.post(`/v1/admin/extensions/${owner}/${type}/${name}/${version}/purge`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AdminExtensionsPurgeExtensionVersion202),
+            "400": decodeError("AdminExtensionsPurgeExtensionVersion400", AdminExtensionsPurgeExtensionVersion400),
+            "401": decodeError("AdminExtensionsPurgeExtensionVersion401", AdminExtensionsPurgeExtensionVersion401),
+            "403": decodeError("AdminExtensionsPurgeExtensionVersion403", AdminExtensionsPurgeExtensionVersion403),
+            "404": decodeError("AdminExtensionsPurgeExtensionVersion404", AdminExtensionsPurgeExtensionVersion404),
+            "409": decodeError("AdminExtensionsPurgeExtensionVersion409", AdminExtensionsPurgeExtensionVersion409),
+            orElse: unexpectedStatus,
+        }))),
         LibrariesListLibraries: (owner, options) => HttpClientRequest.get(`/v1/libraries/${owner}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(LibrariesListLibraries200),
             "400": decodeError("LibrariesListLibraries400", LibrariesListLibraries400),
@@ -1946,90 +2042,6 @@ export const make = (httpClient, options = {}) => {
             "204": () => Effect.void,
             orElse: unexpectedStatus,
         }))),
-        CollaboratorsListCollaborators: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/collaborators`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(CollaboratorsListCollaborators200),
-            "400": decodeError("CollaboratorsListCollaborators400", CollaboratorsListCollaborators400),
-            "401": decodeError("CollaboratorsListCollaborators401", CollaboratorsListCollaborators401),
-            "403": decodeError("CollaboratorsListCollaborators403", CollaboratorsListCollaborators403),
-            "404": decodeError("CollaboratorsListCollaborators404", CollaboratorsListCollaborators404),
-            orElse: unexpectedStatus,
-        }))),
-        CollaboratorsUpsertCollaborator: (owner, type, name, userId, options) => HttpClientRequest.put(`/v1/extensions/${owner}/${type}/${name}/collaborators/${userId}`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(CollaboratorsUpsertCollaborator200),
-            "400": decodeError("CollaboratorsUpsertCollaborator400", CollaboratorsUpsertCollaborator400),
-            "401": decodeError("CollaboratorsUpsertCollaborator401", CollaboratorsUpsertCollaborator401),
-            "403": decodeError("CollaboratorsUpsertCollaborator403", CollaboratorsUpsertCollaborator403),
-            "404": decodeError("CollaboratorsUpsertCollaborator404", CollaboratorsUpsertCollaborator404),
-            orElse: unexpectedStatus,
-        }))),
-        CollaboratorsDeleteCollaborator: (owner, type, name, userId, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/collaborators/${userId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "400": decodeError("CollaboratorsDeleteCollaborator400", CollaboratorsDeleteCollaborator400),
-            "401": decodeError("CollaboratorsDeleteCollaborator401", CollaboratorsDeleteCollaborator401),
-            "403": decodeError("CollaboratorsDeleteCollaborator403", CollaboratorsDeleteCollaborator403),
-            "404": decodeError("CollaboratorsDeleteCollaborator404", CollaboratorsDeleteCollaborator404),
-            "409": decodeError("CollaboratorsDeleteCollaborator409", CollaboratorsDeleteCollaborator409),
-            "204": () => Effect.void,
-            orElse: unexpectedStatus,
-        }))),
-        TeamGrantsListExtensionGrants: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/grants`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(TeamGrantsListExtensionGrants200),
-            "400": decodeError("TeamGrantsListExtensionGrants400", TeamGrantsListExtensionGrants400),
-            "401": decodeError("TeamGrantsListExtensionGrants401", TeamGrantsListExtensionGrants401),
-            "403": decodeError("TeamGrantsListExtensionGrants403", TeamGrantsListExtensionGrants403),
-            "404": decodeError("TeamGrantsListExtensionGrants404", TeamGrantsListExtensionGrants404),
-            orElse: unexpectedStatus,
-        }))),
-        TeamGrantsUpsertTeamExtensionGrant: (owner, type, name, options) => HttpClientRequest.post(`/v1/extensions/${owner}/${type}/${name}/grants`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(TeamGrantsUpsertTeamExtensionGrant200),
-            "400": decodeError("TeamGrantsUpsertTeamExtensionGrant400", TeamGrantsUpsertTeamExtensionGrant400),
-            "401": decodeError("TeamGrantsUpsertTeamExtensionGrant401", TeamGrantsUpsertTeamExtensionGrant401),
-            "403": decodeError("TeamGrantsUpsertTeamExtensionGrant403", TeamGrantsUpsertTeamExtensionGrant403),
-            "404": decodeError("TeamGrantsUpsertTeamExtensionGrant404", TeamGrantsUpsertTeamExtensionGrant404),
-            "422": decodeError("TeamGrantsUpsertTeamExtensionGrant422", TeamGrantsUpsertTeamExtensionGrant422),
-            orElse: unexpectedStatus,
-        }))),
-        TeamGrantsUpsertUserExtensionGrant: (owner, type, name, userId, options) => HttpClientRequest.put(`/v1/extensions/${owner}/${type}/${name}/grants/user/${userId}`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(TeamGrantsUpsertUserExtensionGrant200),
-            "400": decodeError("TeamGrantsUpsertUserExtensionGrant400", TeamGrantsUpsertUserExtensionGrant400),
-            "401": decodeError("TeamGrantsUpsertUserExtensionGrant401", TeamGrantsUpsertUserExtensionGrant401),
-            "403": decodeError("TeamGrantsUpsertUserExtensionGrant403", TeamGrantsUpsertUserExtensionGrant403),
-            "404": decodeError("TeamGrantsUpsertUserExtensionGrant404", TeamGrantsUpsertUserExtensionGrant404),
-            orElse: unexpectedStatus,
-        }))),
-        TeamGrantsDeleteUserExtensionGrant: (owner, type, name, userId, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/grants/user/${userId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "400": decodeError("TeamGrantsDeleteUserExtensionGrant400", TeamGrantsDeleteUserExtensionGrant400),
-            "401": decodeError("TeamGrantsDeleteUserExtensionGrant401", TeamGrantsDeleteUserExtensionGrant401),
-            "403": decodeError("TeamGrantsDeleteUserExtensionGrant403", TeamGrantsDeleteUserExtensionGrant403),
-            "404": decodeError("TeamGrantsDeleteUserExtensionGrant404", TeamGrantsDeleteUserExtensionGrant404),
-            "409": decodeError("TeamGrantsDeleteUserExtensionGrant409", TeamGrantsDeleteUserExtensionGrant409),
-            "204": () => Effect.void,
-            orElse: unexpectedStatus,
-        }))),
-        TeamGrantsUpsertTeamExtensionGrantById: (owner, type, name, teamId, options) => HttpClientRequest.put(`/v1/extensions/${owner}/${type}/${name}/grants/team/${teamId}`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(TeamGrantsUpsertTeamExtensionGrantById200),
-            "400": decodeError("TeamGrantsUpsertTeamExtensionGrantById400", TeamGrantsUpsertTeamExtensionGrantById400),
-            "401": decodeError("TeamGrantsUpsertTeamExtensionGrantById401", TeamGrantsUpsertTeamExtensionGrantById401),
-            "403": decodeError("TeamGrantsUpsertTeamExtensionGrantById403", TeamGrantsUpsertTeamExtensionGrantById403),
-            "404": decodeError("TeamGrantsUpsertTeamExtensionGrantById404", TeamGrantsUpsertTeamExtensionGrantById404),
-            "422": decodeError("TeamGrantsUpsertTeamExtensionGrantById422", TeamGrantsUpsertTeamExtensionGrantById422),
-            orElse: unexpectedStatus,
-        }))),
-        TeamGrantsDeleteTeamExtensionGrantById: (owner, type, name, teamId, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/grants/team/${teamId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "400": decodeError("TeamGrantsDeleteTeamExtensionGrantById400", TeamGrantsDeleteTeamExtensionGrantById400),
-            "401": decodeError("TeamGrantsDeleteTeamExtensionGrantById401", TeamGrantsDeleteTeamExtensionGrantById401),
-            "403": decodeError("TeamGrantsDeleteTeamExtensionGrantById403", TeamGrantsDeleteTeamExtensionGrantById403),
-            "404": decodeError("TeamGrantsDeleteTeamExtensionGrantById404", TeamGrantsDeleteTeamExtensionGrantById404),
-            "204": () => Effect.void,
-            orElse: unexpectedStatus,
-        }))),
-        TeamGrantsDeleteTeamExtensionGrant: (owner, type, name, teamId, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/grants/${teamId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "400": decodeError("TeamGrantsDeleteTeamExtensionGrant400", TeamGrantsDeleteTeamExtensionGrant400),
-            "401": decodeError("TeamGrantsDeleteTeamExtensionGrant401", TeamGrantsDeleteTeamExtensionGrant401),
-            "403": decodeError("TeamGrantsDeleteTeamExtensionGrant403", TeamGrantsDeleteTeamExtensionGrant403),
-            "404": decodeError("TeamGrantsDeleteTeamExtensionGrant404", TeamGrantsDeleteTeamExtensionGrant404),
-            "204": () => Effect.void,
-            orElse: unexpectedStatus,
-        }))),
         MaintainerGetMaintainer: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/maintainer`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(MaintainerGetMaintainer200),
             "400": decodeError("MaintainerGetMaintainer400", MaintainerGetMaintainer400),