@atiproto/lexicons 1.1.0 → 2.0.0-beta.1

package/dist/lexicons/com/atiproto/repo/profile/get.defs.d.ts

@@ -12,6 +12,9 @@ declare const main: l.Query<"com.atiproto.repo.profile.get", l.ParamsSchema<{
         readonly format: "did";
     }>;
     profile: l.RefSchema<l.Validator<AtiprotoProfile.View, AtiprotoProfile.View>>;
+    brokers: l.OptionalSchema<l.ArraySchema<l.StringSchema<{
+        readonly format: "did";
+    }>>>;
 }>>, undefined>;
 export { main };
 export type $Params = l.InferMethodParams<typeof main>;
@@ -26,4 +29,7 @@ export declare const $lxm: "com.atiproto.repo.profile.get", $params: l.ParamsSch
         readonly format: "did";
     }>;
     profile: l.RefSchema<l.Validator<AtiprotoProfile.View, AtiprotoProfile.View>>;
+    brokers: l.OptionalSchema<l.ArraySchema<l.StringSchema<{
+        readonly format: "did";
+    }>>>;
 }>>;

package/dist/lexicons/com/atiproto/repo/subscription/count.defs.d.ts

@@ -1,10 +1,10 @@
 import { l } from '@atproto/lex';
 declare const $nsid = "com.atiproto.repo.subscription.count";
 export { $nsid };
-/** Count active subscriptions. If subject is provided, counts subscriptions received by that DID. If omitted, counts subscriptions the authenticated user has active (as the subscriber). Optionally filtered by a start/end datetime window (matching billingStartDate). When the authenticated user is the subject/owner of the target, the response also includes the sum of amounts. */
+/** Count active subscriptions. When `record` is provided, counts subscriptions targeting that at-uri (either a specific record or, when the at-uri is repo-level like `at://did:plc:...`, all subscriptions the named user receives). When omitted, counts subscriptions the authenticated user has active as the subscriber. Optionally filtered by a start/end datetime window (matching `billingStartDate`). When the authenticated caller is the subject/owner of the target (or counting their own active subscriptions), the response also includes the sum of amounts. */
 declare const main: l.Query<"com.atiproto.repo.subscription.count", l.ParamsSchema<{
-    readonly subject: l.OptionalSchema<l.StringSchema<{
-        readonly format: "did";
+    readonly record: l.OptionalSchema<l.StringSchema<{
+        readonly format: "at-uri";
     }>>;
     readonly startDate: l.OptionalSchema<l.StringSchema<{
         readonly format: "datetime";
@@ -24,8 +24,8 @@ 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.repo.subscription.count", $params: l.ParamsSchema<{
-    readonly subject: l.OptionalSchema<l.StringSchema<{
-        readonly format: "did";
+    readonly record: l.OptionalSchema<l.StringSchema<{
+        readonly format: "at-uri";
     }>>;
     readonly startDate: l.OptionalSchema<l.StringSchema<{
         readonly format: "datetime";

package/dist/lexicons/com/atiproto/subscription.defs.d.ts

@@ -1,296 +1,229 @@
 import { l } from '@atproto/lex';
+import * as RepoStrongRef from '../atproto/repo/strongRef.defs.js';
+import * as PaymentInitiate from '../../network/attested/payment/initiate.defs.js';
+import * as AttestedSignature from '../../network/attested/signature.defs.js';
 declare const $nsid = "com.atiproto.subscription";
 export { $nsid };
-/** A record representing a subscription from one user to another */
 type Main = {
     $type: 'com.atiproto.subscription';
     /**
-     * DID of the user being subscribed to
+     * Reference to the entity being subscribed to. Either a `com.atproto.repo.strongRef` (a specific record, e.g. a paid feed) or a `#userRef` (a thin wrapper carrying a did string for the user being subscribed to). Absent when marked as private.
      */
-    subject: l.DidString;
+    subject?: l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject;
     /**
-     * Subscription amount in cents (0 for free subscriptions)
+     * Per-period subscription amount in the smallest unit of the cart's `currency` (0 for free).
      */
     amount: number;
     /**
-     * ISO 4217 currency code
+     * Billing cadence. Mirrors `network.attested.payment.initiate#interval`: either `network.attested.payment.initiate#namedInterval` (weekly / monthly / yearly) or `network.attested.payment.initiate#customInterval` (`{ days: integer >= 1 }`).
      */
-    currency: string;
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     /**
-     * Billing interval
+     * Subscription lifecycle state. Open to extension via `knownValues`; PoS continues to interpret these values for subscription-specific flows (renewal, dunning, etc.).
      */
-    interval: 'monthly' | 'yearly';
+    status: 'pending' | 'active' | 'past_due' | 'cancelled' | 'expired' | l.UnknownString;
     /**
-     * Subscription status
-     */
-    status: 'pending' | 'active' | 'past_due' | 'cancelled' | 'expired';
-    /**
-     * First billing period, can be used to determine recurrence
+     * First billing period; can be used to derive recurrence.
      */
     billingStartDate: l.DatetimeString;
-    /**
-     * Cancellation timestamp
-     */
     cancelledAt?: l.DatetimeString;
     /**
-     * Date until which the subscriber retains access after cancellation
+     * Date until which the subscriber retains access after cancellation.
      */
     accessUntil?: l.DatetimeString;
+    createdAt: l.DatetimeString;
     /**
-     * Creation timestamp
+     * PoS + recipient AppView attestations. 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 `amount`, `interval`, `status`, `billingStartDate`, `createdAt`, plus `subject`, `cancelledAt`, and `accessUntil` when present. Mutating any of those fields invalidates every signature in this array.
      */
-    createdAt: l.DatetimeString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
 };
 export type { Main };
-/** A record representing a subscription from one user to another */
 declare const main: l.RecordSchema<"any", "com.atiproto.subscription", l.Validator<Omit<Main, "$type">, Omit<Main, "$type">>>;
 export { main };
 export declare const $isTypeOf: <TValue extends {
     $type?: unknown;
 }>(value: TValue) => value is l.TypedRecord<"com.atiproto.subscription", TValue>, $build: {
     (input: Omit<Omit<Main, "$type">, "$type">): {
-        currency: string;
-        status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+        subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+        status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
         createdAt: l.DatetimeString;
-        subject: l.DidString;
+        signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
         amount: number;
-        interval: "monthly" | "yearly";
+        interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
         billingStartDate: l.DatetimeString;
         cancelledAt?: l.DatetimeString
         /**
-         * Date until which the subscriber retains access after cancellation
-         */
-         | undefined;
-        accessUntil?: l.DatetimeString
-        /**
-         * Creation timestamp
+         * Date until which the subscriber retains access after cancellation.
          */
          | undefined;
+        accessUntil?: l.DatetimeString | undefined;
         $type: "com.atiproto.subscription";
     };
     (input: Omit<Omit<Main, "$type">, "$type">): {
-        currency: string;
-        status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+        subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+        status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
         createdAt: l.DatetimeString;
-        subject: l.DidString;
+        signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
         amount: number;
-        interval: "monthly" | "yearly";
+        interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
         billingStartDate: l.DatetimeString;
         cancelledAt?: l.DatetimeString
         /**
-         * Date until which the subscriber retains access after cancellation
-         */
-         | undefined;
-        accessUntil?: l.DatetimeString
-        /**
-         * Creation timestamp
+         * Date until which the subscriber retains access after cancellation.
          */
          | undefined;
+        accessUntil?: l.DatetimeString | undefined;
         $type: "com.atiproto.subscription";
     };
 }, $type: "com.atiproto.subscription";
 export declare const $assert: (input: unknown, options?: l.ValidateOptions) => asserts input is {
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }, $check: (input: unknown, options?: l.ValidateOptions) => void, $cast: <I>(input: I, options?: l.ValidateOptions) => I & {
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }, $ifMatches: <I>(input: I, options?: l.ValidateOptions) => (I & {
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }) | undefined, $matches: <I>(input: I, options?: l.ValidateOptions) => input is I & {
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }, $parse: (input: unknown, options?: l.ParseOptions) => {
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }, $safeParse: (input: unknown, options?: l.ParseOptions) => l.ValidationResult<{
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }>, $validate: <I>(input: I, options?: l.ValidateOptions) => I & {
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }, $safeValidate: <I>(input: I, options?: l.ValidateOptions) => l.ValidationResult<I & {
-    currency: string;
-    status: "pending" | "active" | "past_due" | "cancelled" | "expired";
+    subject?: (l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject) | undefined;
+    status: "pending" | "active" | "past_due" | "cancelled" | "expired" | l.UnknownString;
     createdAt: l.DatetimeString;
-    subject: l.DidString;
+    signatures: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
     amount: number;
-    interval: "monthly" | "yearly";
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
     billingStartDate: l.DatetimeString;
     cancelledAt?: l.DatetimeString
     /**
-     * Date until which the subscriber retains access after cancellation
-     */
-     | undefined;
-    accessUntil?: l.DatetimeString
-    /**
-     * Creation timestamp
+     * Date until which the subscriber retains access after cancellation.
      */
      | undefined;
+    accessUntil?: l.DatetimeString | undefined;
     $type: "com.atiproto.subscription";
 }>;
-/** View of a subscription record for use in API responses */
 type View = {
     $type?: 'com.atiproto.subscription#view';
-    /**
-     * AT-URI of the subscription record
-     */
     uri: l.AtUriString;
-    /**
-     * DID of the user being subscribed to
-     */
-    subject?: l.DidString;
-    /**
-     * Subscription amount in cents (0 for free subscriptions)
-     */
+    cid?: l.CidString;
+    subject?: l.$Typed<RepoStrongRef.Main> | l.$Typed<UserRef> | l.Unknown$TypedObject;
     amount: number;
-    /**
-     * ISO 4217 currency code
-     */
-    currency: string;
-    /**
-     * Billing interval
-     */
-    interval: 'monthly' | 'yearly';
-    /**
-     * Subscription status
-     */
-    status: 'pending' | 'active' | 'past_due' | 'cancelled' | 'expired';
-    /**
-     * First billing period, can be used to determine recurrence
-     */
+    interval: l.$Typed<PaymentInitiate.NamedInterval> | l.$Typed<PaymentInitiate.CustomInterval> | l.Unknown$TypedObject;
+    status: 'pending' | 'active' | 'past_due' | 'cancelled' | 'expired' | l.UnknownString;
     billingStartDate: l.DatetimeString;
     /**
-     * Next scheduled renewal/billing date. Server-derived from the billing schedule; not stored in PDS. Omitted when not applicable (e.g. cancelled or unauthenticated views).
+     * Next scheduled renewal/billing date. Server-derived from the billing schedule; not stored on the record.
      */
     renewalDate?: l.DatetimeString;
-    /**
-     * Cancellation timestamp
-     */
     cancelledAt?: l.DatetimeString;
-    /**
-     * Date until which the subscriber retains access after cancellation
-     */
     accessUntil?: l.DatetimeString;
-    /**
-     * Creation timestamp
-     */
     createdAt: l.DatetimeString;
+    signatures?: (l.$Typed<AttestedSignature.Main> | l.$Typed<RepoStrongRef.Main> | l.Unknown$TypedObject)[];
 };
 export type { View };
-/** View of a subscription record for use in API responses */
 declare const view: l.TypedObjectSchema<"com.atiproto.subscription#view", l.Validator<View, View>>;
 export { view };
+/** Thin wrapper that carries a bare did string for the user being subscribed to. The wire shape is `{ "$type": "com.atiproto.subscription#userRef", "did": "did:plc:..." }`; pair with `com.atproto.repo.strongRef` in a `subject` union to express either-or. */
+type UserRef = {
+    $type?: 'com.atiproto.subscription#userRef';
+    did: l.DidString;
+};
+export type { UserRef };
+/** Thin wrapper that carries a bare did string for the user being subscribed to. The wire shape is `{ "$type": "com.atiproto.subscription#userRef", "did": "did:plc:..." }`; pair with `com.atproto.repo.strongRef` in a `subject` union to express either-or. */
+declare const userRef: l.TypedObjectSchema<"com.atiproto.subscription#userRef", l.Validator<UserRef, UserRef>>;
+export { userRef };

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

@@ -1,6 +1,12 @@
 export * as actions from './atiproto/actions.js';
-export * as authEnhanced from './atiproto/authEnhanced.js';
-export * as authGeneral from './atiproto/authGeneral.js';
+export * as authCreateCart from './atiproto/authCreateCart.js';
+export * as authCreatePayment from './atiproto/authCreatePayment.js';
+export * as authReadCart from './atiproto/authReadCart.js';
+export * as authReadEntitlements from './atiproto/authReadEntitlements.js';
+export * as authReadPayments from './atiproto/authReadPayments.js';
+export * as authReadPublic from './atiproto/authReadPublic.js';
+export * as authReadRecipient from './atiproto/authReadRecipient.js';
+export * as authWriteProfile from './atiproto/authWriteProfile.js';
 export * as cart from './atiproto/cart.js';
 export * as item from './atiproto/item.js';
 export * as payment from './atiproto/payment.js';

package/dist/lexicons/com/atproto/repo/strongRef.d.ts

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

package/dist/lexicons/com/atproto/repo/strongRef.defs.d.ts

@@ -0,0 +1,56 @@
+import { l } from '@atproto/lex';
+declare const $nsid = "com.atproto.repo.strongRef";
+export { $nsid };
+type Main = {
+    $type?: 'com.atproto.repo.strongRef';
+    cid: l.CidString;
+    uri: l.AtUriString;
+};
+export type { Main };
+declare const main: l.TypedObjectSchema<"com.atproto.repo.strongRef", l.Validator<Main, Main>>;
+export { main };
+export declare const $isTypeOf: <TValue extends Record<string, unknown>>(value: TValue) => value is l.MaybeTypedObject<"com.atproto.repo.strongRef", TValue>, $build: {
+    (input: Omit<Main, "$type">): {
+        $type: "com.atproto.repo.strongRef";
+        cid: l.CidString;
+        uri: l.AtUriString;
+    };
+    (input: Omit<Main, "$type">): {
+        $type: "com.atproto.repo.strongRef";
+        cid: l.CidString;
+        uri: l.AtUriString;
+    };
+}, $type: "com.atproto.repo.strongRef";
+export declare const $assert: (input: unknown, options?: l.ValidateOptions) => asserts input is {
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}, $check: (input: unknown, options?: l.ValidateOptions) => void, $cast: <I>(input: I, options?: l.ValidateOptions) => I & {
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}, $ifMatches: <I>(input: I, options?: l.ValidateOptions) => (I & {
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}) | undefined, $matches: <I>(input: I, options?: l.ValidateOptions) => input is I & {
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}, $parse: (input: unknown, options?: l.ParseOptions) => {
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}, $safeParse: (input: unknown, options?: l.ParseOptions) => l.ValidationResult<{
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}>, $validate: <I>(input: I, options?: l.ValidateOptions) => I & {
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}, $safeValidate: <I>(input: I, options?: l.ValidateOptions) => l.ValidationResult<I & {
+    $type?: "com.atproto.repo.strongRef" | undefined;
+    cid: l.CidString;
+    uri: l.AtUriString;
+}>;

package/dist/lexicons/com/atproto/repo.d.ts

@@ -0,0 +1 @@
+export * as strongRef from './repo/strongRef.js';

package/dist/lexicons/com/atproto.d.ts

@@ -0,0 +1 @@
+export * as repo from './atproto/repo.js';

package/dist/lexicons/com.d.ts

@@ -1 +1,2 @@
 export * as atiproto from './com/atiproto.js';
+export * as atproto from './com/atproto.js';

package/dist/lexicons/index.d.ts

@@ -1 +1,2 @@
 export * as com from './com.js';
+export * as network from './network.js';

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

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