@atcute/oauth-types 0.1.1 → 1.0.0

package/dist/schemas/atproto-authorization-server-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-authorization-server-metadata.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-authorization-server-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAIpC;;;;GAIG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvD,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,CAAC"}
+{"version":3,"file":"atproto-authorization-server-metadata.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-authorization-server-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAI7B;;;;GAIG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAgB8B,MAAM;IAC3F,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAC7D,OAAO,2CAA2C,CAClD,CAAC"}

package/dist/schemas/atproto-authorization-server-metadata.js

@@ -1,25 +1,9 @@
-import * as v from '@badrap/valita';
+import * as v from 'valibot';
 import { oauthAuthorizationServerMetadataValidator } from './oauth-authorization-server-metadata.js';
 /**
  * AT Protocol authorization server metadata with required fields and assertions.
  *
  * @see {@link https://atproto.com/specs/oauth}
  */
-export const atprotoAuthorizationServerMetadataValidator = oauthAuthorizationServerMetadataValidator.chain((data) => {
-    // atproto requires client_id_metadata_document support
-    if (data.client_id_metadata_document_supported !== true) {
-        return v.err({
-            message: `atproto requires client_id_metadata_document_supported to be true`,
-            path: ['client_id_metadata_document_supported'],
-        });
-    }
-    // atproto requires PAR
-    if (!data.pushed_authorization_request_endpoint) {
-        return v.err({
-            message: `atproto requires pushed_authorization_request_endpoint to be true`,
-            path: ['pushed_authorization_request_endpoint'],
-        });
-    }
-    return v.ok(data);
-});
+export const atprotoAuthorizationServerMetadataValidator = v.pipe(oauthAuthorizationServerMetadataValidator, v.forward(v.check((data) => data.client_id_metadata_document_supported === true, `atproto requires client_id_metadata_document_supported to be true`), ['client_id_metadata_document_supported']), v.forward(v.check((data) => !!data.pushed_authorization_request_endpoint, `atproto requires pushed_authorization_request_endpoint to be true`), ['pushed_authorization_request_endpoint']), v.transform((data) => data));
 //# sourceMappingURL=atproto-authorization-server-metadata.js.map

package/dist/schemas/atproto-authorization-server-metadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-authorization-server-metadata.js","sourceRoot":"","sources":["../../lib/schemas/atproto-authorization-server-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAEpC,OAAO,EAAE,yCAAyC,EAAE,MAAM,0CAA0C,CAAC;AAErG;;;;GAIG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAG,yCAAyC,CAAC,KAAK,CACzG,CAAC,IAAI,EAAE,EAAE,CAAC;IACT,uDAAuD;IACvD,IAAI,IAAI,CAAC,qCAAqC,KAAK,IAAI,EAAE,CAAC;QACzD,OAAO,CAAC,CAAC,GAAG,CAAC;YACZ,OAAO,EAAE,mEAAmE;YAC5E,IAAI,EAAE,CAAC,uCAAuC,CAAC;SAC/C,CAAC,CAAC;IACJ,CAAC;IAED,uBAAuB;IACvB,IAAI,CAAC,IAAI,CAAC,qCAAqC,EAAE,CAAC;QACjD,OAAO,CAAC,CAAC,GAAG,CAAC;YACZ,OAAO,EAAE,mEAAmE;YAC5E,IAAI,EAAE,CAAC,uCAAuC,CAAC;SAC/C,CAAC,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,CAAC,EAAE,CAAC,IAAuE,CAAC,CAAC;AAAA,CACrF,CACD,CAAC"}
+{"version":3,"file":"atproto-authorization-server-metadata.js","sourceRoot":"","sources":["../../lib/schemas/atproto-authorization-server-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,yCAAyC,EAAE,MAAM,0CAA0C,CAAC;AAErG;;;;GAIG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAG,CAAC,CAAC,IAAI,CAChE,yCAAyC,EACzC,CAAC,CAAC,OAAO,CACR,CAAC,CAAC,KAAK,CACN,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,qCAAqC,KAAK,IAAI,EAC7D,mEAAmE,CACnE,EACD,CAAC,uCAAuC,CAAC,CACzC,EACD,CAAC,CAAC,OAAO,CACR,CAAC,CAAC,KAAK,CACN,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,qCAAqC,EACtD,mEAAmE,CACnE,EACD,CAAC,uCAAuC,CAAC,CACzC,EACD,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAuE,CAAC,CAC9F,CAAC"}

package/dist/schemas/atproto-oauth-scope.d.ts

@@ -1,8 +1,8 @@
-import * as v from '@badrap/valita';
+import * as v from 'valibot';
 export declare const ATPROTO_SCOPE_VALUE = "atproto";
 /** atproto OAuth scope (must include "atproto") */
-export declare const atprotoOAuthScopeSchema: v.Type<string>;
-export type AtprotoOAuthScope = v.Infer<typeof atprotoOAuthScopeSchema>;
+export declare const atprotoOAuthScopeSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "invalid atproto OAuth scope">]>;
+export type AtprotoOAuthScope = v.InferOutput<typeof atprotoOAuthScopeSchema>;
 /** default scope is for reading identity (did) only */
 export declare const DEFAULT_ATPROTO_OAUTH_SCOPE: AtprotoOAuthScope;
 //# sourceMappingURL=atproto-oauth-scope.d.ts.map

package/dist/schemas/atproto-oauth-scope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-oauth-scope.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-scope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAKpC,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAM7C,mDAAmD;AACnD,eAAO,MAAM,uBAAuB,gBAAwE,CAAC;AAE7G,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,uDAAuD;AACvD,eAAO,MAAM,2BAA2B,EAAE,iBAAuC,CAAC"}
+{"version":3,"file":"atproto-oauth-scope.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-scope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAK7B,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAM7C,mDAAmD;AACnD,eAAO,MAAM,uBAAuB,8GAGnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,uDAAuD;AACvD,eAAO,MAAM,2BAA2B,EAAE,iBAAuC,CAAC"}

package/dist/schemas/atproto-oauth-scope.js

@@ -1,4 +1,4 @@
-import * as v from '@badrap/valita';
+import * as v from 'valibot';
 import { isOAuthScope } from './oauth-scope.js';
 import { isSpaceSeparatedValue } from './utils.js';
 export const ATPROTO_SCOPE_VALUE = 'atproto';
@@ -6,7 +6,7 @@ const isAtprotoOAuthScope = (input) => {
     return isOAuthScope(input) && isSpaceSeparatedValue(ATPROTO_SCOPE_VALUE, input);
 };
 /** atproto OAuth scope (must include "atproto") */
-export const atprotoOAuthScopeSchema = v.string().assert(isAtprotoOAuthScope, `invalid atproto OAuth scope`);
+export const atprotoOAuthScopeSchema = v.pipe(v.string(), v.check(isAtprotoOAuthScope, `invalid atproto OAuth scope`));
 /** default scope is for reading identity (did) only */
 export const DEFAULT_ATPROTO_OAUTH_SCOPE = ATPROTO_SCOPE_VALUE;
 //# sourceMappingURL=atproto-oauth-scope.js.map

package/dist/schemas/atproto-oauth-scope.js.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-oauth-scope.js","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-scope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAEpC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,CAAC,MAAM,mBAAmB,GAAG,SAAS,CAAC;AAE7C,MAAM,mBAAmB,GAAG,CAAC,KAAa,EAAW,EAAE,CAAC;IACvD,OAAO,YAAY,CAAC,KAAK,CAAC,IAAI,qBAAqB,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;AAAA,CAChF,CAAC;AAEF,mDAAmD;AACnD,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,mBAAmB,EAAE,6BAA6B,CAAC,CAAC;AAI7G,uDAAuD;AACvD,MAAM,CAAC,MAAM,2BAA2B,GAAsB,mBAAmB,CAAC"}
+{"version":3,"file":"atproto-oauth-scope.js","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-scope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,CAAC,MAAM,mBAAmB,GAAG,SAAS,CAAC;AAE7C,MAAM,mBAAmB,GAAG,CAAC,KAAa,EAAW,EAAE;IACtD,OAAO,YAAY,CAAC,KAAK,CAAC,IAAI,qBAAqB,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;AACjF,CAAC,CAAC;AAEF,mDAAmD;AACnD,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,IAAI,CAC5C,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,KAAK,CAAC,mBAAmB,EAAE,6BAA6B,CAAC,CAC3D,CAAC;AAIF,uDAAuD;AACvD,MAAM,CAAC,MAAM,2BAA2B,GAAsB,mBAAmB,CAAC"}

package/dist/schemas/atproto-oauth-token-response.d.ts

@@ -1,19 +1,19 @@
-import * as v from '@badrap/valita';
-export declare const atprotoOAuthTokenResponseSchema: v.ObjectType<{
-    access_token: v.Type<string>;
-    token_type: v.Type<"DPoP">;
-    sub: v.Type<`did:plc:${string}` | `did:web:${string}`>;
-    scope: v.Type<string>;
-    refresh_token: v.Optional<string>;
-    expires_in: v.Optional<number>;
-    authorization_details: v.Optional<{
-        type: string;
-        locations?: string[] | undefined;
-        actions?: string[] | undefined;
-        datatypes?: string[] | undefined;
-        identifier?: string | undefined;
-        privileges?: string[] | undefined;
-    }[]>;
+import * as v from 'valibot';
+export declare const atprotoOAuthTokenResponseSchema: v.LooseObjectSchema<{
+    readonly access_token: v.StringSchema<undefined>;
+    readonly token_type: v.LiteralSchema<"DPoP", undefined>;
+    readonly sub: v.CustomSchema<`did:${string}:${string}`, v.ErrorMessage<v.CustomIssue> | undefined>;
+    readonly scope: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "invalid atproto OAuth scope">]>;
+    readonly refresh_token: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly expires_in: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly authorization_details: v.OptionalSchema<v.ArraySchema<v.LooseObjectSchema<{
+        readonly type: v.StringSchema<undefined>;
+        readonly locations: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, undefined>, undefined>;
+        readonly actions: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly datatypes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly identifier: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly privileges: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
 }, undefined>;
-export type AtprotoOAuthTokenResponse = v.Infer<typeof atprotoOAuthTokenResponseSchema>;
+export type AtprotoOAuthTokenResponse = v.InferOutput<typeof atprotoOAuthTokenResponseSchema>;
 //# sourceMappingURL=atproto-oauth-token-response.d.ts.map

package/dist/schemas/atproto-oauth-token-response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-oauth-token-response.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-token-response.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAKpC,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;aAU1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}
+{"version":3,"file":"atproto-oauth-token-response.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-token-response.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAK7B,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;aAU1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/schemas/atproto-oauth-token-response.js

@@ -1,16 +1,16 @@
 import { isAtprotoDid } from '@atcute/identity';
-import * as v from '@badrap/valita';
+import * as v from 'valibot';
 import { atprotoOAuthScopeSchema } from './atproto-oauth-scope.js';
 import { oauthAuthorizationDetailsSchema } from './oauth-authorization-details.js';
-export const atprotoOAuthTokenResponseSchema = v.object({
+export const atprotoOAuthTokenResponseSchema = v.looseObject({
     access_token: v.string(),
     token_type: v.literal('DPoP'),
-    sub: v.string().assert(isAtprotoDid, `must be a did:plc or did:web`),
+    sub: v.custom(isAtprotoDid, `must be a did:plc or did:web`),
     scope: atprotoOAuthScopeSchema,
-    refresh_token: v.string().optional(),
-    expires_in: v.number().optional(),
+    refresh_token: v.optional(v.string()),
+    expires_in: v.optional(v.number()),
     // https://datatracker.ietf.org/doc/html/rfc9396#name-enriched-authorization-deta
-    authorization_details: oauthAuthorizationDetailsSchema.optional(),
+    authorization_details: v.optional(oauthAuthorizationDetailsSchema),
     // OpenID is not compatible with atproto identities
 });
 //# sourceMappingURL=atproto-oauth-token-response.js.map

package/dist/schemas/atproto-oauth-token-response.js.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-oauth-token-response.js","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-token-response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAEpC,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AAEnF,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IACvD,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IAC7B,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,YAAY,EAAE,8BAA8B,CAAC;IACpE,KAAK,EAAE,uBAAuB;IAC9B,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACpC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,iFAAiF;IACjF,qBAAqB,EAAE,+BAA+B,CAAC,QAAQ,EAAE;IACjE,mDAAmD;CACnD,CAAC,CAAC"}
+{"version":3,"file":"atproto-oauth-token-response.js","sourceRoot":"","sources":["../../lib/schemas/atproto-oauth-token-response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGhD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAC;AAEnF,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,WAAW,CAAC;IAC5D,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IAC7B,GAAG,EAAE,CAAC,CAAC,MAAM,CAAM,YAAY,EAAE,8BAA8B,CAAC;IAChE,KAAK,EAAE,uBAAuB;IAC9B,aAAa,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACrC,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAClC,iFAAiF;IACjF,qBAAqB,EAAE,CAAC,CAAC,QAAQ,CAAC,+BAA+B,CAAC;IAClE,mDAAmD;CACnD,CAAC,CAAC"}

package/dist/schemas/atproto-protected-resource-metadata.d.ts

@@ -1,10 +1,20 @@
-import * as v from '@badrap/valita';
+import * as v from 'valibot';
 /**
  * AT Protocol protected resource metadata with required fields.
  *
  * @see {@link https://atproto.com/specs/oauth}
  */
-export declare const atprotoProtectedResourceMetadataValidator: v.Type<{
+export declare const atprotoProtectedResourceMetadataValidator: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.LooseObjectSchema<{
+    readonly resource: v.UnionSchema<[v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>, v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>], "url must use http: or https: protocol">;
+    readonly authorization_servers: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>, v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>], "url must use http: or https: protocol">, v.RawCheckAction<string>]>, undefined>, undefined>;
+    readonly jwks_uri: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>, v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>], "url must use http: or https: protocol">, undefined>;
+    readonly scopes_supported: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly bearer_methods_supported: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<["header", "body", "query"], undefined>, undefined>, undefined>;
+    readonly resource_signing_alg_values_supported: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly resource_documentation: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>, v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>], "url must use http: or https: protocol">, undefined>;
+    readonly resource_policy_uri: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>, v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>], "url must use http: or https: protocol">, undefined>;
+    readonly resource_tos_uri: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>, v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "must be a valid url">]>, v.RawCheckAction<string>]>], "url must use http: or https: protocol">, undefined>;
+}, undefined>, v.BaseValidation<{
     resource: string;
     authorization_servers?: string[] | undefined;
     jwks_uri?: string | undefined;
@@ -14,8 +24,94 @@ export declare const atprotoProtectedResourceMetadataValidator: v.Type<{
     resource_documentation?: string | undefined;
     resource_policy_uri?: string | undefined;
     resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
+}, {
+    resource: string;
+    authorization_servers?: string[] | undefined;
+    jwks_uri?: string | undefined;
+    scopes_supported?: string[] | undefined;
+    bearer_methods_supported?: ("body" | "header" | "query")[] | undefined;
+    resource_signing_alg_values_supported?: string[] | undefined;
+    resource_documentation?: string | undefined;
+    resource_policy_uri?: string | undefined;
+    resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
+}, v.CheckIssue<{
+    resource: string;
+    authorization_servers?: string[] | undefined;
+    jwks_uri?: string | undefined;
+    scopes_supported?: string[] | undefined;
+    bearer_methods_supported?: ("body" | "header" | "query")[] | undefined;
+    resource_signing_alg_values_supported?: string[] | undefined;
+    resource_documentation?: string | undefined;
+    resource_policy_uri?: string | undefined;
+    resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
+}>>]>, v.BaseValidation<{
+    resource: string;
+    authorization_servers?: string[] | undefined;
+    jwks_uri?: string | undefined;
+    scopes_supported?: string[] | undefined;
+    bearer_methods_supported?: ("body" | "header" | "query")[] | undefined;
+    resource_signing_alg_values_supported?: string[] | undefined;
+    resource_documentation?: string | undefined;
+    resource_policy_uri?: string | undefined;
+    resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
+}, {
+    resource: string;
+    authorization_servers?: string[] | undefined;
+    jwks_uri?: string | undefined;
+    scopes_supported?: string[] | undefined;
+    bearer_methods_supported?: ("body" | "header" | "query")[] | undefined;
+    resource_signing_alg_values_supported?: string[] | undefined;
+    resource_documentation?: string | undefined;
+    resource_policy_uri?: string | undefined;
+    resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
+}, v.CheckIssue<{
+    resource: string;
+    authorization_servers?: string[] | undefined;
+    jwks_uri?: string | undefined;
+    scopes_supported?: string[] | undefined;
+    bearer_methods_supported?: ("body" | "header" | "query")[] | undefined;
+    resource_signing_alg_values_supported?: string[] | undefined;
+    resource_documentation?: string | undefined;
+    resource_policy_uri?: string | undefined;
+    resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
+}>>, v.TransformAction<{
+    resource: string;
+    authorization_servers?: string[] | undefined;
+    jwks_uri?: string | undefined;
+    scopes_supported?: string[] | undefined;
+    bearer_methods_supported?: ("body" | "header" | "query")[] | undefined;
+    resource_signing_alg_values_supported?: string[] | undefined;
+    resource_documentation?: string | undefined;
+    resource_policy_uri?: string | undefined;
+    resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
+}, {
+    resource: string;
+    authorization_servers?: string[] | undefined;
+    jwks_uri?: string | undefined;
+    scopes_supported?: string[] | undefined;
+    bearer_methods_supported?: ("body" | "header" | "query")[] | undefined;
+    resource_signing_alg_values_supported?: string[] | undefined;
+    resource_documentation?: string | undefined;
+    resource_policy_uri?: string | undefined;
+    resource_tos_uri?: string | undefined;
+} & {
+    [key: string]: unknown;
 } & {
     authorization_servers: [string];
-}>;
-export type AtprotoProtectedResourceMetadata = v.Infer<typeof atprotoProtectedResourceMetadataValidator>;
+}>]>;
+export type AtprotoProtectedResourceMetadata = v.InferOutput<typeof atprotoProtectedResourceMetadataValidator>;
 //# sourceMappingURL=atproto-protected-resource-metadata.d.ts.map

package/dist/schemas/atproto-protected-resource-metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-protected-resource-metadata.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-protected-resource-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAIpC;;;;GAIG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;EAYrD,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC"}
+{"version":3,"file":"atproto-protected-resource-metadata.d.ts","sourceRoot":"","sources":["../../lib/schemas/atproto-protected-resource-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAI7B;;;;GAIG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BASgB,CAAC,MAAM,CAAC;IAC7E,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,WAAW,CAC3D,OAAO,yCAAyC,CAChD,CAAC"}

package/dist/schemas/atproto-protected-resource-metadata.js

@@ -1,18 +1,9 @@
-import * as v from '@badrap/valita';
+import * as v from 'valibot';
 import { oauthProtectedResourceMetadataValidator } from './oauth-protected-resource-metadata.js';
 /**
  * AT Protocol protected resource metadata with required fields.
  *
  * @see {@link https://atproto.com/specs/oauth}
  */
-export const atprotoProtectedResourceMetadataValidator = oauthProtectedResourceMetadataValidator.chain((data) => {
-    // atproto requires exactly one authorization server
-    if (data.authorization_servers?.length !== 1) {
-        return v.err({
-            message: `atproto requires exactly one authorization server`,
-            path: ['authorization_servers'],
-        });
-    }
-    return v.ok(data);
-});
+export const atprotoProtectedResourceMetadataValidator = v.pipe(oauthProtectedResourceMetadataValidator, v.forward(v.check((data) => data.authorization_servers?.length === 1, `atproto requires exactly one authorization server`), ['authorization_servers']), v.transform((data) => data));
 //# sourceMappingURL=atproto-protected-resource-metadata.js.map

package/dist/schemas/atproto-protected-resource-metadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"atproto-protected-resource-metadata.js","sourceRoot":"","sources":["../../lib/schemas/atproto-protected-resource-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAEpC,OAAO,EAAE,uCAAuC,EAAE,MAAM,wCAAwC,CAAC;AAEjG;;;;GAIG;AACH,MAAM,CAAC,MAAM,yCAAyC,GAAG,uCAAuC,CAAC,KAAK,CACrG,CAAC,IAAI,EAAE,EAAE,CAAC;IACT,oDAAoD;IACpD,IAAI,IAAI,CAAC,qBAAqB,EAAE,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9C,OAAO,CAAC,CAAC,GAAG,CAAC;YACZ,OAAO,EAAE,mDAAmD;YAC5D,IAAI,EAAE,CAAC,uBAAuB,CAAC;SAC/B,CAAC,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,CAAC,EAAE,CAAC,IAAyD,CAAC,CAAC;AAAA,CACvE,CACD,CAAC"}
+{"version":3,"file":"atproto-protected-resource-metadata.js","sourceRoot":"","sources":["../../lib/schemas/atproto-protected-resource-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,uCAAuC,EAAE,MAAM,wCAAwC,CAAC;AAEjG;;;;GAIG;AACH,MAAM,CAAC,MAAM,yCAAyC,GAAG,CAAC,CAAC,IAAI,CAC9D,uCAAuC,EACvC,CAAC,CAAC,OAAO,CACR,CAAC,CAAC,KAAK,CACN,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,qBAAqB,EAAE,MAAM,KAAK,CAAC,EAClD,mDAAmD,CACnD,EACD,CAAC,uBAAuB,CAAC,CACzB,EACD,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAyD,CAAC,CAChF,CAAC"}