@atiproto/lexicons 1.1.0 → 2.0.0-beta.1

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

@@ -0,0 +1,185 @@
+import { l } from '@atproto/lex';
+import * as RepoStrongRef from '../../com/atproto/repo/strongRef.defs.js';
+import * as AttestedSignature from './signature.defs.js';
+declare const $nsid = "network.attested.entitlement";
+export { $nsid };
+type Main = {
+    $type: 'network.attested.entitlement';
+    /**
+     * DID of the entitled party. Absent (null) when marked as private.
+     */
+    subject?: l.DidString;
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+    entitlements?: RepoStrongRef.Main[];
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+    payment: RepoStrongRef.Main;
+    createdAt: l.DatetimeString;
+    /**
+     * PoS attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `payment`, `createdAt`, plus `subject` and `entitlements` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+};
+export type { Main };
+declare const main: l.RecordSchema<"any", "network.attested.entitlement", 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.entitlement", TValue>, $build: {
+    (input: Omit<Omit<Main, "$type">, "$type">): {
+        subject?: l.DidString
+        /**
+         * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+         */
+         | undefined;
+        createdAt: l.DatetimeString;
+        payment: RepoStrongRef.Main;
+        signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+        entitlements?: RepoStrongRef.Main[]
+        /**
+         * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+         */
+         | undefined;
+        $type: "network.attested.entitlement";
+    };
+    (input: Omit<Omit<Main, "$type">, "$type">): {
+        subject?: l.DidString
+        /**
+         * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+         */
+         | undefined;
+        createdAt: l.DatetimeString;
+        payment: RepoStrongRef.Main;
+        signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+        entitlements?: RepoStrongRef.Main[]
+        /**
+         * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+         */
+         | undefined;
+        $type: "network.attested.entitlement";
+    };
+}, $type: "network.attested.entitlement";
+export declare const $assert: (input: unknown, options?: l.ValidateOptions) => asserts input is {
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}, $check: (input: unknown, options?: l.ValidateOptions) => void, $cast: <I>(input: I, options?: l.ValidateOptions) => I & {
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}, $ifMatches: <I>(input: I, options?: l.ValidateOptions) => (I & {
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}) | undefined, $matches: <I>(input: I, options?: l.ValidateOptions) => input is I & {
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}, $parse: (input: unknown, options?: l.ParseOptions) => {
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}, $safeParse: (input: unknown, options?: l.ParseOptions) => l.ValidationResult<{
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}>, $validate: <I>(input: I, options?: l.ValidateOptions) => I & {
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}, $safeValidate: <I>(input: I, options?: l.ValidateOptions) => l.ValidationResult<I & {
+    subject?: l.DidString
+    /**
+     * Strong references to the records the subject is entitled to. Lexicon-agnostic: refs may point at any record type. Empty (or absent) when marked as private.
+     */
+     | undefined;
+    createdAt: l.DatetimeString;
+    payment: RepoStrongRef.Main;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    entitlements?: RepoStrongRef.Main[]
+    /**
+     * StrongRef to the `network.attested.payment` record that justified this entitlement. Entitlements reference payments; payments do not reference carts or entitlements back.
+     */
+     | undefined;
+    $type: "network.attested.entitlement";
+}>;

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

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

package/dist/lexicons/network/attested/payment/initiate.defs.d.ts

@@ -0,0 +1,102 @@
+import { l } from '@atproto/lex';
+import * as RepoStrongRef from '../../../com/atproto/repo/strongRef.defs.js';
+declare const $nsid = "network.attested.payment.initiate";
+export { $nsid };
+/** Broker-side checkout procedure. Creates a pending `network.attested.payment` record signed by the broker and returns a checkout URL plus a strongRef to the payment. Line item details are retained internally by the broker; they do not appear on the resulting record. */
+declare const main: l.Procedure<"network.attested.payment.initiate", l.ParamsSchema<{}>, l.Payload<"application/json", l.ObjectSchema<{
+    subject: l.StringSchema<{
+        readonly format: "did";
+    }>;
+    items: l.ArraySchema<l.TypedUnionSchema<readonly [l.TypedRefSchema<l.TypedObjectValidator<OneTime, OneTime>>, l.TypedRefSchema<l.TypedObjectValidator<Recurring, Recurring>>], false>>;
+    redirectUrl: l.OptionalSchema<l.StringSchema<{
+        readonly format: "uri";
+    }>>;
+}>>, l.Payload<"application/json", l.ObjectSchema<{
+    payment: l.RefSchema<l.Validator<RepoStrongRef.Main, RepoStrongRef.Main>>;
+    checkoutUrl: l.StringSchema<{
+        readonly format: "uri";
+    }>;
+}>>, 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: "network.attested.payment.initiate", $params: l.ParamsSchema<{}>, $input: l.Payload<"application/json", l.ObjectSchema<{
+    subject: l.StringSchema<{
+        readonly format: "did";
+    }>;
+    items: l.ArraySchema<l.TypedUnionSchema<readonly [l.TypedRefSchema<l.TypedObjectValidator<OneTime, OneTime>>, l.TypedRefSchema<l.TypedObjectValidator<Recurring, Recurring>>], false>>;
+    redirectUrl: l.OptionalSchema<l.StringSchema<{
+        readonly format: "uri";
+    }>>;
+}>>, $output: l.Payload<"application/json", l.ObjectSchema<{
+    payment: l.RefSchema<l.Validator<RepoStrongRef.Main, RepoStrongRef.Main>>;
+    checkoutUrl: l.StringSchema<{
+        readonly format: "uri";
+    }>;
+}>>;
+/** A one-time line item. */
+type OneTime = {
+    $type?: 'network.attested.payment.initiate#oneTime';
+    description: string;
+    /**
+     * Line total in the smallest unit of `currency` (PoS-side quantity is already multiplied in).
+     */
+    amount: number;
+    /**
+     * ISO 4217 currency code.
+     */
+    currency: string;
+};
+export type { OneTime };
+/** A one-time line item. */
+declare const oneTime: l.TypedObjectSchema<"network.attested.payment.initiate#oneTime", l.Validator<OneTime, OneTime>>;
+export { oneTime };
+/** A recurring line item billed at a fixed interval. */
+type Recurring = {
+    $type?: 'network.attested.payment.initiate#recurring';
+    description: string;
+    /**
+     * Per-period amount in the smallest unit of `currency`.
+     */
+    amount: number;
+    /**
+     * ISO 4217 currency code.
+     */
+    currency: string;
+    /**
+     * Billing cadence. Discriminated by `$type`: `#namedInterval` for the common cases (weekly / monthly / yearly), `#customInterval` for a custom number of days.
+     */
+    interval: l.$Typed<NamedInterval> | l.$Typed<CustomInterval> | l.Unknown$TypedObject;
+    /**
+     * First billing period.
+     */
+    billingStartDate?: l.DatetimeString;
+};
+export type { Recurring };
+/** A recurring line item billed at a fixed interval. */
+declare const recurring: l.TypedObjectSchema<"network.attested.payment.initiate#recurring", l.Validator<Recurring, Recurring>>;
+export { recurring };
+/** One of the well-known billing cadences. */
+type NamedInterval = {
+    $type?: 'network.attested.payment.initiate#namedInterval';
+    value: 'weekly' | 'monthly' | 'yearly';
+};
+export type { NamedInterval };
+/** One of the well-known billing cadences. */
+declare const namedInterval: l.TypedObjectSchema<"network.attested.payment.initiate#namedInterval", l.Validator<NamedInterval, NamedInterval>>;
+export { namedInterval };
+/** An arbitrary number-of-days interval. Lets callers set non-standard cadences (every 14 days, every 90 days, etc.). */
+type CustomInterval = {
+    $type?: 'network.attested.payment.initiate#customInterval';
+    /**
+     * Length of one billing period in days.
+     */
+    days: number;
+};
+export type { CustomInterval };
+/** An arbitrary number-of-days interval. Lets callers set non-standard cadences (every 14 days, every 90 days, etc.). */
+declare const customInterval: l.TypedObjectSchema<"network.attested.payment.initiate#customInterval", l.Validator<CustomInterval, CustomInterval>>;
+export { customInterval };

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

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

package/dist/lexicons/network/attested/payment/status.defs.d.ts

@@ -0,0 +1,56 @@
+import { l } from '@atproto/lex';
+import * as PaymentInitiate from './initiate.defs.js';
+import * as AttestedSignature from '../signature.defs.js';
+import * as RepoStrongRef from '../../../com/atproto/repo/strongRef.defs.js';
+declare const $nsid = "network.attested.payment.status";
+export { $nsid };
+/** Look up a `network.attested.payment` record by uri. Returns a `#view`: status, broker, timestamps, and signatures are always present; private fields (`subject`, `items`, `total`, `currency`) are auto-filled by the broker only when the caller is one of the signing parties. */
+declare const main: l.Query<"network.attested.payment.status", l.ParamsSchema<{
+    readonly uri: l.StringSchema<{
+        readonly format: "at-uri";
+    }>;
+}>, l.Payload<"application/json", l.ObjectSchema<{
+    payment: l.RefSchema<l.Validator<View, View>>;
+}>>, 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.payment.status", $params: l.ParamsSchema<{
+    readonly uri: l.StringSchema<{
+        readonly format: "at-uri";
+    }>;
+}>, $output: l.Payload<"application/json", l.ObjectSchema<{
+    payment: l.RefSchema<l.Validator<View, View>>;
+}>>;
+/** Hydrated view of a `network.attested.payment` record. Shape mirrors the `network.attested.payment.initiate` input plus `total`, the record's uri/cid, and signatures. Private fields (`subject`, `items`, `total`, `currency`) are auto-filled by the broker only when the caller is one of the signing parties; for other callers, the view degrades to the record's public surface. */
+type View = {
+    $type?: 'network.attested.payment.status#view';
+    uri: l.AtUriString;
+    cid?: l.CidString;
+    /**
+     * DID of the payment recipient. Auto-filled when the caller is authorized; absent otherwise.
+     */
+    subject?: l.DidString;
+    /**
+     * Line items as supplied to `initiate`. Auto-filled when the caller is authorized; absent otherwise.
+     */
+    items?: (l.$Typed<PaymentInitiate.OneTime> | l.$Typed<PaymentInitiate.Recurring> | l.Unknown$TypedObject)[];
+    /**
+     * Sum of line item amounts in the smallest currency unit. Auto-filled when the caller is authorized; absent otherwise.
+     */
+    total?: number;
+    /**
+     * ISO 4217 currency code of `total`. Auto-filled when the caller is authorized; absent otherwise.
+     */
+    currency?: string;
+    status: 'pending' | 'completed' | 'failed' | 'refunded' | 'cancelled' | l.UnknownString;
+    broker: l.DidString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+};
+export type { View };
+/** Hydrated view of a `network.attested.payment` record. Shape mirrors the `network.attested.payment.initiate` input plus `total`, the record's uri/cid, and signatures. Private fields (`subject`, `items`, `total`, `currency`) are auto-filled by the broker only when the caller is one of the signing parties; for other callers, the view degrades to the record's public surface. */
+declare const view: l.TypedObjectSchema<"network.attested.payment.status#view", l.Validator<View, View>>;
+export { view };

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

@@ -0,0 +1,4 @@
+export * as initiate from './payment/initiate.js';
+export * as status from './payment/status.js';
+export * from './payment.defs.js';
+export * as $defs from './payment.defs.js';

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

@@ -0,0 +1,156 @@
+import { l } from '@atproto/lex';
+import * as AttestedSignature from './signature.defs.js';
+import * as RepoStrongRef from '../../com/atproto/repo/strongRef.defs.js';
+declare const $nsid = "network.attested.payment";
+export { $nsid };
+type Main = {
+    $type: 'network.attested.payment';
+    /**
+     * Optional DID of the payment recipient. Absent by default; Broker expected to retain the recipient information internally. Setting this on the record makes the recipient publicly visible.
+     */
+    subject?: l.DidString;
+    status: 'pending' | 'completed' | 'failed' | 'refunded' | 'cancelled' | l.UnknownString;
+    /**
+     * DID of the broker that issued and is settling this payment.
+     */
+    broker: l.DidString;
+    createdAt: l.DatetimeString;
+    /**
+     * Set when `status === completed`.
+     */
+    completedAt?: l.DatetimeString;
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+};
+export type { Main };
+declare const main: l.RecordSchema<"any", "network.attested.payment", 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.payment", TValue>, $build: {
+    (input: Omit<Omit<Main, "$type">, "$type">): {
+        broker: l.DidString;
+        subject?: l.DidString | undefined;
+        status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+        createdAt: l.DatetimeString;
+        completedAt?: l.DatetimeString
+        /**
+         * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+         */
+         | undefined;
+        signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+        $type: "network.attested.payment";
+    };
+    (input: Omit<Omit<Main, "$type">, "$type">): {
+        broker: l.DidString;
+        subject?: l.DidString | undefined;
+        status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+        createdAt: l.DatetimeString;
+        completedAt?: l.DatetimeString
+        /**
+         * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+         */
+         | undefined;
+        signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+        $type: "network.attested.payment";
+    };
+}, $type: "network.attested.payment";
+export declare const $assert: (input: unknown, options?: l.ValidateOptions) => asserts input is {
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}, $check: (input: unknown, options?: l.ValidateOptions) => void, $cast: <I>(input: I, options?: l.ValidateOptions) => I & {
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}, $ifMatches: <I>(input: I, options?: l.ValidateOptions) => (I & {
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}) | undefined, $matches: <I>(input: I, options?: l.ValidateOptions) => input is I & {
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}, $parse: (input: unknown, options?: l.ParseOptions) => {
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}, $safeParse: (input: unknown, options?: l.ParseOptions) => l.ValidationResult<{
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}>, $validate: <I>(input: I, options?: l.ValidateOptions) => I & {
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}, $safeValidate: <I>(input: I, options?: l.ValidateOptions) => l.ValidationResult<I & {
+    broker: l.DidString;
+    subject?: l.DidString | undefined;
+    status: "pending" | "completed" | "failed" | "refunded" | "cancelled" | l.UnknownString;
+    createdAt: l.DatetimeString;
+    completedAt?: l.DatetimeString
+    /**
+     * Broker attestation(s). Each entry is either an inline `network.attested.signature` or a `com.atproto.repo.strongRef` pointing at a remote `network.attested.proof` record. The canonical signing payload covers `status`, `broker`, `createdAt`, plus `subject` and `completedAt` when present. Mutating any of those fields invalidates every signature in this array.
+     */
+     | undefined;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
+    $type: "network.attested.payment";
+}>;

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

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