@agentxm/client-core 0.20.1 → 0.21.1

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",
@@ -83,9 +83,12 @@ export const PublishDetails = Schema.Struct({
 });
 export const SessionTokenResponse = Schema.Struct({
     access_token: Schema.String.annotate({ description: "OAuth 2.0 access token." }),
-    refresh_token: Schema.String.annotate({
-        description: "OAuth 2.0 refresh token for obtaining new token pairs.",
-    }),
+    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.",
@@ -98,6 +101,12 @@ export const SessionTokenResponse = Schema.Struct({
         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,
+    ])),
 }).annotate({
     title: "Session Token Response",
     description: "OAuth 2.0 token response containing an access/refresh token pair.",
@@ -152,12 +161,45 @@ export const StepUpChallengeResponse = Schema.Union([
         expires_at: Schema.String.annotate({ description: "ISO timestamp when this proof expires." }),
     }),
 ]).annotate({ title: "Step-up Challenge Response" });
+export const Handle = Schema.String.check(Schema.isPattern(new RegExp("^@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?$"), {
+    title: "Handle",
+    description: "A unique username or organization name starting with @, like @my-org.",
+    examples: ["@my-org", "@username"],
+}));
+export const ExtensionType = Schema.Literals([
+    "skill",
+    "command",
+    "mcp-server",
+    "subagent",
+    "files",
+    "rule",
+    "hook",
+    "pack",
+]).annotate({
+    title: "Extension Type",
+    description: "What kind of extension this is: skill, command, mcp-server, subagent, context, rule, hook, or pack.",
+});
+export const ExtensionName = Schema.String.check(Schema.isMinLength(1)).check(Schema.isPattern(new RegExp("^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$"), {
+    title: "Extension Name",
+    description: "The name of an extension — lowercase letters, numbers, and hyphens (e.g. my-skill).",
+    examples: ["my-skill", "code-review", "prettier"],
+}));
+export const Version = Schema.String.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-]+)*))?$"), {
+    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"],
+}));
+export const PublishAuthorizationRequestId = Schema.String.check(Schema.isPattern(new RegExp("^pubreq_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "Publish Authorization Request ID",
+    description: "Identifies one exact browser-reviewed publish authorization request.",
+    examples: ["pubreq_01h455vb4pexka56gq5w2r7cpc"],
+}));
+export const IsoDateTimeString = Schema.String.check(Schema.isMinLength(1));
 export const TokenId = Schema.String.check(Schema.isPattern(new RegExp("^tok_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
     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"],
 }));
-export const IsoDateTimeString = Schema.String.check(Schema.isMinLength(1));
 export const ScopeCheckDetails = Schema.Struct({
     requiredScope: Schema.String.annotate({
         description: "The scope required to perform the requested operation.",
@@ -176,7 +218,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.",
@@ -217,11 +259,6 @@ export const StepUpRequiredError = Schema.Struct({
     authUrl: Schema.String,
     doneUrl: Schema.String,
 });
-export const Handle = Schema.String.check(Schema.isPattern(new RegExp("^@[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?$"), {
-    title: "Handle",
-    description: "A unique username or organization name starting with @, like @my-org.",
-    examples: ["@my-org", "@username"],
-}));
 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." });
@@ -274,29 +311,6 @@ export const ChangeTeamMemberRoleBody = Schema.Struct({
         description: "Role within a team — 'admin' manages membership and grants; 'member' inherits grants.",
     }),
 }).annotate({ title: "Change Team Member Role Body" });
-export const ExtensionName = Schema.String.check(Schema.isMinLength(1)).check(Schema.isPattern(new RegExp("^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$"), {
-    title: "Extension Name",
-    description: "The name of an extension — lowercase letters, numbers, and hyphens (e.g. my-skill).",
-    examples: ["my-skill", "code-review", "prettier"],
-}));
-export const ExtensionType = Schema.Literals([
-    "skill",
-    "command",
-    "mcp-server",
-    "subagent",
-    "files",
-    "rule",
-    "hook",
-    "pack",
-]).annotate({
-    title: "Extension Type",
-    description: "What kind of extension this is: skill, command, mcp-server, subagent, context, rule, hook, or pack.",
-});
-export const Version = Schema.String.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-]+)*))?$"), {
-    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"],
-}));
 export const Repository = Schema.Struct({
     url: Schema.String.annotate({
         description: "Canonical repository URL for the extension source.",
@@ -363,8 +377,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,9 +461,42 @@ 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 LibraryVisibility = Schema.Literals(["public", "private"]).annotate({
+    title: "Library Visibility",
+});
 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.",
+    description: "Identifies an account-owned installable collection of extension identities in the registry.",
     examples: ["lib_01h455vb4pexka56gq5w2r7cpc"],
 }));
 export const LibraryName = Schema.String.annotate({
@@ -452,28 +504,20 @@ 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({
-    title: "Library Visibility",
-});
 export const LibraryMemberId = Schema.String.check(Schema.isPattern(new RegExp("^lmem_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
     title: "Library Member ID",
     description: "Identifies an extension identity membership inside an installable registry library.",
     examples: ["lmem_01h455vb4pexka56gq5w2r7cpc"],
 }));
+export const ExtensionVersionId = Schema.String.check(Schema.isPattern(new RegExp("^extv_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "Extension Version ID",
+    description: "Identifies a specific published version of an extension. Each publish operation creates a new version under its parent extension.",
+    examples: ["extv_01h455vb4pexka56gq5w2r7cpc"],
+}));
 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.",
@@ -519,7 +563,7 @@ 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"]).annotate({
+    type: Schema.Literals(["session", "pat", "oidc", "publish-capability"]).annotate({
         title: "Token Type",
         description: "The type of authentication token.",
     }),
@@ -540,6 +584,30 @@ export const AuthMeToken = Schema.Struct({
     title: "Token Info",
     description: "Details about the token you used to authenticate.",
 });
+export const LibraryMemberCoordinate = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+}).annotate({ title: "Library Member Coordinate" });
+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.",
+});
+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 TokenListItem = Schema.Struct({
     id: TokenId,
     name: Schema.Union([
@@ -583,6 +651,7 @@ export const ForbiddenError = Schema.Struct({
         "resource_restriction",
         "scope_escalation",
         "gat_requires_session",
+        "recent_authentication_required",
         "team_create_not_authorized",
         "team_delete_not_authorized",
         "team_update_not_authorized",
@@ -597,6 +666,8 @@ export const ForbiddenError = Schema.Struct({
         "publish/resource-restriction",
         "publish/handle-not-owned",
         "publish/publish-forbidden",
+        "publish/capability-binding-mismatch",
+        "publish/capability-expired",
     ]),
     details: Schema.optionalKey(Schema.Union([ScopeCheckDetails, AuthorizationDenyDetails, PublishDetails])),
 });
@@ -654,25 +725,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"),
@@ -724,15 +776,6 @@ export const TeamMembership = Schema.Struct({
     addedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
     addedBy: UserIdRef,
 }).annotate({ title: "Team Membership" });
-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.",
-});
 export const SearchHit = Schema.Struct({
     name: ExtensionName,
     owner: Handle,
@@ -744,6 +787,8 @@ export const SearchHit = Schema.Struct({
     authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
     deprecated_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
     deprecation_notice: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), 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." });
 export const CompanionPackage = Schema.Struct({
     purl: PackageIdentityPurl,
@@ -769,13 +814,13 @@ export const PublishLintFinding = Schema.Struct({
     title: "Publish Lint Finding",
     description: "One lint finding produced against the publish subject.",
 });
+export const PatchLibraryVisibilityBody = Schema.Struct({ visibility: LibraryVisibility }).annotate({ title: "Patch Library Visibility Body" });
 export const CreateLibraryBody = Schema.Struct({
     name: LibraryName,
     title: Schema.String,
     description: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
     visibility: Schema.optionalKey(Schema.Union([LibraryVisibility, Schema.Null])),
 }).annotate({ title: "Create Library Body" });
-export const PatchLibraryVisibilityBody = Schema.Struct({ visibility: LibraryVisibility }).annotate({ title: "Patch Library Visibility Body" });
 export const LibraryMember = Schema.Struct({
     id: LibraryMemberId,
     libraryId: LibraryId,
@@ -785,6 +830,17 @@ export const LibraryMember = Schema.Struct({
     extensionName: ExtensionName,
     addedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
 }).annotate({ title: "Library Member" });
+export const LibraryResolutionMember = Schema.Struct({
+    memberId: LibraryMemberId,
+    extensionId: ExtensionId,
+    extensionVersionId: ExtensionVersionId,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+    addedAt: IsoDateTimeString,
+    publishedAt: Schema.Union([IsoDateTimeString, Schema.Null]),
+}).annotate({ title: "Library Resolution Member" });
 export const AuthMeResponse = Schema.Struct({
     user: AuthMeUser,
     orgs: Schema.Array(Schema.Never).annotate({
@@ -795,6 +851,27 @@ export const AuthMeResponse = Schema.Struct({
     title: "Auth Me Response",
     description: "Your user profile, organizations, and token details.",
 });
+export const PatchLibraryMembersBody = Schema.Struct({
+    add: Schema.Array(LibraryMemberCoordinate),
+    remove: Schema.Array(LibraryMemberCoordinate),
+}).annotate({ title: "Patch Library Members Body" });
+export const PatchLibraryMembersResponse = Schema.Struct({
+    added: Schema.Array(LibraryMemberCoordinate),
+    removed: Schema.Array(LibraryMemberCoordinate),
+    unchanged: Schema.Array(Schema.Struct({ action: Schema.Literals(["add", "remove"]), member: LibraryMemberCoordinate })),
+}).annotate({ title: "Patch Library Members Response" });
+export const ExtensionIdentityMismatchError = Schema.Struct({
+    kind: Schema.Literal("ExtensionIdentityMismatchError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt()),
+    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),
+});
 export const TokenListResponse = Schema.Struct({
     tokens: Schema.Array(TokenListItem).annotate({
         description: "List of access tokens for the authenticated user.",
@@ -829,9 +906,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]),
@@ -840,18 +914,6 @@ export const TeamMembershipList = Schema.Struct({
     items: Schema.Array(TeamMembership),
     nextCursor: Schema.Union([Schema.String, Schema.Null]),
 }).annotate({ title: "Team Membership List" });
-export const ExtensionIdentityMismatchError = Schema.Struct({
-    kind: Schema.Literal("ExtensionIdentityMismatchError"),
-    type: Schema.String,
-    title: Schema.String,
-    status: Schema.Number.check(Schema.isInt()),
-    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),
-});
 export const SearchResponse = Schema.Struct({
     extensions: Schema.Array(SearchHit).annotate({
         description: "Extensions matching the query, ordered by recency.",
@@ -863,6 +925,10 @@ export const SearchResponse = Schema.Struct({
         Schema.String.annotate({ description: "Opaque cursor for fetching the next page of results." }),
         Schema.Null,
     ]),
+    total: Schema.Number.check(Schema.isInt()).check(Schema.makeFilterGroup([Schema.isFinite(), Schema.isGreaterThanOrEqualTo(0)], {
+        description: "Exact number of viewer-visible extensions matching the query.",
+    })),
+    total_relation: Schema.Literal("exact"),
 }).annotate({
     title: "Search Response",
     description: "A page of extensions matching the search query.",
@@ -880,12 +946,32 @@ export const ExtensionLintFailedError = Schema.Struct({
     displayRoot: Schema.String,
     findings: Schema.Array(PublishLintFinding),
 });
+export const ListLibraryMembersResponse = Schema.Struct({
+    members: Schema.Array(LibraryMember),
+    total: Schema.Number.check(Schema.isInt()),
+    limit: Schema.Number.check(Schema.isInt()),
+    offset: Schema.Number.check(Schema.isInt()),
+    viewerRelative: Schema.Literal(true),
+}).annotate({ title: "List Library Members Response" });
+export const LibraryResolution = Schema.Struct({
+    libraryId: LibraryId,
+    reference: Schema.String,
+    name: LibraryName,
+    updatedAt: IsoDateTimeString,
+    membershipDigest: Schema.String,
+    viewerRelative: Schema.Literal(true),
+    members: Schema.Array(LibraryResolutionMember),
+}).annotate({
+    title: "Library Resolution",
+    description: "The current Library membership and latest eligible versions visible to the authenticated viewer.",
+});
 export const LibraryDetail = Schema.Struct({
     library: Library,
     members: Schema.Array(LibraryMember),
-    hiddenMemberCount: Schema.Number.check(Schema.isInt())
+    accessibleMemberCount: Schema.Number.check(Schema.isInt())
         .check(Schema.isFinite())
         .check(Schema.isGreaterThanOrEqualTo(0)),
+    contentsMayVary: Schema.Literal(true),
 }).annotate({ title: "Library Detail" });
 export const MetaGet200 = MetaResponse;
 export const MetaGet400 = DecodeErrorResponse;
@@ -1001,6 +1087,27 @@ export const AuthGetStepUpChallenge401 = ProblemDetails;
 export const AuthGetStepUpChallenge404 = ProblemDetails;
 export const AuthExchangeOidcToken400 = DecodeErrorResponse;
 export const AuthExchangeOidcToken501 = ProblemDetails;
+export const AuthCreatePublishAuthorizationRequestRequestJson = Schema.Struct({
+    client_id: Schema.String.check(Schema.isMinLength(1)),
+    redirect_uri: Schema.String.check(Schema.isMinLength(1)),
+    state: Schema.String.check(Schema.isMinLength(1)),
+    code_challenge: Schema.String.check(Schema.isMinLength(1)),
+    code_challenge_method: Schema.Literal("S256"),
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: Version,
+    archive_sha256: Schema.String.check(Schema.isMinLength(1)),
+});
+export const AuthCreatePublishAuthorizationRequest201 = Schema.Struct({
+    request_id: PublishAuthorizationRequestId,
+    authorization_url: Schema.String,
+    expires_at: IsoDateTimeString,
+});
+export const AuthCreatePublishAuthorizationRequest400 = Schema.Union([
+    ProblemDetails,
+    DecodeErrorResponse,
+]);
 export const TokensListParams = Schema.Struct({
     cursor: Schema.optionalKey(Schema.Union([
         Schema.String.annotate({
@@ -1133,6 +1240,7 @@ 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])),
@@ -1145,9 +1253,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 +1265,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 +1323,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.String.annotate({ readOnly: true }),
     version: Version,
     status: Schema.Literals(["pending", "available", "failed"]).annotate({ readOnly: true }),
     published: IsoDateTimeString,
@@ -1186,14 +1340,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 ExtensionsPublishVersionRequestFormData = Schema.Struct({
-    archive: Schema.String.annotate({ description: "Extension archive multipart file part." }),
-    integrity: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-});
+export const ExtensionsGetVersion410 = ProblemDetails;
 export const ExtensionsPublishVersion201 = Schema.Struct({
     owner: Handle,
     type: ExtensionType,
@@ -1220,10 +1372,22 @@ 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 ExtensionsDownloadArchive500 = ProblemDetails;
@@ -1253,12 +1417,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,13 +1438,97 @@ 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 LibrariesListLibraries200 = Schema.Struct({ libraries: Schema.Array(Library) });
+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 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()),
+    limit: Schema.Number.check(Schema.isInt()),
+    offset: Schema.Number.check(Schema.isInt()),
+    viewerRelative: Schema.Literal(true),
+});
 export const LibrariesListLibraries400 = DecodeErrorResponse;
 export const LibrariesListLibraries404 = ProblemDetails;
 export const LibrariesCreateLibraryRequestJson = CreateLibraryBody;
@@ -1304,6 +1555,27 @@ export const LibrariesUpdateLibrary401 = ProblemDetails;
 export const LibrariesUpdateLibrary403 = Schema.Union([ForbiddenError, ForbiddenError]);
 export const LibrariesUpdateLibrary404 = ProblemDetails;
 export const LibrariesUpdateLibrary422 = ProblemDetails;
+export const LibrariesGetLibraryResolution200 = LibraryResolution;
+export const LibrariesGetLibraryResolution400 = DecodeErrorResponse;
+export const LibrariesGetLibraryResolution404 = ProblemDetails;
+export const LibrariesGetLibraryResolution422 = 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 = DecodeErrorResponse;
+export const LibrariesListLibraryMembers404 = ProblemDetails;
+export const LibrariesListLibraryMembers422 = ProblemDetails;
+export const LibrariesPatchLibraryMembersRequestJson = PatchLibraryMembersBody;
+export const LibrariesPatchLibraryMembers200 = PatchLibraryMembersResponse;
+export const LibrariesPatchLibraryMembers400 = DecodeErrorResponse;
+export const LibrariesPatchLibraryMembers401 = ProblemDetails;
+export const LibrariesPatchLibraryMembers403 = Schema.Union([ForbiddenError, ForbiddenError]);
+export const LibrariesPatchLibraryMembers404 = ProblemDetails;
+export const LibrariesPatchLibraryMembers422 = ProblemDetails;
 export const LibrariesSetLibraryVisibilityRequestJson = PatchLibraryVisibilityBody;
 export const LibrariesSetLibraryVisibility200 = Library;
 export const LibrariesSetLibraryVisibility400 = DecodeErrorResponse;
@@ -1336,95 +1608,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;
@@ -1568,9 +1751,19 @@ export const SearchSearchExtensionsParams = Schema.Struct({
         }),
         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 = DecodeErrorResponse;
+export const SearchSearchExtensions400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
 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({
@@ -1647,6 +1840,11 @@ export const make = (httpClient, options = {}) => {
             "204": () => Effect.void,
             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"],
@@ -1774,6 +1972,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,16 +1994,16 @@ 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({
+        ExtensionsPublishVersion: (owner, type, name, version, options) => HttpClientRequest.put(`/v1/extensions/${owner}/${type}/${name}/${version}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(ExtensionsPublishVersion201),
             "400": decodeError("ExtensionsPublishVersion400", ExtensionsPublishVersion400),
             "401": decodeError("ExtensionsPublishVersion401", ExtensionsPublishVersion401),
@@ -1811,12 +2018,12 @@ 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({
@@ -1827,6 +2034,13 @@ export const make = (httpClient, options = {}) => {
             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,
+        }))),
         ExtensionsDeprecate: (owner, type, name, options) => HttpClientRequest.post(`/v1/extensions/${owner}/${type}/${name}/deprecate`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(ExtensionsDeprecate200),
             "400": decodeError("ExtensionsDeprecate400", ExtensionsDeprecate400),
@@ -1843,7 +2057,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,7 +2073,37 @@ export const make = (httpClient, options = {}) => {
             "404": decodeError("ExtensionsUnyankVersion404", ExtensionsUnyankVersion404),
             orElse: unexpectedStatus,
         }))),
-        LibrariesListLibraries: (owner, options) => HttpClientRequest.get(`/v1/libraries/${owner}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+        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(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),
@@ -1900,6 +2144,35 @@ export const make = (httpClient, options = {}) => {
             "422": decodeError("LibrariesUpdateLibrary422", LibrariesUpdateLibrary422),
             orElse: unexpectedStatus,
         }))),
+        LibrariesGetLibraryResolution: (owner, name, options) => HttpClientRequest.get(`/v1/libraries/${owner}/${name}/resolution`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(LibrariesGetLibraryResolution200),
+            "400": decodeError("LibrariesGetLibraryResolution400", LibrariesGetLibraryResolution400),
+            "404": decodeError("LibrariesGetLibraryResolution404", LibrariesGetLibraryResolution404),
+            "422": decodeError("LibrariesGetLibraryResolution422", LibrariesGetLibraryResolution422),
+            "304": () => Effect.void,
+            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,
+        }))),
+        LibrariesPatchLibraryMembers: (owner, name, options) => HttpClientRequest.patch(`/v1/libraries/${owner}/${name}/members`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(LibrariesPatchLibraryMembers200),
+            "400": decodeError("LibrariesPatchLibraryMembers400", LibrariesPatchLibraryMembers400),
+            "401": decodeError("LibrariesPatchLibraryMembers401", LibrariesPatchLibraryMembers401),
+            "403": decodeError("LibrariesPatchLibraryMembers403", LibrariesPatchLibraryMembers403),
+            "404": decodeError("LibrariesPatchLibraryMembers404", LibrariesPatchLibraryMembers404),
+            "422": decodeError("LibrariesPatchLibraryMembers422", LibrariesPatchLibraryMembers422),
+            orElse: unexpectedStatus,
+        }))),
         LibrariesSetLibraryVisibility: (owner, name, options) => HttpClientRequest.patch(`/v1/libraries/${owner}/${name}/visibility`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(LibrariesSetLibraryVisibility200),
             "400": decodeError("LibrariesSetLibraryVisibility400", LibrariesSetLibraryVisibility400),
@@ -1946,90 +2219,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),
@@ -2088,6 +2277,13 @@ export const make = (httpClient, options = {}) => {
             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),