@atiproto/lexicons 1.1.0 → 2.0.0-beta.1

package/dist/lexicons/network/attested/proof.defs.d.ts

@@ -0,0 +1,172 @@
+import { l } from '@atproto/lex';
+declare const $nsid = "network.attested.proof";
+export { $nsid };
+type Main = {
+    $type: 'network.attested.proof';
+    /**
+     * CID of the canonical signing payload of the source record being attested (same computation as `network.attested.signature.cid`).
+     */
+    cid: l.CidString;
+    /**
+     * Optional status indicator for the attestation (implementation-defined).
+     */
+    status?: string;
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+    issuer?: l.DidString;
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+    role?: 'broker' | 'pos' | 'appview' | 'co-signer' | l.UnknownString;
+};
+export type { Main };
+declare const main: l.RecordSchema<"any", "network.attested.proof", l.Validator<Omit<Main, "$type">, Omit<Main, "$type">>>;
+export { main };
+export declare const $isTypeOf: <TValue extends {
+    $type?: unknown;
+}>(value: TValue) => value is l.TypedRecord<"network.attested.proof", TValue>, $build: {
+    (input: Omit<Omit<Main, "$type">, "$type">): {
+        cid: l.CidString;
+        issuer?: l.DidString
+        /**
+         * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+         */
+         | undefined;
+        role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+        status?: string
+        /**
+         * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+         */
+         | undefined;
+        $type: "network.attested.proof";
+    };
+    (input: Omit<Omit<Main, "$type">, "$type">): {
+        cid: l.CidString;
+        issuer?: l.DidString
+        /**
+         * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+         */
+         | undefined;
+        role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+        status?: string
+        /**
+         * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+         */
+         | undefined;
+        $type: "network.attested.proof";
+    };
+}, $type: "network.attested.proof";
+export declare const $assert: (input: unknown, options?: l.ValidateOptions) => asserts input is {
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}, $check: (input: unknown, options?: l.ValidateOptions) => void, $cast: <I>(input: I, options?: l.ValidateOptions) => I & {
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}, $ifMatches: <I>(input: I, options?: l.ValidateOptions) => (I & {
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}) | undefined, $matches: <I>(input: I, options?: l.ValidateOptions) => input is I & {
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}, $parse: (input: unknown, options?: l.ParseOptions) => {
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}, $safeParse: (input: unknown, options?: l.ParseOptions) => l.ValidationResult<{
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}>, $validate: <I>(input: I, options?: l.ValidateOptions) => I & {
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}, $safeValidate: <I>(input: I, options?: l.ValidateOptions) => l.ValidationResult<I & {
+    cid: l.CidString;
+    issuer?: l.DidString
+    /**
+     * Optional. Role under which the issuer attested. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    status?: string
+    /**
+     * Optional. DID of the issuing party. Usually redundant with the repository owner; useful when the record was written by a delegate or when the issuer wants to be explicit.
+     */
+     | undefined;
+    $type: "network.attested.proof";
+}>;

package/dist/lexicons/network/attested/signature.d.ts

@@ -0,0 +1,2 @@
+export * from './signature.defs.js';
+export * as $defs from './signature.defs.js';

package/dist/lexicons/network/attested/signature.defs.d.ts

@@ -0,0 +1,230 @@
+import { l } from '@atproto/lex';
+declare const $nsid = "network.attested.signature";
+export { $nsid };
+type Main = {
+    $type?: 'network.attested.signature';
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+    key: string;
+    /**
+     * CID of the canonical signing payload (the record with `signatures` stripped, `$sig` metadata inserted including the repository DID, DAG-CBOR encoded, SHA-256 wrapped as CIDv1).
+     */
+    cid: l.CidString;
+    /**
+     * Normalized ECDSA signature bytes over the CID. Curve is inferred from `key` (P-256, P-384, or K-256). Serialized as `{ "$bytes": "<base64>" }` per lex bytes encoding.
+     */
+    signature: Uint8Array;
+    /**
+     * Optional. DID of the issuing party. Useful when `key` does not directly identify the issuer.
+     */
+    issuer?: l.DidString;
+    /**
+     * Optional. When the signature was produced.
+     */
+    issuedAt?: l.DatetimeString;
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+    role?: 'broker' | 'pos' | 'appview' | 'co-signer' | l.UnknownString;
+};
+export type { Main };
+declare const main: l.TypedObjectSchema<"network.attested.signature", l.Validator<Main, Main>>;
+export { main };
+export declare const $isTypeOf: <TValue extends Record<string, unknown>>(value: TValue) => value is l.MaybeTypedObject<"network.attested.signature", TValue>, $build: {
+    (input: Omit<Main, "$type">): {
+        $type: "network.attested.signature";
+        key: string;
+        cid: l.CidString;
+        signature: Uint8Array;
+        issuer?: l.DidString
+        /**
+         * Optional. When the signature was produced.
+         */
+         | undefined;
+        issuedAt?: l.DatetimeString
+        /**
+         * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+         */
+         | undefined;
+        role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    };
+    (input: Omit<Main, "$type">): {
+        $type: "network.attested.signature";
+        key: string;
+        cid: l.CidString;
+        signature: Uint8Array;
+        issuer?: l.DidString
+        /**
+         * Optional. When the signature was produced.
+         */
+         | undefined;
+        issuedAt?: l.DatetimeString
+        /**
+         * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+         */
+         | undefined;
+        role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+    };
+}, $type: "network.attested.signature";
+export declare const $assert: (input: unknown, options?: l.ValidateOptions) => asserts input is {
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}, $check: (input: unknown, options?: l.ValidateOptions) => void, $cast: <I>(input: I, options?: l.ValidateOptions) => I & {
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}, $ifMatches: <I>(input: I, options?: l.ValidateOptions) => (I & {
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}) | undefined, $matches: <I>(input: I, options?: l.ValidateOptions) => input is I & {
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}, $parse: (input: unknown, options?: l.ParseOptions) => {
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}, $safeParse: (input: unknown, options?: l.ParseOptions) => l.ValidationResult<{
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}>, $validate: <I>(input: I, options?: l.ValidateOptions) => I & {
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}, $safeValidate: <I>(input: I, options?: l.ValidateOptions) => l.ValidationResult<I & {
+    $type?: "network.attested.signature"
+    /**
+     * did:key public-key reference used to verify this signature.
+     */
+     | undefined;
+    key: string;
+    cid: l.CidString;
+    signature: Uint8Array;
+    issuer?: l.DidString
+    /**
+     * Optional. When the signature was produced.
+     */
+     | undefined;
+    issuedAt?: l.DatetimeString
+    /**
+     * Optional. Role under which the issuer signed. Lets verifiers reason about completeness (e.g. require both PoS and AppView attestations on a cart).
+     */
+     | undefined;
+    role?: ("broker" | "pos" | "appview" | "co-signer" | l.UnknownString) | undefined;
+}>;

package/dist/lexicons/network/attested/verify.d.ts

@@ -0,0 +1,2 @@
+export * from './verify.defs.js';
+export * as $defs from './verify.defs.js';

package/dist/lexicons/network/attested/verify.defs.d.ts

@@ -0,0 +1,41 @@
+import { l } from '@atproto/lex';
+import * as AttestedSignature from './signature.defs.js';
+import * as RepoStrongRef from '../../com/atproto/repo/strongRef.defs.js';
+import * as AtiprotoActions from '../../com/atiproto/actions.defs.js';
+declare const $nsid = "network.attested.verify";
+export { $nsid };
+/** Verify signatures on a signed record (`network.attested.payment`, `network.attested.entitlement`, or any `com.atiproto.*` record using the same scheme). Open to any caller. Implemented by both brokers (over their `network.attested.payment` records) and the PoS (over its own records). To retrieve hydrated payment details, call `network.attested.payment.status`, which auto-fills private fields when the caller is a signing party. */
+declare const main: l.Query<"network.attested.verify", l.ParamsSchema<{
+    readonly uri: l.StringSchema<{
+        readonly format: "at-uri";
+    }>;
+}>, l.Payload<"application/json", l.ObjectSchema<{
+    uri: l.StringSchema<{
+        readonly format: "at-uri";
+    }>;
+    cid: l.OptionalSchema<l.StringSchema<{
+        readonly format: "cid";
+    }>>;
+    valid: l.BooleanSchema;
+    signatures: l.ArraySchema<l.TypedUnionSchema<readonly [l.TypedRefSchema<l.TypedObjectValidator<AttestedSignature.Main, AttestedSignature.Main>>, l.TypedRefSchema<l.TypedObjectValidator<RepoStrongRef.Main, RepoStrongRef.Main>>], false>>;
+    workflow: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoActions.OutboundWorkflow, AtiprotoActions.OutboundWorkflow>>>;
+}>>, undefined>;
+export { main };
+export type $Params = l.InferMethodParams<typeof main>;
+export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>;
+export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>;
+export declare const $lxm: "network.attested.verify", $params: l.ParamsSchema<{
+    readonly uri: l.StringSchema<{
+        readonly format: "at-uri";
+    }>;
+}>, $output: l.Payload<"application/json", l.ObjectSchema<{
+    uri: l.StringSchema<{
+        readonly format: "at-uri";
+    }>;
+    cid: l.OptionalSchema<l.StringSchema<{
+        readonly format: "cid";
+    }>>;
+    valid: l.BooleanSchema;
+    signatures: l.ArraySchema<l.TypedUnionSchema<readonly [l.TypedRefSchema<l.TypedObjectValidator<AttestedSignature.Main, AttestedSignature.Main>>, l.TypedRefSchema<l.TypedObjectValidator<RepoStrongRef.Main, RepoStrongRef.Main>>], false>>;
+    workflow: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoActions.OutboundWorkflow, AtiprotoActions.OutboundWorkflow>>>;
+}>>;

package/dist/lexicons/network/attested.d.ts

@@ -0,0 +1,5 @@
+export * as entitlement from './attested/entitlement.js';
+export * as payment from './attested/payment.js';
+export * as proof from './attested/proof.js';
+export * as signature from './attested/signature.js';
+export * as verify from './attested/verify.js';

package/dist/lexicons/network.d.ts

@@ -0,0 +1 @@
+export * as attested from './network/attested.js';

package/dist/schemas.d.ts

@@ -1,2 +1,4 @@
 import type { LexiconDoc } from "@atproto/lexicon";
 export declare const schemas: LexiconDoc[];
+export declare const associatedSchemas: LexiconDoc[];
+export declare const allSchemas: LexiconDoc[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atiproto/lexicons",
-  "version": "1.1.0",
+  "version": "2.0.0-beta.1",
   "description": "ATProto lexicon types and utilities",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -17,7 +17,7 @@
     "dist"
   ],
   "scripts": {
-    "build:lexicons": "lex build --lexicons ./src/schemas --out ./src/lexicons --clear --indexFile",
+    "build:lexicons": "node ./scripts/build-lexicons.mjs",
     "build": "npm run build:lexicons && tsup && tsc --emitDeclarationOnly --declaration --composite false --incremental false",
     "prepack": "npm run build",
     "test": "echo \"No tests yet\" && exit 0"
@@ -30,6 +30,10 @@
   "homepage": "https://atiproto.com/docs/lexicon",
   "bugs": "https://github.com/Yakrware/atiproto/issues",
   "license": "MIT",
+  "publishConfig": {
+    "tag": "beta",
+    "access": "public"
+  },
   "dependencies": {
     "@atproto/lex": "^0.0.23"
   },

package/dist/lexicons/com/atiproto/payment/cart/clone.d.ts

@@ -1,2 +0,0 @@
-export * from './clone.defs.js';
-export * as $defs from './clone.defs.js';

package/dist/lexicons/com/atiproto/payment/cart/clone.defs.d.ts

@@ -1,54 +0,0 @@
-import { l } from '@atproto/lex';
-import * as AtiprotoActions from '../../actions.defs.js';
-import * as AtiprotoCart from '../../cart.defs.js';
-import * as AtiprotoItem from '../../item.defs.js';
-import * as AtiprotoSubscription from '../../subscription.defs.js';
-declare const $nsid = "com.atiproto.payment.cart.clone";
-export { $nsid };
-/** Clone an existing cart, creating new item and subscription records. Useful for reopening expired carts or repeating payments. */
-declare const main: l.Procedure<"com.atiproto.payment.cart.clone", l.ParamsSchema<{}>, l.Payload<"application/json", l.ObjectSchema<{
-    uri: l.StringSchema<{
-        readonly format: "at-uri";
-    }>;
-    redirectUrl: l.OptionalSchema<l.StringSchema<{
-        readonly format: "uri";
-    }>>;
-    workflow: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoActions.InboundWorkflow, AtiprotoActions.InboundWorkflow>>>;
-}>>, l.Payload<"application/json", l.ObjectSchema<{
-    workflow: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoActions.OutboundWorkflow, AtiprotoActions.OutboundWorkflow>>>;
-    cart: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoCart.View, AtiprotoCart.View>>>;
-    cartUri: l.OptionalSchema<l.StringSchema<{
-        readonly format: "at-uri";
-    }>>;
-    checkoutUrl: l.OptionalSchema<l.StringSchema<{
-        readonly format: "uri";
-    }>>;
-    items: l.OptionalSchema<l.ArraySchema<l.RefSchema<l.Validator<AtiprotoItem.View, AtiprotoItem.View>>>>;
-    subscriptions: l.OptionalSchema<l.ArraySchema<l.RefSchema<l.Validator<AtiprotoSubscription.View, AtiprotoSubscription.View>>>>;
-}>>, undefined>;
-export { main };
-export type $Params = l.InferMethodParams<typeof main>;
-export type $Input<B = l.BinaryData> = l.InferMethodInput<typeof main, B>;
-export type $InputBody<B = l.BinaryData> = l.InferMethodInputBody<typeof main, B>;
-export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>;
-export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>;
-export declare const $lxm: "com.atiproto.payment.cart.clone", $params: l.ParamsSchema<{}>, $input: l.Payload<"application/json", l.ObjectSchema<{
-    uri: l.StringSchema<{
-        readonly format: "at-uri";
-    }>;
-    redirectUrl: l.OptionalSchema<l.StringSchema<{
-        readonly format: "uri";
-    }>>;
-    workflow: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoActions.InboundWorkflow, AtiprotoActions.InboundWorkflow>>>;
-}>>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    workflow: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoActions.OutboundWorkflow, AtiprotoActions.OutboundWorkflow>>>;
-    cart: l.OptionalSchema<l.RefSchema<l.Validator<AtiprotoCart.View, AtiprotoCart.View>>>;
-    cartUri: l.OptionalSchema<l.StringSchema<{
-        readonly format: "at-uri";
-    }>>;
-    checkoutUrl: l.OptionalSchema<l.StringSchema<{
-        readonly format: "uri";
-    }>>;
-    items: l.OptionalSchema<l.ArraySchema<l.RefSchema<l.Validator<AtiprotoItem.View, AtiprotoItem.View>>>>;
-    subscriptions: l.OptionalSchema<l.ArraySchema<l.RefSchema<l.Validator<AtiprotoSubscription.View, AtiprotoSubscription.View>>>>;
-}>>;

package/dist/lexicons/com/atiproto/payment/item/validate.d.ts

@@ -1,2 +0,0 @@
-export * from './validate.defs.js';
-export * as $defs from './validate.defs.js';

package/dist/lexicons/com/atiproto/payment/item/validate.defs.d.ts

@@ -1,50 +0,0 @@
-import { l } from '@atproto/lex';
-declare const $nsid = "com.atiproto.payment.item.validate";
-export { $nsid };
-/** Validate that the authenticated user (as the sender) has completed item payment(s). Looks up by itemUri (a specific item record), recordUri (sums all items for that record), or subject (recipient DID). These are mutually exclusive and resolved in that order. */
-declare const main: l.Query<"com.atiproto.payment.item.validate", l.ParamsSchema<{
-    readonly itemUri: l.OptionalSchema<l.StringSchema<{
-        readonly format: "at-uri";
-    }>>;
-    readonly recordUri: l.OptionalSchema<l.StringSchema<{
-        readonly format: "at-uri";
-    }>>;
-    readonly subject: l.OptionalSchema<l.StringSchema<{
-        readonly format: "did";
-    }>>;
-    readonly amount: l.OptionalSchema<l.IntegerSchema>;
-}>, l.Payload<"application/json", l.ObjectSchema<{
-    valid: l.BooleanSchema;
-    amount: l.OptionalSchema<l.IntegerSchema>;
-    currency: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 3;
-    }>>;
-    reason: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 1024;
-    }>>;
-}>>, undefined>;
-export { main };
-export type $Params = l.InferMethodParams<typeof main>;
-export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>;
-export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>;
-export declare const $lxm: "com.atiproto.payment.item.validate", $params: l.ParamsSchema<{
-    readonly itemUri: l.OptionalSchema<l.StringSchema<{
-        readonly format: "at-uri";
-    }>>;
-    readonly recordUri: l.OptionalSchema<l.StringSchema<{
-        readonly format: "at-uri";
-    }>>;
-    readonly subject: l.OptionalSchema<l.StringSchema<{
-        readonly format: "did";
-    }>>;
-    readonly amount: l.OptionalSchema<l.IntegerSchema>;
-}>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    valid: l.BooleanSchema;
-    amount: l.OptionalSchema<l.IntegerSchema>;
-    currency: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 3;
-    }>>;
-    reason: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 1024;
-    }>>;
-}>>;

package/dist/lexicons/com/atiproto/payment/list.d.ts

@@ -1,2 +0,0 @@
-export * from './list.defs.js';
-export * as $defs from './list.defs.js';

package/dist/lexicons/com/atiproto/payment/list.defs.d.ts

@@ -1,32 +0,0 @@
-import { l } from '@atproto/lex';
-import * as AtiprotoItem from '../item.defs.js';
-import * as AtiprotoSubscription from '../subscription.defs.js';
-declare const $nsid = "com.atiproto.payment.list";
-export { $nsid };
-/** List items and subscriptions for the authenticated user. Always returns items given by the user and subscriptions the user has created. */
-declare const main: l.Query<"com.atiproto.payment.list", l.ParamsSchema<{
-    readonly cursor: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 512;
-    }>>;
-    readonly limit: l.OptionalSchema<l.WithDefaultSchema<l.IntegerSchema>>;
-}>, l.Payload<"application/json", l.ObjectSchema<{
-    items: l.ArraySchema<l.TypedUnionSchema<readonly [l.TypedRefSchema<l.TypedObjectValidator<AtiprotoItem.View, AtiprotoItem.View>>, l.TypedRefSchema<l.TypedObjectValidator<AtiprotoSubscription.View, AtiprotoSubscription.View>>], false>>;
-    cursor: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 512;
-    }>>;
-}>>, undefined>;
-export { main };
-export type $Params = l.InferMethodParams<typeof main>;
-export type $Output<B = l.BinaryData> = l.InferMethodOutput<typeof main, B>;
-export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<typeof main, B>;
-export declare const $lxm: "com.atiproto.payment.list", $params: l.ParamsSchema<{
-    readonly cursor: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 512;
-    }>>;
-    readonly limit: l.OptionalSchema<l.WithDefaultSchema<l.IntegerSchema>>;
-}>, $output: l.Payload<"application/json", l.ObjectSchema<{
-    items: l.ArraySchema<l.TypedUnionSchema<readonly [l.TypedRefSchema<l.TypedObjectValidator<AtiprotoItem.View, AtiprotoItem.View>>, l.TypedRefSchema<l.TypedObjectValidator<AtiprotoSubscription.View, AtiprotoSubscription.View>>], false>>;
-    cursor: l.OptionalSchema<l.StringSchema<{
-        readonly maxLength: 512;
-    }>>;
-}>>;

package/dist/lexicons/com/atiproto/payment/subscription/validate.d.ts

@@ -1,2 +0,0 @@
-export * from './validate.defs.js';
-export * as $defs from './validate.defs.js';