@agentxm/client-core 0.1.6 → 0.2.0

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

@@ -8,46 +8,94 @@ import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as HttpClientError from "effect/unstable/http/HttpClientError";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+export const MetaResponse = Schema.Struct({
+    ok: Schema.Literal(true),
+    service: Schema.Literal("registry"),
+    message: Schema.String.annotate({ description: "Human-readable service greeting." }),
+    docs: Schema.Union([
+        Schema.String.annotate({
+            description: "Path to the interactive API documentation, or null when docs are disabled.",
+            format: "uri-reference",
+        }),
+        Schema.Null,
+    ]),
+    openapi: Schema.Union([
+        Schema.String.annotate({
+            description: "Path to the OpenAPI specification, or null when docs are disabled.",
+            format: "uri-reference",
+        }),
+        Schema.Null,
+    ]),
+}).annotate({
+    title: "Meta Response",
+    description: "Registry service metadata including health status and documentation entry points.",
+});
 export const DecodeErrorResponse = Schema.Struct({
     kind: Schema.Literal("DecodeErrorResponse"),
     type: Schema.String,
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-});
-export const InternalError = Schema.Struct({
-    kind: Schema.Literal("InternalError"),
-    type: Schema.String,
-    title: Schema.String,
-    status: Schema.Number.check(Schema.isInt()),
-    detail: Schema.String,
     code: Schema.String,
-    instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
 });
-export const InvalidRequestError = Schema.Struct({
-    kind: Schema.Literal("InvalidRequestError"),
-    type: Schema.String,
-    title: Schema.String,
-    status: Schema.Number.check(Schema.isInt()),
-    detail: Schema.String,
-    code: Schema.String,
-    instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+export const DeviceCodeResponse = Schema.Struct({
+    device_code: Schema.String.annotate({
+        description: "Device verification code for the polling client.",
+    }),
+    user_code: Schema.String.annotate({ description: "Short code the user enters in the browser." }),
+    verification_uri: Schema.String.annotate({
+        description: "URI where the user should navigate to enter the user code.",
+        format: "uri",
+    }),
+    verification_uri_complete: Schema.String.annotate({
+        description: "URI with the user code pre-filled, suitable for QR codes or direct links.",
+        format: "uri",
+    }),
+    expires_in: Schema.Number.annotate({
+        description: "Lifetime of the device code in seconds.",
+    }).check(Schema.isInt()),
+    interval: Schema.Number.annotate({ description: "Minimum polling interval in seconds." }).check(Schema.isInt()),
+}).annotate({
+    title: "Device Code Response",
+    description: "Response from the OAuth device authorization endpoint (RFC 8628).",
+});
+export const PublishDetails = Schema.Struct({
+    retryable: Schema.Boolean.annotate({ description: "Whether the client may retry the request." }),
+    retryAfterSeconds: Schema.optionalKey(Schema.Number.annotate({ description: "Suggested delay in seconds before retrying." }).check(Schema.isFinite())),
+    requiredScope: Schema.optionalKey(Schema.String.annotate({
+        description: "The scope required to perform the operation, if applicable.",
+    })),
+    tokenScopes: Schema.optionalKey(Schema.Array(Schema.String).annotate({
+        description: "The scopes present on the token used for the request.",
     })),
+    requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({
+        description: "The collaborator role required, if applicable.",
+    })),
+}).annotate({
+    title: "Publish Details",
+    description: "Extended error details for publish-related and retryable error responses.",
+});
+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.",
+    }),
+    token_type: Schema.Literal("Bearer"),
+    expires_in: Schema.Number.annotate({
+        description: "Access token lifetime remaining in seconds.",
+    }).check(Schema.isInt()),
+    expires_at: Schema.String.annotate({
+        description: "ISO 8601 timestamp when the access token expires.",
+        format: "date-time",
+    }),
+    scope: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Space-delimited list of granted scopes." }),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Session Token Response",
+    description: "OAuth 2.0 token response containing an access/refresh token pair.",
 });
 export const DeviceTokenOAuthError = Schema.Struct({
     kind: Schema.Literal("DeviceTokenOAuthError"),
@@ -57,8 +105,34 @@ export const DeviceTokenOAuthError = Schema.Struct({
         "slow_down",
         "expired_token",
         "access_denied",
-    ]),
-    error_description: Schema.String,
+    ]).annotate({
+        title: "OAuth Device Error Code",
+        description: "RFC 8628 error code indicating the polling state.",
+    }),
+    error_description: Schema.String.annotate({
+        description: "Human-readable explanation of the error.",
+    }),
+});
+export const RefreshSessionTokenResponse = 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.",
+    }),
+    token_type: Schema.Literal("Bearer"),
+    expires_in: Schema.Number.annotate({
+        description: "Access token lifetime remaining in seconds.",
+    }).check(Schema.isInt()),
+    expires_at: Schema.String.annotate({
+        description: "ISO 8601 timestamp when the access token expires.",
+        format: "date-time",
+    }),
+    scope: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Space-delimited list of granted scopes." }),
+        Schema.Null,
+    ])),
+}).annotate({
+    title: "Session Token Response",
+    description: "OAuth 2.0 token response containing an access/refresh token pair.",
 });
 export const RefreshTokenError = Schema.Struct({
     kind: Schema.Literal("RefreshTokenError"),
@@ -66,68 +140,199 @@ export const RefreshTokenError = Schema.Struct({
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
+    code: Schema.String,
     details: Schema.optionalKey(Schema.Unknown),
 });
 export const UserId = Schema.String.check(Schema.isPattern(new RegExp("^user_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
     title: "User ID",
-    description: "Identifies a registered user account. Assigned at sign-up and referenced by tokens, memberships, and audit trails.",
+    description: "Unique user identifier.",
     examples: ["user_01h455vb4pexka56gq5w2r7cpc"],
 }));
 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.",
+    description: "Unique identifier of the token used for this request.",
     examples: ["tok_01h455vb4pexka56gq5w2r7cpc"],
 }));
+export const ResourceRestrictions = Schema.Struct({
+    extensions: Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({
+        description: "Extension patterns this token is limited to, or null if unrestricted.",
+    }),
+}).annotate({
+    title: "Resource Restrictions",
+    description: "What this token is allowed to access.",
+});
 export const UnauthorizedError = Schema.Struct({
     kind: Schema.Literal("UnauthorizedError"),
     type: Schema.String,
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
+    code: Schema.String,
 });
-export const NotImplementedError = Schema.Struct({
-    kind: Schema.Literal("NotImplementedError"),
+export const TokenId1 = Schema.String.check(Schema.isPattern(new RegExp("^tok_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "Token ID",
+    description: "Unique token identifier.",
+    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.",
+    }),
+    grantedScopes: Schema.Array(Schema.String).annotate({
+        description: "The scopes granted to the current credential.",
+    }),
+}).annotate({
+    title: "Scope Check Details",
+    description: "Diagnostic details returned when a request is denied due to insufficient scopes.",
+});
+export const AuthorizationDenyDetails = Schema.Struct({
+    requiredScope: Schema.String.annotate({
+        description: "The scope required to perform the requested operation.",
+    }),
+    tokenScopes: Schema.Array(Schema.String).annotate({
+        description: "The scopes present on the token used for the request.",
+    }),
+    requiredRole: Schema.optionalKey(Schema.String.annotate({ description: "The collaborator role required, if applicable." })),
+}).annotate({
+    title: "Authorization Deny Details",
+    description: "Diagnostic details returned when a request is denied due to insufficient authorization.",
+});
+export const CreateTokenRequest = Schema.Struct({
+    name: Schema.String.check(Schema.isMinLength(1, {
+        description: "Human-readable name for the token.",
+        examples: ["CI publish token"],
+    })),
+    scopes: Schema.Array(Schema.String).check(Schema.isMinLength(1, {
+        description: "Permissions to grant this token (e.g. extensions:read, extensions:write).",
+        examples: [["extensions:read", "extensions:write"]],
+    })),
+    expires_in: Schema.Number.check(Schema.isInt())
+        .check(Schema.isFinite())
+        .check(Schema.isGreaterThanOrEqualTo(3600))
+        .check(Schema.isLessThanOrEqualTo(31536000, {
+        description: "How long the token lasts, in seconds (1 hour to 365 days).",
+    })),
+}).annotate({
+    title: "Create Token Request",
+    description: "Request body for creating a new personal access token.",
+});
+export const TokenId2 = 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 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." });
+export const ExtensionName = Schema.String;
+export const ExtensionType = Schema.Literals([
+    "skill",
+    "command",
+    "mcp-server",
+    "subagent",
+    "file",
+    "rule",
+    "pack",
+]).annotate({
+    title: "Extension Type",
+    description: "What kind of extension this is: skill, command, mcp-server, subagent, file, rule, or pack.",
+});
+export const ExactSemverVersion = Schema.String;
+export const Author = Schema.Struct({
+    name: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "Display name of the extension author." }),
+        Schema.Null,
+    ])),
+    email: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Contact email of the extension author.",
+            format: "email",
+        }),
+        Schema.Null,
+    ])),
+    url: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "URL for the extension author (homepage or profile).",
+            format: "uri",
+        }),
+        Schema.Null,
+    ])),
+}).annotate({ title: "Author", description: "Author details: name, email, and homepage URL." });
+export const VersionConstraint = Schema.String;
+export const PatchVisibilityBody = Schema.Struct({
+    visibility: Schema.Literals(["public", "unlisted", "private"]).annotate({
+        title: "Visibility",
+        description: "Target visibility level for the extension.",
+    }),
+}).annotate({
+    title: "Patch Visibility Body",
+    description: "Request body for updating an extension's visibility.",
+});
+export const ExtensionId = Schema.String.check(Schema.isPattern(new RegExp("^ext_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "Extension ID",
+    description: "Identifies a registered extension in the registry. An extension groups all published versions under a single handle, type, and name.",
+    examples: ["ext_01h455vb4pexka56gq5w2r7cpc"],
+}));
+export const DeprecateBody = Schema.Struct({
+    notice: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Message shown to users explaining why this extension is deprecated.",
+            examples: ["Use @example/skills/new-skill instead."],
+        }),
+        Schema.Null,
+    ])),
+}).annotate({ title: "Deprecate Body", description: "Request body for deprecating an extension." });
+export const UserId1 = Schema.String.check(Schema.isPattern(new RegExp("^user_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
+    title: "User ID",
+    description: "Identifies a registered user account. Assigned at sign-up and referenced by tokens, memberships, and audit trails.",
+    examples: ["user_01h455vb4pexka56gq5w2r7cpc"],
+}));
+export const PutCollaboratorBody = Schema.Struct({
+    role: Schema.Literals(["admin", "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 InternalError = Schema.Struct({
+    kind: Schema.Literal("InternalError"),
     type: Schema.String,
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
-export const ForbiddenError = Schema.Struct({
-    kind: Schema.Literal("ForbiddenError"),
+export const InvalidRequestError = Schema.Struct({
+    kind: Schema.Literal("InvalidRequestError"),
     type: Schema.String,
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
     code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
+});
+export const NotImplementedError = Schema.Struct({
+    kind: Schema.Literal("NotImplementedError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt()),
+    detail: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Union([
-        Schema.Struct({ requiredScope: Schema.String, grantedScopes: Schema.Array(Schema.String) }),
-        Schema.Struct({
-            requiredScope: Schema.String,
-            tokenScopes: Schema.Array(Schema.String),
-            requiredRole: Schema.optionalKey(Schema.String),
-        }),
-        Schema.Struct({
-            retryable: Schema.Boolean,
-            retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-            requiredScope: Schema.optionalKey(Schema.String),
-            tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-            requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-        }),
-    ])),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
 export const UnprocessableEntityError = Schema.Struct({
     kind: Schema.Literal("UnprocessableEntityError"),
@@ -135,15 +340,9 @@ export const UnprocessableEntityError = Schema.Struct({
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
 export const NotFoundError = Schema.Struct({
     kind: Schema.Literal("NotFoundError"),
@@ -151,36 +350,19 @@ export const NotFoundError = Schema.Struct({
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
-export const ExtensionId = Schema.String.check(Schema.isPattern(new RegExp("^ext_[0-7][0-9a-hjkmnp-tv-z]{25}$"), {
-    title: "Extension ID",
-    description: "Identifies a registered extension in the registry. An extension groups all published versions under a single handle, type, and name.",
-    examples: ["ext_01h455vb4pexka56gq5w2r7cpc"],
-}));
 export const ConflictError = Schema.Struct({
     kind: Schema.Literal("ConflictError"),
     type: Schema.String,
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
 export const PayloadTooLargeError = Schema.Struct({
     kind: Schema.Literal("PayloadTooLargeError"),
@@ -188,15 +370,9 @@ export const PayloadTooLargeError = Schema.Struct({
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
 export const UnsupportedMediaTypeError = Schema.Struct({
     kind: Schema.Literal("UnsupportedMediaTypeError"),
@@ -204,15 +380,9 @@ export const UnsupportedMediaTypeError = Schema.Struct({
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
 export const TooManyRequestsError = Schema.Struct({
     kind: Schema.Literal("TooManyRequestsError"),
@@ -220,15 +390,9 @@ export const TooManyRequestsError = Schema.Struct({
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
-    code: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
 });
 export const ServiceUnavailableError = Schema.Struct({
     kind: Schema.Literal("ServiceUnavailableError"),
@@ -236,185 +400,202 @@ export const ServiceUnavailableError = Schema.Struct({
     title: Schema.String,
     status: Schema.Number.check(Schema.isInt()),
     detail: Schema.String,
+    instance: Schema.optionalKey(Schema.String),
     code: Schema.String,
+    details: Schema.optionalKey(PublishDetails),
+});
+export const AuthMeUser = Schema.Struct({
+    id: UserId,
+    handle: Schema.String.annotate({
+        description: "The user's registry handle.",
+        examples: ["@example"],
+    }),
+    email: Schema.Union([
+        Schema.String.annotate({
+            description: "The user's email address, if available.",
+            format: "email",
+        }),
+        Schema.Null,
+    ]),
+}).annotate({ title: "Authenticated User", description: "Your profile information." });
+export const AuthMeToken = Schema.Struct({
+    id: TokenId,
+    type: Schema.Literals(["session", "pat", "oidc"]).annotate({
+        title: "Token Type",
+        description: "The type of authentication token.",
+    }),
+    name: Schema.Union([
+        Schema.String.annotate({ description: "Human-readable name of the token, if assigned." }),
+        Schema.Null,
+    ]),
+    scopes: Schema.Array(Schema.String).annotate({ description: "Scopes granted to this token." }),
+    resource_restrictions: ResourceRestrictions,
+    expires_at: Schema.String.annotate({
+        description: "When this token expires.",
+        format: "date-time",
+    }),
+}).annotate({
+    title: "Token Info",
+    description: "Details about the token you used to authenticate.",
+});
+export const TokenListItem = Schema.Struct({
+    id: TokenId1,
+    name: Schema.Union([
+        Schema.String.annotate({ description: "Human-readable name of the token, if assigned." }),
+        Schema.Null,
+    ]),
+    type: Schema.String.annotate({ description: "Token type (e.g. 'pat', 'session')." }),
+    scopes: Schema.Array(Schema.String).annotate({ description: "Scopes granted to this token." }),
+    created_at: IsoDateTimeString,
+    expires_at: IsoDateTimeString,
+    last_used_at: Schema.Union([IsoDateTimeString, Schema.Null]),
+}).annotate({ title: "Token List Item", description: "Summary of an access token." });
+export const ForbiddenError = Schema.Struct({
+    kind: Schema.Literal("ForbiddenError"),
+    type: Schema.String,
+    title: Schema.String,
+    status: Schema.Number.check(Schema.isInt()),
+    detail: Schema.String,
     instance: Schema.optionalKey(Schema.String),
-    details: Schema.optionalKey(Schema.Struct({
-        retryable: Schema.Boolean,
-        retryAfterSeconds: Schema.optionalKey(Schema.Number.check(Schema.isFinite())),
-        requiredScope: Schema.optionalKey(Schema.String),
-        tokenScopes: Schema.optionalKey(Schema.Array(Schema.String)),
-        requiredRole: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    })),
+    code: Schema.String,
+    details: Schema.optionalKey(Schema.Union([ScopeCheckDetails, AuthorizationDenyDetails, PublishDetails])),
 });
-export const MetaGet200 = Schema.Struct({
-    ok: Schema.Literal(true),
-    service: Schema.Literal("registry"),
-    message: Schema.String,
-    docs: Schema.Union([Schema.String, Schema.Null]),
-    openapi: Schema.Union([Schema.String, Schema.Null]),
+export const CreateTokenResponse = Schema.Struct({
+    id: TokenId2,
+    token: Schema.String.annotate({
+        description: "The token value — save this, it won't be shown again.",
+        readOnly: true,
+    }),
+    name: Schema.String,
+    scopes: Schema.Array(Schema.String),
+    created_at: IsoDateTimeString,
+    expires_at: IsoDateTimeString,
+}).annotate({
+    title: "Create Token Response",
+    description: "Your new access token. The token value is only shown once — save it now.",
 });
-export const MetaGet400 = DecodeErrorResponse;
-export const AuthIssueDeviceCodeRequestFormUrlEncoded = Schema.Struct({
-    client_id: Schema.Literal("axm-cli"),
-    scope: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+export const SearchHit = Schema.Struct({
+    name: ExtensionName,
+    owner: Handle,
+    type: ExtensionType,
+    latestVersion: ExactSemverVersion,
+    description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    repository: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    license: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    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])),
+}).annotate({ title: "Search Hit", description: "A single extension matched by a search query." });
+export const AuthMeResponse = Schema.Struct({
+    user: AuthMeUser,
+    orgs: Schema.Array(Schema.Never).annotate({
+        description: "Organizations the user belongs to (reserved, currently empty).",
+    }),
+    token: AuthMeToken,
+}).annotate({
+    title: "Auth Me Response",
+    description: "Your user profile, organizations, and token details.",
 });
-export const AuthIssueDeviceCode200 = Schema.Struct({
-    device_code: Schema.String.annotate({
-        description: "Device verification code for the polling client.",
+export const TokenListResponse = Schema.Struct({
+    tokens: Schema.Array(TokenListItem).annotate({
+        description: "List of access tokens for the authenticated user.",
     }),
-    user_code: Schema.String.annotate({ description: "Short code the user enters in the browser." }),
-    verification_uri: Schema.String.annotate({
-        description: "URI where the user should navigate to enter the user code.",
-        format: "uri",
+    has_more: Schema.Boolean.annotate({
+        description: "Whether additional tokens exist beyond this page.",
     }),
-    verification_uri_complete: Schema.String.annotate({
-        description: "URI with the user code pre-filled, suitable for QR codes or direct links.",
-        format: "uri",
+    cursor: Schema.Union([
+        Schema.String.annotate({ description: "Opaque cursor for fetching the next page of results." }),
+        Schema.Null,
+    ]),
+}).annotate({ title: "Token List Response", description: "A page of your access tokens." });
+export const SearchResponse = Schema.Struct({
+    extensions: Schema.Array(SearchHit).annotate({
+        description: "Extensions matching the query, ordered by recency.",
     }),
-    expires_in: Schema.Number.annotate({
-        description: "Lifetime of the device code in seconds.",
-    }).check(Schema.isInt()),
-    interval: Schema.Number.annotate({ description: "Minimum polling interval in seconds." }).check(Schema.isInt()),
+    has_more: Schema.Boolean.annotate({
+        description: "Whether additional results exist beyond this page.",
+    }),
+    cursor: Schema.Union([
+        Schema.String.annotate({ description: "Opaque cursor for fetching the next page of results." }),
+        Schema.Null,
+    ]),
 }).annotate({
-    title: "Device Code Response",
-    description: "Response from the OAuth device authorization endpoint (RFC 8628).",
+    title: "Search Response",
+    description: "A page of extensions matching the search query.",
 });
+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'.",
+    }),
+    scope: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+export const AuthIssueDeviceCode200 = DeviceCodeResponse;
 export const AuthIssueDeviceCode400 = DecodeErrorResponse;
 export const AuthIssueDeviceCode500 = InternalError;
 export const AuthExchangeDeviceCodeRequestFormUrlEncoded = Schema.Struct({
-    grant_type: Schema.String,
-    device_code: Schema.String,
-    client_id: Schema.String,
-});
-export const AuthExchangeDeviceCode200 = 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.",
+    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"],
     }),
-    token_type: Schema.Literal("Bearer"),
-    expires_in: Schema.Number.annotate({
-        description: "Access token lifetime remaining in seconds.",
-    }).check(Schema.isInt()),
-    expires_at: Schema.String.annotate({
-        description: "ISO 8601 timestamp when the access token expires.",
-        format: "date-time",
+    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"],
     }),
-    scope: Schema.optionalKey(Schema.Union([
-        Schema.String.annotate({ description: "Space-delimited list of granted scopes." }),
-        Schema.Null,
-    ])),
-}).annotate({
-    title: "Session Token Response",
-    description: "OAuth 2.0 token response containing an access/refresh token pair.",
 });
+export const AuthExchangeDeviceCode200 = SessionTokenResponse;
 export const AuthExchangeDeviceCode400 = Schema.Union([
     Schema.Union([InvalidRequestError, DecodeErrorResponse]),
     DeviceTokenOAuthError,
 ]);
 export const AuthRefreshTokenRequestFormUrlEncoded = Schema.Struct({
-    grant_type: Schema.Literal("refresh_token"),
-    refresh_token: Schema.String.check(Schema.isMinLength(1)),
-    client_id: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-});
-export const AuthRefreshToken200 = 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.",
+    grant_type: Schema.Literal("refresh_token").annotate({
+        description: "OAuth grant type. Must be 'refresh_token'.",
     }),
-    token_type: Schema.Literal("Bearer"),
-    expires_in: Schema.Number.annotate({
-        description: "Access token lifetime remaining in seconds.",
-    }).check(Schema.isInt()),
-    expires_at: Schema.String.annotate({
-        description: "ISO 8601 timestamp when the access token expires.",
-        format: "date-time",
-    }),
-    scope: Schema.optionalKey(Schema.Union([
-        Schema.String.annotate({ description: "Space-delimited list of granted scopes." }),
+    refresh_token: Schema.String.check(Schema.isMinLength(1, { description: "The refresh token to exchange for a new token pair." })),
+    client_id: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({ description: "OAuth client identifier." }),
         Schema.Null,
     ])),
-}).annotate({
-    title: "Session Token Response",
-    description: "OAuth 2.0 token response containing an access/refresh token pair.",
 });
+export const AuthRefreshToken200 = RefreshSessionTokenResponse;
 export const AuthRefreshToken400 = DecodeErrorResponse;
 export const AuthRefreshToken401 = RefreshTokenError;
 export const AuthRevokeTokenRequestFormUrlEncoded = Schema.Struct({
-    token: Schema.String.check(Schema.isMinLength(1)),
+    token: Schema.String.check(Schema.isMinLength(1, {
+        description: "The access token or refresh token to revoke. Revocation is idempotent.",
+    })),
 });
 export const AuthRevokeToken400 = DecodeErrorResponse;
-export const AuthGetMe200 = Schema.Struct({
-    user: Schema.Struct({
-        id: UserId,
-        handle: Schema.String,
-        email: Schema.Union([Schema.String, Schema.Null]),
-    }),
-    orgs: Schema.Array(Schema.Never),
-    token: Schema.Struct({
-        id: TokenId,
-        type: Schema.Literals(["session", "pat", "oidc"]),
-        name: Schema.Union([Schema.String, Schema.Null]),
-        scopes: Schema.Array(Schema.String),
-        resource_restrictions: Schema.Struct({
-            extensions: Schema.Union([Schema.Array(Schema.String), Schema.Null]),
-        }),
-        expires_at: Schema.String.annotate({ format: "date-time" }),
-    }),
-});
+export const AuthGetMe200 = AuthMeResponse;
 export const AuthGetMe400 = DecodeErrorResponse;
 export const AuthGetMe401 = UnauthorizedError;
 export const AuthExchangeOidcToken400 = DecodeErrorResponse;
 export const AuthExchangeOidcToken501 = NotImplementedError;
 export const TokensListParams = Schema.Struct({
-    cursor: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-});
-export const TokensList200 = Schema.Struct({
-    tokens: Schema.Array(Schema.Struct({
-        id: TokenId,
-        name: Schema.Union([Schema.String, Schema.Null]),
-        type: Schema.String,
-        scopes: Schema.Array(Schema.String),
-        created_at: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-        expires_at: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-        last_used_at: Schema.Union([
-            Schema.String.annotate({ readOnly: true, format: "date-time" }),
-            Schema.Null,
-        ]),
-    })),
-    has_more: Schema.Boolean,
-    cursor: Schema.Union([Schema.String, Schema.Null]),
+    cursor: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Opaque cursor from a previous response for pagination.",
+        }),
+        Schema.Null,
+    ])),
+    limit: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Maximum number of tokens to return (1–100, default 50).",
+        }),
+        Schema.Null,
+    ])),
 });
+export const TokensList200 = TokenListResponse;
 export const TokensList400 = DecodeErrorResponse;
 export const TokensList401 = UnauthorizedError;
 export const TokensList403 = ForbiddenError;
-export const TokensCreateRequestJson = Schema.Struct({
-    name: Schema.String.check(Schema.isMinLength(1, { description: "Human-readable name for the token." })),
-    scopes: Schema.Array(Schema.String).check(Schema.isMinLength(1)),
-    expires_in: Schema.Number.check(Schema.isInt())
-        .check(Schema.isFinite())
-        .check(Schema.isGreaterThanOrEqualTo(3600))
-        .check(Schema.isLessThanOrEqualTo(31536000, {
-        description: "Token lifetime in seconds (3600–31536000).",
-    })),
-}).annotate({
-    title: "Create Token Request",
-    description: "Request body for creating a new personal access token.",
-});
-export const TokensCreate201 = Schema.Struct({
-    id: TokenId,
-    token: Schema.String.annotate({
-        description: "The full token value. Only returned once at creation time.",
-        readOnly: true,
-    }),
-    name: Schema.String,
-    scopes: Schema.Array(Schema.String),
-    created_at: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-    expires_at: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-}).annotate({
-    title: "Create Token Response",
-    description: "Newly created personal access token with the plaintext token value.",
-});
+export const TokensCreateRequestJson = CreateTokenRequest;
+export const TokensCreate201 = CreateTokenResponse;
 export const TokensCreate400 = DecodeErrorResponse;
 export const TokensCreate401 = UnauthorizedError;
 export const TokensCreate403 = ForbiddenError;
@@ -422,100 +603,72 @@ export const TokensCreate422 = UnprocessableEntityError;
 export const TokensDelete400 = DecodeErrorResponse;
 export const TokensDelete401 = UnauthorizedError;
 export const TokensDelete403 = ForbiddenError;
+export const OwnersGetOwner200 = OwnerResponse;
+export const OwnersGetOwner400 = DecodeErrorResponse;
+export const OwnersGetOwner404 = NotFoundError;
 export const ExtensionsListByOwner200 = Schema.Struct({
     extensions: Schema.Array(Schema.Struct({
-        name: Schema.String,
-        owner: Schema.String,
-        type: Schema.Literals(["skill", "command", "mcp-server", "subagent", "file", "rule", "pack"]),
-        latestVersion: Schema.String,
+        name: ExtensionName,
+        owner: Handle,
+        type: ExtensionType,
+        latestVersion: ExactSemverVersion,
         description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
         repository: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
         license: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-        authors: Schema.optionalKey(Schema.Union([
-            Schema.Array(Schema.Struct({
-                name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-                email: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-                url: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-            })),
-            Schema.Null,
-        ])),
+        authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
         visibility: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null])),
-        deprecated_at: Schema.optionalKey(Schema.Union([
-            Schema.String.annotate({ readOnly: true, format: "date-time" }),
-            Schema.Null,
-        ])),
+        deprecated_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
         deprecation_notice: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null])),
     })),
 });
 export const ExtensionsListByOwner400 = DecodeErrorResponse;
 export const ExtensionsListByType200 = Schema.Struct({
     extensions: Schema.Array(Schema.Struct({
-        name: Schema.String,
-        owner: Schema.String,
-        type: Schema.Literals(["skill", "command", "mcp-server", "subagent", "file", "rule", "pack"]),
-        latestVersion: Schema.String,
+        name: ExtensionName,
+        owner: Handle,
+        type: ExtensionType,
+        latestVersion: ExactSemverVersion,
         description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
         repository: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
         license: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-        authors: Schema.optionalKey(Schema.Union([
-            Schema.Array(Schema.Struct({
-                name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-                email: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-                url: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-            })),
-            Schema.Null,
-        ])),
+        authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
         visibility: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null])),
-        deprecated_at: Schema.optionalKey(Schema.Union([
-            Schema.String.annotate({ readOnly: true, format: "date-time" }),
-            Schema.Null,
-        ])),
+        deprecated_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
         deprecation_notice: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null])),
     })),
 });
 export const ExtensionsListByType400 = DecodeErrorResponse;
 export const ExtensionsGet200 = Schema.Struct({
-    name: Schema.String,
-    owner: Schema.String,
-    type: Schema.Literals(["skill", "command", "mcp-server", "subagent", "file", "rule", "pack"]),
+    name: ExtensionName,
+    owner: Handle,
+    type: ExtensionType,
     description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
     repository: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
     license: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    authors: Schema.optionalKey(Schema.Union([
-        Schema.Array(Schema.Struct({
-            name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-            email: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-            url: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-        })),
-        Schema.Null,
-    ])),
+    authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
     versions: Schema.Array(Schema.Struct({
-        version: Schema.String,
-        published: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+        version: ExactSemverVersion,
+        published: IsoDateTimeString,
         integrity: Schema.String.annotate({ readOnly: true }),
-        dependencies: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, Schema.String), Schema.Null])),
-        yanked_at: Schema.optionalKey(Schema.Union([
-            Schema.String.annotate({ readOnly: true, format: "date-time" }),
-            Schema.Null,
-        ])),
+        dependencies: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, VersionConstraint), Schema.Null])),
+        compatiblePackages: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+        yanked_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
     })),
     visibility: Schema.optionalKey(Schema.Union([
         Schema.Literals(["public", "unlisted", "private"]).annotate({ readOnly: true }),
         Schema.Null,
     ])),
-    deprecated_at: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true, format: "date-time" }), Schema.Null])),
+    deprecated_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
     deprecation_notice: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null])),
 });
 export const ExtensionsGet400 = DecodeErrorResponse;
 export const ExtensionsGet404 = NotFoundError;
-export const ExtensionsUpdateVisibilityRequestJson = Schema.Struct({
-    visibility: Schema.Literals(["public", "unlisted", "private"]),
-});
+export const ExtensionsUpdateVisibilityRequestJson = PatchVisibilityBody;
 export const ExtensionsUpdateVisibility200 = Schema.Struct({
     id: ExtensionId,
-    owner: Schema.String,
-    type: Schema.String,
-    name: Schema.String,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
     visibility: Schema.String,
     updatedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
 });
@@ -527,27 +680,21 @@ export const ExtensionsUpdateVisibility401 = UnauthorizedError;
 export const ExtensionsUpdateVisibility403 = ForbiddenError;
 export const ExtensionsUpdateVisibility404 = NotFoundError;
 export const ExtensionsGetVersion200 = Schema.Struct({
-    name: Schema.String,
-    owner: Schema.String,
-    type: Schema.String,
-    version: Schema.String,
+    name: ExtensionName,
+    owner: Handle,
+    type: ExtensionType,
+    version: ExactSemverVersion,
     status: Schema.Literals(["pending", "available", "failed"]).annotate({ readOnly: true }),
-    published: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+    published: IsoDateTimeString,
     integrity: Schema.String.annotate({ readOnly: true }),
     description: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
     repository: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
     license: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-    authors: Schema.optionalKey(Schema.Union([
-        Schema.Array(Schema.Struct({
-            name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-            email: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-            url: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-        })),
-        Schema.Null,
-    ])),
-    dependencies: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, Schema.String), Schema.Null])),
-    yanked_at: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true, format: "date-time" }), Schema.Null])),
-    deleted_at: Schema.optionalKey(Schema.Union([Schema.String.annotate({ readOnly: true, format: "date-time" }), Schema.Null])),
+    authors: Schema.optionalKey(Schema.Union([Schema.Array(Author), Schema.Null])),
+    dependencies: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, VersionConstraint), Schema.Null])),
+    compatiblePackages: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    yanked_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
+    deleted_at: Schema.optionalKey(Schema.Union([IsoDateTimeString, Schema.Null])),
 });
 export const ExtensionsGetVersion400 = DecodeErrorResponse;
 export const ExtensionsGetVersion404 = NotFoundError;
@@ -556,24 +703,24 @@ export const ExtensionsPublishVersionRequestFormData = Schema.Struct({
     integrity: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
 });
 export const ExtensionsPublishVersion200 = Schema.Struct({
-    owner: Schema.String,
-    type: Schema.String,
-    name: Schema.String,
-    version: Schema.String,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: ExactSemverVersion,
     integrity: Schema.String.annotate({ readOnly: true }),
     sha256_hex: Schema.String.annotate({ readOnly: true }),
-    published_at: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-    publish_status: Schema.String.annotate({ readOnly: true }),
+    published_at: IsoDateTimeString,
+    publish_status: Schema.Literals(["pending", "available", "failed"]).annotate({ readOnly: true }),
 });
 export const ExtensionsPublishVersion201 = Schema.Struct({
-    owner: Schema.String,
-    type: Schema.String,
-    name: Schema.String,
-    version: Schema.String,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: ExactSemverVersion,
     integrity: Schema.String.annotate({ readOnly: true }),
     sha256_hex: Schema.String.annotate({ readOnly: true }),
-    published_at: Schema.String.annotate({ readOnly: true, format: "date-time" }),
-    publish_status: Schema.String.annotate({ readOnly: true }),
+    published_at: IsoDateTimeString,
+    publish_status: Schema.Literals(["pending", "available", "failed"]).annotate({ readOnly: true }),
 });
 export const ExtensionsPublishVersion400 = Schema.Union([InvalidRequestError, DecodeErrorResponse]);
 export const ExtensionsPublishVersion401 = UnauthorizedError;
@@ -585,7 +732,6 @@ export const ExtensionsPublishVersion415 = UnsupportedMediaTypeError;
 export const ExtensionsPublishVersion422 = UnprocessableEntityError;
 export const ExtensionsPublishVersion429 = TooManyRequestsError;
 export const ExtensionsPublishVersion500 = InternalError;
-export const ExtensionsPublishVersion501 = NotImplementedError;
 export const ExtensionsPublishVersion503 = ServiceUnavailableError;
 export const ExtensionsDeleteVersion400 = DecodeErrorResponse;
 export const ExtensionsDeleteVersion401 = UnauthorizedError;
@@ -594,22 +740,11 @@ export const ExtensionsDeleteVersion404 = NotFoundError;
 export const ExtensionsDownloadArchive400 = DecodeErrorResponse;
 export const ExtensionsDownloadArchive404 = NotFoundError;
 export const ExtensionsDownloadArchive500 = InternalError;
-export const ExtensionsGetOwnerProfile200 = Schema.Struct({
-    ok: Schema.Literal(true),
-    mock: Schema.Literal(true),
-    method: Schema.Literal("GET"),
-    route: Schema.Literal("/v1/extensions/{owner}/profile"),
-    message: Schema.String,
-    params: Schema.Struct({ owner: Schema.String }),
-});
-export const ExtensionsGetOwnerProfile400 = DecodeErrorResponse;
-export const ExtensionsDeprecateRequestJson = Schema.Struct({
-    notice: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
-});
+export const ExtensionsDeprecateRequestJson = DeprecateBody;
 export const ExtensionsDeprecate200 = Schema.Struct({
-    owner: Schema.String,
-    type: Schema.String,
-    name: Schema.String,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
     deprecatedAt: Schema.Union([
         Schema.String.annotate({ readOnly: true, format: "date-time" }),
         Schema.Null,
@@ -621,9 +756,9 @@ export const ExtensionsDeprecate401 = UnauthorizedError;
 export const ExtensionsDeprecate403 = ForbiddenError;
 export const ExtensionsDeprecate404 = NotFoundError;
 export const ExtensionsUndeprecate200 = Schema.Struct({
-    owner: Schema.String,
-    type: Schema.String,
-    name: Schema.String,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
     deprecatedAt: Schema.Null,
     deprecationNotice: Schema.Null,
 });
@@ -632,24 +767,21 @@ export const ExtensionsUndeprecate401 = UnauthorizedError;
 export const ExtensionsUndeprecate403 = ForbiddenError;
 export const ExtensionsUndeprecate404 = NotFoundError;
 export const ExtensionsYankVersion200 = Schema.Struct({
-    owner: Schema.String,
-    type: Schema.String,
-    name: Schema.String,
-    version: Schema.String,
-    yankedAt: Schema.Union([
-        Schema.String.annotate({ readOnly: true, format: "date-time" }),
-        Schema.Null,
-    ]),
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: ExactSemverVersion,
+    yankedAt: Schema.Union([IsoDateTimeString, Schema.Null]),
 });
 export const ExtensionsYankVersion400 = DecodeErrorResponse;
 export const ExtensionsYankVersion401 = UnauthorizedError;
 export const ExtensionsYankVersion403 = ForbiddenError;
 export const ExtensionsYankVersion404 = NotFoundError;
 export const ExtensionsUnyankVersion200 = Schema.Struct({
-    owner: Schema.String,
-    type: Schema.String,
-    name: Schema.String,
-    version: Schema.String,
+    owner: Handle,
+    type: ExtensionType,
+    name: ExtensionName,
+    version: ExactSemverVersion,
     yankedAt: Schema.Null,
 });
 export const ExtensionsUnyankVersion400 = DecodeErrorResponse;
@@ -658,9 +790,9 @@ export const ExtensionsUnyankVersion403 = ForbiddenError;
 export const ExtensionsUnyankVersion404 = NotFoundError;
 export const CollaboratorsListCollaborators200 = Schema.Struct({
     collaborators: Schema.Array(Schema.Struct({
-        userId: UserId,
+        userId: UserId1,
         role: Schema.String,
-        grantedBy: Schema.Union([UserId, Schema.Null]).annotate({ readOnly: true }),
+        grantedBy: Schema.Union([UserId1, Schema.Null]).annotate({ readOnly: true }),
         createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
     })),
 });
@@ -668,13 +800,11 @@ export const CollaboratorsListCollaborators400 = DecodeErrorResponse;
 export const CollaboratorsListCollaborators401 = UnauthorizedError;
 export const CollaboratorsListCollaborators403 = ForbiddenError;
 export const CollaboratorsListCollaborators404 = NotFoundError;
-export const CollaboratorsUpsertCollaboratorRequestJson = Schema.Struct({
-    role: Schema.Literals(["admin", "write", "read"]),
-});
+export const CollaboratorsUpsertCollaboratorRequestJson = PutCollaboratorBody;
 export const CollaboratorsUpsertCollaborator200 = Schema.Struct({
-    userId: UserId,
+    userId: UserId1,
     role: Schema.String,
-    grantedBy: Schema.Union([UserId, Schema.Null]).annotate({ readOnly: true }),
+    grantedBy: Schema.Union([UserId1, Schema.Null]).annotate({ readOnly: true }),
     createdAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
 });
 export const CollaboratorsUpsertCollaborator400 = Schema.Union([
@@ -723,6 +853,8 @@ export const HealthGetDeepHealth400 = DecodeErrorResponse;
 export const HealthGetObservabilityVerificationParams = Schema.Struct({
     "x-health-key": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
     level: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    scenario: Schema.optionalKey(Schema.Union([Schema.Literals(["effect-handled-500", "surface-unhandled-500"]), Schema.Null])),
+    scenarioId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
 });
 export const HealthGetObservabilityVerification200 = Schema.Struct({
     status: Schema.Literals(["ok", "error"]),
@@ -749,6 +881,8 @@ export const HealthGetObservabilityVerification200 = Schema.Struct({
             Schema.Struct({
                 status: Schema.Literals(["ok", "error"]),
                 sentryEventId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+                reason: Schema.optionalKey(Schema.Union([Schema.Literal("sentry-issue-reporter-disabled"), Schema.Null])),
+                message: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
             }),
             Schema.Null,
         ])),
@@ -756,16 +890,24 @@ export const HealthGetObservabilityVerification200 = Schema.Struct({
 });
 export const HealthGetObservabilityVerification400 = DecodeErrorResponse;
 export const SearchSearchExtensionsParams = Schema.Struct({
-    q: Schema.String.check(Schema.isMinLength(1)),
-});
-export const SearchSearchExtensions200 = Schema.Struct({
-    ok: Schema.Literal(true),
-    mock: Schema.Literal(true),
-    method: Schema.Literal("GET"),
-    route: Schema.Literal("/v1/search"),
-    message: Schema.String,
-    query: Schema.Struct({ q: Schema.String }),
+    q: Schema.String.annotate({
+        description: "Search query string. Use an empty string to list the public catalog.",
+        examples: ["git commit", ""],
+    }),
+    cursor: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Opaque cursor from a previous response for pagination.",
+        }),
+        Schema.Null,
+    ])),
+    limit: Schema.optionalKey(Schema.Union([
+        Schema.String.annotate({
+            description: "Maximum number of results to return (1–100, default 20).",
+        }),
+        Schema.Null,
+    ])),
 });
+export const SearchSearchExtensions200 = SearchResponse;
 export const SearchSearchExtensions400 = DecodeErrorResponse;
 export const make = (httpClient, options = {}) => {
     const unexpectedStatus = (response) => Effect.flatMap(Effect.orElseSucceed(response.json, () => "Unexpected status code"), (description) => Effect.fail(new HttpClientError.HttpClientError({
@@ -856,6 +998,12 @@ export const make = (httpClient, options = {}) => {
             "204": () => Effect.void,
             orElse: unexpectedStatus,
         }))),
+        OwnersGetOwner: (handle, options) => HttpClientRequest.get(`/v1/owners/${handle}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(OwnersGetOwner200),
+            "400": decodeError("OwnersGetOwner400", OwnersGetOwner400),
+            "404": decodeError("OwnersGetOwner404", OwnersGetOwner404),
+            orElse: unexpectedStatus,
+        }))),
         ExtensionsListByOwner: (owner, options) => HttpClientRequest.get(`/v1/extensions/${owner}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(ExtensionsListByOwner200),
             "400": decodeError("ExtensionsListByOwner400", ExtensionsListByOwner400),
@@ -907,7 +1055,6 @@ export const make = (httpClient, options = {}) => {
             "422": decodeError("ExtensionsPublishVersion422", ExtensionsPublishVersion422),
             "429": decodeError("ExtensionsPublishVersion429", ExtensionsPublishVersion429),
             "500": decodeError("ExtensionsPublishVersion500", ExtensionsPublishVersion500),
-            "501": decodeError("ExtensionsPublishVersion501", ExtensionsPublishVersion501),
             "503": decodeError("ExtensionsPublishVersion503", ExtensionsPublishVersion503),
             orElse: unexpectedStatus,
         }))),
@@ -927,11 +1074,6 @@ export const make = (httpClient, options = {}) => {
             orElse: unexpectedStatus,
         }))),
         ExtensionsDownloadArchiveStream: (owner, type, name, version) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/${version}/archive`).pipe(binaryRequest),
-        ExtensionsGetOwnerProfile: (owner, options) => HttpClientRequest.get(`/v1/extensions/${owner}/profile`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
-            "2xx": decodeSuccess(ExtensionsGetOwnerProfile200),
-            "400": decodeError("ExtensionsGetOwnerProfile400", ExtensionsGetOwnerProfile400),
-            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),
@@ -1001,14 +1143,22 @@ export const make = (httpClient, options = {}) => {
             "400": decodeError("HealthGetDeepHealth400", HealthGetDeepHealth400),
             orElse: unexpectedStatus,
         }))),
-        HealthGetObservabilityVerification: (options) => HttpClientRequest.get(`/v1/debug/observability`).pipe(HttpClientRequest.setUrlParams({ level: options?.params?.["level"] }), HttpClientRequest.setHeaders({
+        HealthGetObservabilityVerification: (options) => HttpClientRequest.get(`/v1/debug/observability`).pipe(HttpClientRequest.setUrlParams({
+            level: options?.params?.["level"],
+            scenario: options?.params?.["scenario"],
+            scenarioId: options?.params?.["scenarioId"],
+        }), HttpClientRequest.setHeaders({
             "x-health-key": options?.params?.["x-health-key"] ?? undefined,
         }), withResponse(options?.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(HealthGetObservabilityVerification200),
             "400": decodeError("HealthGetObservabilityVerification400", HealthGetObservabilityVerification400),
             orElse: unexpectedStatus,
         }))),
-        SearchSearchExtensions: (options) => HttpClientRequest.get(`/v1/search`).pipe(HttpClientRequest.setUrlParams({ q: options.params["q"] }), withResponse(options.config)(HttpClientResponse.matchStatus({
+        SearchSearchExtensions: (options) => HttpClientRequest.get(`/v1/search`).pipe(HttpClientRequest.setUrlParams({
+            q: options.params["q"],
+            cursor: options.params["cursor"],
+            limit: options.params["limit"],
+        }), withResponse(options.config)(HttpClientResponse.matchStatus({
             "2xx": decodeSuccess(SearchSearchExtensions200),
             "400": decodeError("SearchSearchExtensions400", SearchSearchExtensions400),
             orElse: unexpectedStatus,