@agentxm/client-core 0.11.3 → 0.12.1

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

@@ -269,23 +269,36 @@ 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 ListId = Schema.String.check(Schema.isPattern(new RegExp("^list_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "List ID",
+    description: "Identifies a handle-scoped curated extension collection in the registry.",
+    examples: ["list_01h455vb4pexka56gq5w2r7cpc"],
+}));
+export const ListVisibility = Schema.Literals(["public", "internal", "private"]).annotate({
+    title: "List Visibility",
+});
+export const ListItemId = Schema.String.check(Schema.isPattern(new RegExp("^litem_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "List Item ID",
+    description: "Identifies an ordered extension membership inside a curated registry list.",
+    examples: ["litem_01h455vb4pexka56gq5w2r7cpc"],
 }));
 export const ExtensionType = Schema.Literals([
     "skill",
     "command",
     "mcp-server",
     "subagent",
-    "file",
+    "context",
     "rule",
     "pack",
 ]).annotate({
     title: "Extension Type",
-    description: "What kind of extension this is: skill, command, mcp-server, subagent, file, rule, or pack.",
+    description: "What kind of extension this is: skill, command, mcp-server, subagent, context, rule, 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.",
@@ -631,6 +644,66 @@ export const TeamMembership = Schema.Struct({
     addedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
     addedBy: UserIdRef,
 }).annotate({ title: "Team Membership" });
+export const List = Schema.Struct({
+    id: ListId,
+    owner: Handle,
+    name: Schema.String,
+    title: Schema.String,
+    description: Schema.Union([Schema.String, Schema.Null]),
+    visibility: ListVisibility,
+    listed: Schema.Boolean,
+    createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+    updatedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+}).annotate({ title: "List" });
+export const CreateListBody = Schema.Struct({
+    name: Schema.String,
+    title: Schema.String,
+    description: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+    visibility: Schema.optionalKey(Schema.Union([ListVisibility, Schema.Null])),
+    listed: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null])),
+}).annotate({ title: "Create List Body" });
+export const UpdateListBody = Schema.Struct({
+    name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    title: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    description: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+    visibility: Schema.optionalKey(Schema.Union([ListVisibility, Schema.Null])),
+    listed: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null])),
+}).annotate({ title: "Update List Body" });
+export const ListItem = Schema.Struct({
+    id: ListItemId,
+    extensionOwner: Handle,
+    extensionType: ExtensionType,
+    extensionName: ExtensionName,
+    position: Schema.Union([
+        Schema.Union([
+            Schema.Number.check(Schema.isFinite()),
+            Schema.Literal("NaN"),
+            Schema.Literal("Infinity"),
+            Schema.Literal("-Infinity"),
+        ]),
+        Schema.Literals(["Infinity", "-Infinity", "NaN"]),
+    ]),
+    note: Schema.Union([Schema.String, Schema.Null]),
+    createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+}).annotate({ title: "List Item" });
+export const AddListItemBody = Schema.Struct({
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    note: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+    position: Schema.optionalKey(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,
+    ])),
+}).annotate({ title: "Add List Item Body" });
 export const PublishIdentity = Schema.Struct({
     owner: Handle,
     type: ExtensionType,
@@ -706,6 +779,12 @@ export const TeamMembershipList = Schema.Struct({
     items: Schema.Array(TeamMembership),
     nextCursor: Schema.Union([Schema.String, Schema.Null]),
 }).annotate({ title: "Team Membership List" });
+export const ListCollection = Schema.Struct({ items: Schema.Array(List) }).annotate({
+    title: "List Collection",
+});
+export const ListDetail = Schema.Struct({ list: List, items: Schema.Array(ListItem) }).annotate({
+    title: "List Detail",
+});
 export const ExtensionIdentityMismatchError = Schema.Struct({
     kind: Schema.Literal("ExtensionIdentityMismatchError"),
     type: Schema.String,
@@ -749,12 +828,13 @@ export const ExtensionLintFailedError = Schema.Struct({
 export const MetaGet200 = MetaResponse;
 export const MetaGet400 = DecodeErrorResponse;
 export const AuthIssueDeviceCodeRequestFormUrlEncoded = Schema.Struct({
-    client_id: Schema.Literal("axm-cli").annotate({
-        description: "OAuth client identifier. Must be 'axm-cli'.",
-    }),
+    client_id: Schema.String.check(Schema.isMinLength(1, {
+        description: "OAuth public client identifier.",
+        examples: ["example-client"],
+    })),
     scope: Schema.optionalKey(Schema.Union([
         Schema.String.annotate({
-            description: "Ignored for axm-cli. Sessions always use full user authority.",
+            description: "Optional space-delimited registry scopes requested by the client.",
         }),
         Schema.Null,
     ])),
@@ -782,7 +862,10 @@ export const AuthExchangeTokenRequestFormUrlEncoded = Schema.Struct({
         Schema.Null,
     ])),
     client_id: Schema.optionalKey(Schema.Union([
-        Schema.String.annotate({ description: "OAuth client identifier.", examples: ["axm-cli"] }),
+        Schema.String.check(Schema.isMinLength(1, {
+            description: "OAuth client identifier.",
+            examples: ["example-client"],
+        })),
         Schema.Null,
     ])),
     redirect_uri: Schema.optionalKey(Schema.Union([
@@ -813,57 +896,6 @@ export const AuthExchangeToken400 = Schema.Union([
     Schema.Union([ProblemDetails, DecodeErrorResponse]),
     TokenOAuthError,
 ]);
-export const AuthExchangeDeviceCodeRequestFormUrlEncoded = Schema.Struct({
-    grant_type: Schema.String.annotate({
-        description: "OAuth grant type. Must be 'urn:ietf:params:oauth:grant-type:device_code'.",
-        examples: ["urn:ietf:params:oauth:grant-type:device_code"],
-    }),
-    device_code: Schema.String.annotate({
-        description: "The device verification code received from the /device/code endpoint.",
-    }),
-    client_id: Schema.String.annotate({
-        description: "OAuth client identifier, e.g. 'axm-cli'.",
-        examples: ["axm-cli"],
-    }),
-});
-export const AuthExchangeDeviceCode200 = Schema.Struct({
-    access_token: Schema.String,
-    refresh_token: Schema.String,
-    token_type: Schema.Literal("Bearer"),
-    expires_in: Schema.Number.check(Schema.isInt()),
-    expires_at: Schema.String,
-    scope: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-});
-export const AuthExchangeDeviceCode400 = Schema.Union([TokenOAuthError, DecodeErrorResponse]);
-export const AuthExchangeCliAuthorizationCodeRequestFormUrlEncoded = Schema.Struct({
-    grant_type: Schema.String.annotate({
-        description: "OAuth grant type. Must be 'authorization_code'.",
-        examples: ["authorization_code"],
-    }),
-    code: Schema.String.annotate({
-        description: "Authorization code returned to the loopback callback.",
-    }),
-    code_verifier: Schema.String.annotate({ description: "PKCE verifier generated by the CLI." }),
-    client_id: Schema.String.annotate({
-        description: "OAuth client identifier, e.g. 'axm-cli'.",
-        examples: ["axm-cli"],
-    }),
-    redirect_uri: Schema.String.annotate({
-        description: "Loopback redirect URI the authorization code was bound to.",
-    }),
-});
-export const AuthExchangeCliAuthorizationCode200 = Schema.Struct({
-    access_token: Schema.String,
-    refresh_token: Schema.String,
-    token_type: Schema.Literal("Bearer"),
-    expires_in: Schema.Number.check(Schema.isInt()),
-    expires_at: Schema.String,
-    scope: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-});
-export const AuthExchangeCliAuthorizationCode400 = Schema.Union([
-    TokenOAuthError,
-    DecodeErrorResponse,
-]);
 export const AuthRefreshTokenRequestFormUrlEncoded = Schema.Struct({
     grant_type: Schema.Literal("refresh_token").annotate({
         description: "OAuth grant type. Must be 'refresh_token'.",
@@ -990,6 +1022,46 @@ export const OrgsTeamsChangeTeamMemberRole400 = DecodeErrorResponse;
 export const OrgsTeamsChangeTeamMemberRole401 = ProblemDetails;
 export const OrgsTeamsChangeTeamMemberRole403 = ForbiddenError;
 export const OrgsTeamsChangeTeamMemberRole404 = ProblemDetails;
+export const ListsListLists200 = ListCollection;
+export const ListsListLists400 = DecodeErrorResponse;
+export const ListsListLists404 = ProblemDetails;
+export const ListsCreateListRequestJson = CreateListBody;
+export const ListsCreateList200 = List;
+export const ListsCreateList400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
+export const ListsCreateList401 = ProblemDetails;
+export const ListsCreateList403 = ForbiddenError;
+export const ListsCreateList404 = ProblemDetails;
+export const ListsCreateList409 = ProblemDetails;
+export const ListsCreateList422 = ProblemDetails;
+export const ListsGetList200 = ListDetail;
+export const ListsGetList400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
+export const ListsGetList404 = ProblemDetails;
+export const ListsDeleteList400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
+export const ListsDeleteList401 = ProblemDetails;
+export const ListsDeleteList403 = ForbiddenError;
+export const ListsDeleteList404 = ProblemDetails;
+export const ListsUpdateListRequestJson = UpdateListBody;
+export const ListsUpdateList200 = List;
+export const ListsUpdateList400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
+export const ListsUpdateList401 = ProblemDetails;
+export const ListsUpdateList403 = ForbiddenError;
+export const ListsUpdateList404 = ProblemDetails;
+export const ListsUpdateList409 = ProblemDetails;
+export const ListsUpdateList422 = ProblemDetails;
+export const ListsAddListItemRequestJson = AddListItemBody;
+export const ListsAddListItem200 = ListItem;
+export const ListsAddListItem400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
+export const ListsAddListItem401 = ProblemDetails;
+export const ListsAddListItem403 = ForbiddenError;
+export const ListsAddListItem404 = ProblemDetails;
+export const ListsAddListItem409 = ProblemDetails;
+export const ListsRemoveListItemParams = Schema.Struct({
+    extensionOwner: Schema.optionalKey(Schema.Union([Handle, Schema.Null])),
+});
+export const ListsRemoveListItem400 = Schema.Union([ProblemDetails, DecodeErrorResponse]);
+export const ListsRemoveListItem401 = ProblemDetails;
+export const ListsRemoveListItem403 = ForbiddenError;
+export const ListsRemoveListItem404 = ProblemDetails;
 export const ExtensionsListByOwner200 = Schema.Struct({
     extensions: Schema.Array(Schema.Struct({
         name: ExtensionName,
@@ -1088,17 +1160,6 @@ 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 ExtensionsPublishVersion200 = Schema.Struct({
-    owner: Handle,
-    type: ExtensionType,
-    name: ExtensionName,
-    version: Version,
-    integrity: Schema.String.annotate({ readOnly: true }),
-    sha256_hex: Schema.String.annotate({ readOnly: true }),
-    published_at: IsoDateTimeString,
-    publish_status: Schema.Literals(["pending", "available", "failed"]).annotate({ readOnly: true }),
-    links: ExtensionLinks,
-});
 export const ExtensionsPublishVersion201 = Schema.Struct({
     owner: Handle,
     type: ExtensionType,
@@ -1393,16 +1454,6 @@ export const make = (httpClient, options = {}) => {
             "400": decodeError("AuthExchangeToken400", AuthExchangeToken400),
             orElse: unexpectedStatus,
         }))),
-        AuthExchangeDeviceCode: (options) => HttpClientRequest.post(`/v1/auth/device/token`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(AuthExchangeDeviceCode200),
-            "400": decodeError("AuthExchangeDeviceCode400", AuthExchangeDeviceCode400),
-            orElse: unexpectedStatus,
-        }))),
-        AuthExchangeCliAuthorizationCode: (options) => HttpClientRequest.post(`/v1/auth/cli/token`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(AuthExchangeCliAuthorizationCode200),
-            "400": decodeError("AuthExchangeCliAuthorizationCode400", AuthExchangeCliAuthorizationCode400),
-            orElse: unexpectedStatus,
-        }))),
         AuthRefreshToken: (options) => HttpClientRequest.post(`/v1/auth/token/refresh`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(AuthRefreshToken200),
             "400": decodeError("AuthRefreshToken400", AuthRefreshToken400),
@@ -1545,6 +1596,65 @@ export const make = (httpClient, options = {}) => {
             "404": decodeError("OrgsTeamsChangeTeamMemberRole404", OrgsTeamsChangeTeamMemberRole404),
             orElse: unexpectedStatus,
         }))),
+        ListsListLists: (owner, options) => HttpClientRequest.get(`/v1/lists/${owner}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ListsListLists200),
+            "400": decodeError("ListsListLists400", ListsListLists400),
+            "404": decodeError("ListsListLists404", ListsListLists404),
+            orElse: unexpectedStatus,
+        }))),
+        ListsCreateList: (owner, options) => HttpClientRequest.post(`/v1/lists/${owner}`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ListsCreateList200),
+            "400": decodeError("ListsCreateList400", ListsCreateList400),
+            "401": decodeError("ListsCreateList401", ListsCreateList401),
+            "403": decodeError("ListsCreateList403", ListsCreateList403),
+            "404": decodeError("ListsCreateList404", ListsCreateList404),
+            "409": decodeError("ListsCreateList409", ListsCreateList409),
+            "422": decodeError("ListsCreateList422", ListsCreateList422),
+            orElse: unexpectedStatus,
+        }))),
+        ListsGetList: (owner, name, options) => HttpClientRequest.get(`/v1/lists/${owner}/${name}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ListsGetList200),
+            "400": decodeError("ListsGetList400", ListsGetList400),
+            "404": decodeError("ListsGetList404", ListsGetList404),
+            orElse: unexpectedStatus,
+        }))),
+        ListsDeleteList: (owner, name, options) => HttpClientRequest.delete(`/v1/lists/${owner}/${name}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("ListsDeleteList400", ListsDeleteList400),
+            "401": decodeError("ListsDeleteList401", ListsDeleteList401),
+            "403": decodeError("ListsDeleteList403", ListsDeleteList403),
+            "404": decodeError("ListsDeleteList404", ListsDeleteList404),
+            "204": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        ListsUpdateList: (owner, name, options) => HttpClientRequest.patch(`/v1/lists/${owner}/${name}`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ListsUpdateList200),
+            "400": decodeError("ListsUpdateList400", ListsUpdateList400),
+            "401": decodeError("ListsUpdateList401", ListsUpdateList401),
+            "403": decodeError("ListsUpdateList403", ListsUpdateList403),
+            "404": decodeError("ListsUpdateList404", ListsUpdateList404),
+            "409": decodeError("ListsUpdateList409", ListsUpdateList409),
+            "422": decodeError("ListsUpdateList422", ListsUpdateList422),
+            orElse: unexpectedStatus,
+        }))),
+        ListsAddListItem: (owner, name, options) => HttpClientRequest.post(`/v1/lists/${owner}/${name}/items`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ListsAddListItem200),
+            "400": decodeError("ListsAddListItem400", ListsAddListItem400),
+            "401": decodeError("ListsAddListItem401", ListsAddListItem401),
+            "403": decodeError("ListsAddListItem403", ListsAddListItem403),
+            "404": decodeError("ListsAddListItem404", ListsAddListItem404),
+            "409": decodeError("ListsAddListItem409", ListsAddListItem409),
+            orElse: unexpectedStatus,
+        }))),
+        ListsRemoveListItem: (owner, name, type, extensionName, options) => HttpClientRequest.delete(`/v1/lists/${owner}/${name}/items/${type}/${extensionName}`).pipe(HttpClientRequest.setUrlParams({
+            extensionOwner: options?.params?.["extensionOwner"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("ListsRemoveListItem400", ListsRemoveListItem400),
+            "401": decodeError("ListsRemoveListItem401", ListsRemoveListItem401),
+            "403": decodeError("ListsRemoveListItem403", ListsRemoveListItem403),
+            "404": decodeError("ListsRemoveListItem404", ListsRemoveListItem404),
+            "204": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
         ExtensionsListByOwner: (owner, options) => HttpClientRequest.get(`/v1/extensions/${owner}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(ExtensionsListByOwner200),
             "400": decodeError("ExtensionsListByOwner400", ExtensionsListByOwner400),
@@ -1585,8 +1695,7 @@ export const make = (httpClient, options = {}) => {
             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({
-            "200": decodeSuccess(ExtensionsPublishVersion200),
-            "201": decodeSuccess(ExtensionsPublishVersion201),
+            "2xx": decodeSuccess(ExtensionsPublishVersion201),
             "400": decodeError("ExtensionsPublishVersion400", ExtensionsPublishVersion400),
             "401": decodeError("ExtensionsPublishVersion401", ExtensionsPublishVersion401),
             "403": decodeError("ExtensionsPublishVersion403", ExtensionsPublishVersion403),