@agentxm/client-core 0.1.6

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

@@ -0,0 +1,1026 @@
+// Generated from specs/registry-openapi.json — do not edit by hand.
+// Regenerate: pnpm generate
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * 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 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 DeviceTokenOAuthError = Schema.Struct({
+    kind: Schema.Literal("DeviceTokenOAuthError"),
+    error: Schema.Literals([
+        "invalid_request",
+        "authorization_pending",
+        "slow_down",
+        "expired_token",
+        "access_denied",
+    ]),
+    error_description: Schema.String,
+});
+export const RefreshTokenError = Schema.Struct({
+    kind: Schema.Literal("RefreshTokenError"),
+    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.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.",
+    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.",
+    examples: ["tok_01h455vb4pexka56gq5w2r7cpc"],
+}));
+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),
+});
+export const NotImplementedError = Schema.Struct({
+    kind: Schema.Literal("NotImplementedError"),
+    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 ForbiddenError = Schema.Struct({
+    kind: Schema.Literal("ForbiddenError"),
+    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.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])),
+        }),
+    ])),
+});
+export const UnprocessableEntityError = Schema.Struct({
+    kind: Schema.Literal("UnprocessableEntityError"),
+    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 NotFoundError = Schema.Struct({
+    kind: Schema.Literal("NotFoundError"),
+    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 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])),
+    })),
+});
+export const PayloadTooLargeError = Schema.Struct({
+    kind: Schema.Literal("PayloadTooLargeError"),
+    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 UnsupportedMediaTypeError = Schema.Struct({
+    kind: Schema.Literal("UnsupportedMediaTypeError"),
+    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 TooManyRequestsError = Schema.Struct({
+    kind: Schema.Literal("TooManyRequestsError"),
+    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 ServiceUnavailableError = Schema.Struct({
+    kind: Schema.Literal("ServiceUnavailableError"),
+    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 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 MetaGet400 = DecodeErrorResponse;
+export const AuthIssueDeviceCodeRequestFormUrlEncoded = Schema.Struct({
+    client_id: Schema.Literal("axm-cli"),
+    scope: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+export const AuthIssueDeviceCode200 = 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 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.",
+    }),
+    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 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.",
+    }),
+    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 AuthRefreshToken400 = DecodeErrorResponse;
+export const AuthRefreshToken401 = RefreshTokenError;
+export const AuthRevokeTokenRequestFormUrlEncoded = Schema.Struct({
+    token: Schema.String.check(Schema.isMinLength(1)),
+});
+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 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]),
+});
+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 TokensCreate400 = DecodeErrorResponse;
+export const TokensCreate401 = UnauthorizedError;
+export const TokensCreate403 = ForbiddenError;
+export const TokensCreate422 = UnprocessableEntityError;
+export const TokensDelete400 = DecodeErrorResponse;
+export const TokensDelete401 = UnauthorizedError;
+export const TokensDelete403 = ForbiddenError;
+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,
+        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,
+        ])),
+        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,
+        ])),
+        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,
+        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,
+        ])),
+        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,
+        ])),
+        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"]),
+    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,
+    ])),
+    versions: Schema.Array(Schema.Struct({
+        version: Schema.String,
+        published: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+        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,
+        ])),
+    })),
+    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])),
+    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 ExtensionsUpdateVisibility200 = Schema.Struct({
+    id: ExtensionId,
+    owner: Schema.String,
+    type: Schema.String,
+    name: Schema.String,
+    visibility: Schema.String,
+    updatedAt: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+});
+export const ExtensionsUpdateVisibility400 = Schema.Union([
+    InvalidRequestError,
+    DecodeErrorResponse,
+]);
+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,
+    status: Schema.Literals(["pending", "available", "failed"]).annotate({ readOnly: true }),
+    published: Schema.String.annotate({ readOnly: true, format: "date-time" }),
+    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])),
+});
+export const ExtensionsGetVersion400 = DecodeErrorResponse;
+export const ExtensionsGetVersion404 = NotFoundError;
+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: Schema.String,
+    type: Schema.String,
+    name: Schema.String,
+    version: Schema.String,
+    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 }),
+});
+export const ExtensionsPublishVersion201 = Schema.Struct({
+    owner: Schema.String,
+    type: Schema.String,
+    name: Schema.String,
+    version: Schema.String,
+    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 }),
+});
+export const ExtensionsPublishVersion400 = Schema.Union([InvalidRequestError, DecodeErrorResponse]);
+export const ExtensionsPublishVersion401 = UnauthorizedError;
+export const ExtensionsPublishVersion403 = ForbiddenError;
+export const ExtensionsPublishVersion404 = NotFoundError;
+export const ExtensionsPublishVersion409 = ConflictError;
+export const ExtensionsPublishVersion413 = PayloadTooLargeError;
+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;
+export const ExtensionsDeleteVersion403 = ForbiddenError;
+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 ExtensionsDeprecate200 = Schema.Struct({
+    owner: Schema.String,
+    type: Schema.String,
+    name: Schema.String,
+    deprecatedAt: Schema.Union([
+        Schema.String.annotate({ readOnly: true, format: "date-time" }),
+        Schema.Null,
+    ]),
+    deprecationNotice: Schema.Union([Schema.String.annotate({ readOnly: true }), Schema.Null]),
+});
+export const ExtensionsDeprecate400 = DecodeErrorResponse;
+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,
+    deprecatedAt: Schema.Null,
+    deprecationNotice: Schema.Null,
+});
+export const ExtensionsUndeprecate400 = DecodeErrorResponse;
+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,
+    ]),
+});
+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,
+    yankedAt: Schema.Null,
+});
+export const ExtensionsUnyankVersion400 = DecodeErrorResponse;
+export const ExtensionsUnyankVersion401 = UnauthorizedError;
+export const ExtensionsUnyankVersion403 = ForbiddenError;
+export const ExtensionsUnyankVersion404 = NotFoundError;
+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 = UnauthorizedError;
+export const CollaboratorsListCollaborators403 = ForbiddenError;
+export const CollaboratorsListCollaborators404 = NotFoundError;
+export const CollaboratorsUpsertCollaboratorRequestJson = Schema.Struct({
+    role: Schema.Literals(["admin", "write", "read"]),
+});
+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([
+    InvalidRequestError,
+    DecodeErrorResponse,
+]);
+export const CollaboratorsUpsertCollaborator401 = UnauthorizedError;
+export const CollaboratorsUpsertCollaborator403 = ForbiddenError;
+export const CollaboratorsUpsertCollaborator404 = NotFoundError;
+export const CollaboratorsDeleteCollaborator400 = DecodeErrorResponse;
+export const CollaboratorsDeleteCollaborator401 = UnauthorizedError;
+export const CollaboratorsDeleteCollaborator403 = ForbiddenError;
+export const CollaboratorsDeleteCollaborator404 = NotFoundError;
+export const CollaboratorsDeleteCollaborator409 = ConflictError;
+export const HealthGetShallowHealth200 = Schema.Struct({
+    status: Schema.Literals(["pass", "warn", "fail"]),
+});
+export const HealthGetShallowHealth400 = DecodeErrorResponse;
+export const HealthGetDeepHealthParams = Schema.Struct({
+    "x-health-key": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+export const HealthGetDeepHealth200 = Schema.Struct({
+    status: Schema.Literals(["pass", "warn", "fail"]),
+    serviceId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    version: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    releaseId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    commit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    deployedAt: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    environment: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    region: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+    checks: Schema.optionalKey(Schema.Union([
+        Schema.Record(Schema.String, Schema.Array(Schema.Struct({
+            componentName: Schema.String,
+            componentType: Schema.Literals(["datastore", "system", "component"]),
+            measurementName: Schema.String,
+            status: Schema.Literals(["pass", "warn", "fail"]),
+            observedValue: Schema.Number.check(Schema.isFinite()),
+            observedUnit: Schema.String,
+            time: Schema.String,
+        }))),
+        Schema.Null,
+    ])),
+    output: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+});
+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])),
+});
+export const HealthGetObservabilityVerification200 = Schema.Struct({
+    status: Schema.Literals(["ok", "error"]),
+    timestamp: Schema.String,
+    serviceId: Schema.String,
+    level: Schema.Literals(["basic", "standard", "full"]),
+    checks: Schema.Struct({
+        logging: Schema.optionalKey(Schema.Union([
+            Schema.Struct({ status: Schema.Literals(["ok", "error"]), correlationId: Schema.String }),
+            Schema.Null,
+        ])),
+        tracing: Schema.optionalKey(Schema.Union([
+            Schema.Struct({
+                status: Schema.Literals(["ok", "error"]),
+                traceId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Null,
+        ])),
+        metrics: Schema.optionalKey(Schema.Union([
+            Schema.Struct({ status: Schema.Literals(["ok", "error"]), counter: Schema.String }),
+            Schema.Null,
+        ])),
+        errors: Schema.optionalKey(Schema.Union([
+            Schema.Struct({
+                status: Schema.Literals(["ok", "error"]),
+                sentryEventId: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Null,
+        ])),
+    }),
+});
+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 }),
+});
+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({
+        reason: new HttpClientError.StatusCodeError({
+            request: response.request,
+            response,
+            description: typeof description === "string" ? description : JSON.stringify(description),
+        }),
+    })));
+    const withResponse = (config) => (f) => {
+        const withOptionalResponse = (config?.includeResponse
+            ? (response) => Effect.map(f(response), (a) => [a, response])
+            : (response) => f(response));
+        return options?.transformClient
+            ? (request) => Effect.flatMap(Effect.flatMap(options.transformClient(httpClient), (client) => client.execute(request)), withOptionalResponse)
+            : (request) => Effect.flatMap(httpClient.execute(request), withOptionalResponse);
+    };
+    const binaryRequest = (request) => HttpClient.filterStatusOk(httpClient)
+        .execute(request)
+        .pipe(Effect.map((response) => response.stream), Stream.unwrap);
+    const decodeBinary = (response) => Effect.map(response.arrayBuffer, (buffer) => new Uint8Array(buffer));
+    const decodeSuccess = (schema) => (response) => HttpClientResponse.schemaBodyJson(schema)(response);
+    const decodeError = (tag, schema) => (response) => Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)(response), (cause) => Effect.fail(RegistryClientError(tag, cause, response)));
+    const decodeVoidError = (tag) => (response) => Effect.fail(RegistryClientError(tag, undefined, response));
+    return {
+        httpClient,
+        MetaGet: (options) => HttpClientRequest.get(`/v1`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(MetaGet200),
+            "400": decodeError("MetaGet400", MetaGet400),
+            orElse: unexpectedStatus,
+        }))),
+        AuthIssueDeviceCode: (options) => HttpClientRequest.post(`/v1/auth/device/code`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthIssueDeviceCode200),
+            "400": decodeError("AuthIssueDeviceCode400", AuthIssueDeviceCode400),
+            "500": decodeError("AuthIssueDeviceCode500", AuthIssueDeviceCode500),
+            orElse: unexpectedStatus,
+        }))),
+        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,
+        }))),
+        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),
+            "401": decodeError("AuthRefreshToken401", AuthRefreshToken401),
+            orElse: unexpectedStatus,
+        }))),
+        AuthRevokeToken: (options) => HttpClientRequest.post(`/v1/auth/token/revoke`).pipe(HttpClientRequest.bodyUrlParams(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("AuthRevokeToken400", AuthRevokeToken400),
+            "200": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        AuthGetMe: (options) => HttpClientRequest.get(`/v1/auth/me`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(AuthGetMe200),
+            "400": decodeError("AuthGetMe400", AuthGetMe400),
+            "401": decodeError("AuthGetMe401", AuthGetMe401),
+            orElse: unexpectedStatus,
+        }))),
+        AuthExchangeOidcToken: (options) => HttpClientRequest.post(`/v1/auth/oidc/exchange`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("AuthExchangeOidcToken400", AuthExchangeOidcToken400),
+            "501": decodeError("AuthExchangeOidcToken501", AuthExchangeOidcToken501),
+            "204": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        TokensList: (options) => HttpClientRequest.get(`/v1/tokens`).pipe(HttpClientRequest.setUrlParams({
+            cursor: options?.params?.["cursor"],
+            limit: options?.params?.["limit"],
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(TokensList200),
+            "400": decodeError("TokensList400", TokensList400),
+            "401": decodeError("TokensList401", TokensList401),
+            "403": decodeError("TokensList403", TokensList403),
+            orElse: unexpectedStatus,
+        }))),
+        TokensCreate: (options) => HttpClientRequest.post(`/v1/tokens`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(TokensCreate201),
+            "400": decodeError("TokensCreate400", TokensCreate400),
+            "401": decodeError("TokensCreate401", TokensCreate401),
+            "403": decodeError("TokensCreate403", TokensCreate403),
+            "422": decodeError("TokensCreate422", TokensCreate422),
+            orElse: unexpectedStatus,
+        }))),
+        TokensDelete: (tokenId, options) => HttpClientRequest.delete(`/v1/tokens/${tokenId}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "400": decodeError("TokensDelete400", TokensDelete400),
+            "401": decodeError("TokensDelete401", TokensDelete401),
+            "403": decodeError("TokensDelete403", TokensDelete403),
+            "204": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsListByOwner: (owner, options) => HttpClientRequest.get(`/v1/extensions/${owner}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsListByOwner200),
+            "400": decodeError("ExtensionsListByOwner400", ExtensionsListByOwner400),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsListByType: (owner, type, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsListByType200),
+            "400": decodeError("ExtensionsListByType400", ExtensionsListByType400),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsGet: (owner, type, name, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsGet200),
+            "400": decodeError("ExtensionsGet400", ExtensionsGet400),
+            "404": decodeError("ExtensionsGet404", ExtensionsGet404),
+            "304": () => Effect.void,
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsHead: (owner, type, name, options) => HttpClientRequest.head(`/v1/extensions/${owner}/${type}/${name}`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "200": () => Effect.void,
+            "400": decodeVoidError("400"),
+            "404": decodeVoidError("404"),
+            "500": decodeVoidError("500"),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsUpdateVisibility: (owner, type, name, options) => HttpClientRequest.patch(`/v1/extensions/${owner}/${type}/${name}`).pipe(HttpClientRequest.bodyJsonUnsafe(options.payload), withResponse(options.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsUpdateVisibility200),
+            "400": decodeError("ExtensionsUpdateVisibility400", ExtensionsUpdateVisibility400),
+            "401": decodeError("ExtensionsUpdateVisibility401", ExtensionsUpdateVisibility401),
+            "403": decodeError("ExtensionsUpdateVisibility403", ExtensionsUpdateVisibility403),
+            "404": decodeError("ExtensionsUpdateVisibility404", ExtensionsUpdateVisibility404),
+            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),
+            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),
+            "400": decodeError("ExtensionsPublishVersion400", ExtensionsPublishVersion400),
+            "401": decodeError("ExtensionsPublishVersion401", ExtensionsPublishVersion401),
+            "403": decodeError("ExtensionsPublishVersion403", ExtensionsPublishVersion403),
+            "404": decodeError("ExtensionsPublishVersion404", ExtensionsPublishVersion404),
+            "409": decodeError("ExtensionsPublishVersion409", ExtensionsPublishVersion409),
+            "413": decodeError("ExtensionsPublishVersion413", ExtensionsPublishVersion413),
+            "415": decodeError("ExtensionsPublishVersion415", ExtensionsPublishVersion415),
+            "422": decodeError("ExtensionsPublishVersion422", ExtensionsPublishVersion422),
+            "429": decodeError("ExtensionsPublishVersion429", ExtensionsPublishVersion429),
+            "500": decodeError("ExtensionsPublishVersion500", ExtensionsPublishVersion500),
+            "501": decodeError("ExtensionsPublishVersion501", ExtensionsPublishVersion501),
+            "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,
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsDownloadArchive: (owner, type, name, version, options) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/${version}/archive`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeBinary,
+            "400": decodeError("ExtensionsDownloadArchive400", ExtensionsDownloadArchive400),
+            "404": decodeError("ExtensionsDownloadArchive404", ExtensionsDownloadArchive404),
+            "500": decodeError("ExtensionsDownloadArchive500", ExtensionsDownloadArchive500),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsDownloadArchiveStream: (owner, type, name, version) => HttpClientRequest.get(`/v1/extensions/${owner}/${type}/${name}/${version}/archive`).pipe(binaryRequest),
+        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),
+            "401": decodeError("ExtensionsDeprecate401", ExtensionsDeprecate401),
+            "403": decodeError("ExtensionsDeprecate403", ExtensionsDeprecate403),
+            "404": decodeError("ExtensionsDeprecate404", ExtensionsDeprecate404),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsUndeprecate: (owner, type, name, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/deprecate`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsUndeprecate200),
+            "400": decodeError("ExtensionsUndeprecate400", ExtensionsUndeprecate400),
+            "401": decodeError("ExtensionsUndeprecate401", ExtensionsUndeprecate401),
+            "403": decodeError("ExtensionsUndeprecate403", ExtensionsUndeprecate403),
+            "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({
+            "2xx": decodeSuccess(ExtensionsYankVersion200),
+            "400": decodeError("ExtensionsYankVersion400", ExtensionsYankVersion400),
+            "401": decodeError("ExtensionsYankVersion401", ExtensionsYankVersion401),
+            "403": decodeError("ExtensionsYankVersion403", ExtensionsYankVersion403),
+            "404": decodeError("ExtensionsYankVersion404", ExtensionsYankVersion404),
+            orElse: unexpectedStatus,
+        }))),
+        ExtensionsUnyankVersion: (owner, type, name, version, options) => HttpClientRequest.delete(`/v1/extensions/${owner}/${type}/${name}/${version}/yank`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(ExtensionsUnyankVersion200),
+            "400": decodeError("ExtensionsUnyankVersion400", ExtensionsUnyankVersion400),
+            "401": decodeError("ExtensionsUnyankVersion401", ExtensionsUnyankVersion401),
+            "403": decodeError("ExtensionsUnyankVersion403", ExtensionsUnyankVersion403),
+            "404": decodeError("ExtensionsUnyankVersion404", ExtensionsUnyankVersion404),
+            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,
+        }))),
+        HealthGetShallowHealth: (options) => HttpClientRequest.get(`/v1/health`).pipe(withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(HealthGetShallowHealth200),
+            "400": decodeError("HealthGetShallowHealth400", HealthGetShallowHealth400),
+            orElse: unexpectedStatus,
+        }))),
+        HealthGetDeepHealth: (options) => HttpClientRequest.get(`/v1/health/dependencies`).pipe(HttpClientRequest.setHeaders({
+            "x-health-key": options?.params?.["x-health-key"] ?? undefined,
+        }), withResponse(options?.config)(HttpClientResponse.matchStatus({
+            "2xx": decodeSuccess(HealthGetDeepHealth200),
+            "400": decodeError("HealthGetDeepHealth400", HealthGetDeepHealth400),
+            orElse: unexpectedStatus,
+        }))),
+        HealthGetObservabilityVerification: (options) => HttpClientRequest.get(`/v1/debug/observability`).pipe(HttpClientRequest.setUrlParams({ level: options?.params?.["level"] }), 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({
+            "2xx": decodeSuccess(SearchSearchExtensions200),
+            "400": decodeError("SearchSearchExtensions400", SearchSearchExtensions400),
+            orElse: unexpectedStatus,
+        }))),
+    };
+};
+class RegistryClientErrorImpl extends Data.Error {
+}
+export const RegistryClientError = (tag, cause, response) => new RegistryClientErrorImpl({
+    _tag: tag,
+    cause,
+    response,
+    request: response.request,
+});
+//# sourceMappingURL=registry-client.js.map