@hypercerts-org/lexicon 0.10.0-beta.0 → 0.10.0-beta.2

package/dist/generated/lexicons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicons.d.ts","sourceRoot":"","sources":["../../generated/lexicons.ts"],"names":[],"mappings":"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"}

package/dist/generated/types/app/certified/badge/award.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import { type $Typed } from '../../../../util';
+import type * as AppCertifiedBadgeDefinition from './definition.js';
+import type * as AppCertifiedDefs from '../defs.js';
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js';
+export interface Main {
+    $type: 'app.certified.badge.award';
+    badge: AppCertifiedBadgeDefinition.Main;
+    subject: $Typed<AppCertifiedDefs.Did> | $Typed<ComAtprotoRepoStrongRef.Main> | {
+        $type: string;
+    };
+    /** Optional statement explaining the reason for this badge award. */
+    note?: string;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "app.certified.badge.award", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=award.d.ts.map

package/dist/generated/types/app/certified/badge/award.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"award.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/app/certified/badge/award.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,2BAA2B,MAAM,iBAAiB,CAAA;AACnE,OAAO,KAAK,KAAK,gBAAgB,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AAMtF,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,2BAA2B,CAAA;IAClC,KAAK,EAAE,2BAA2B,CAAC,IAAI,CAAA;IACvC,OAAO,EACH,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAC5B,MAAM,CAAC,uBAAuB,CAAC,IAAI,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,wFAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/app/certified/badge/definition.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+import type * as AppCertifiedDefs from '../defs.js';
+export interface Main {
+    $type: 'app.certified.badge.definition';
+    /** Category of the badge (e.g. endorsement, participation, affiliation). */
+    badgeType: string;
+    /** Human-readable title of the badge. */
+    title: string;
+    /** Icon representing the badge, stored as a blob for compact visual display. */
+    icon: BlobRef;
+    /** Optional short statement describing what the badge represents. */
+    description?: string;
+    /** Optional allowlist of DIDs allowed to issue this badge. If omitted, anyone may issue it. */
+    allowedIssuers?: AppCertifiedDefs.Did[];
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "app.certified.badge.definition", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=definition.d.ts.map

package/dist/generated/types/app/certified/badge/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/app/certified/badge/definition.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAQjE,OAAO,KAAK,KAAK,gBAAgB,MAAM,YAAY,CAAA;AAMnD,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,gCAAgC,CAAA;IACvC,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAA;IACjB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAA;IACb,gFAAgF;IAChF,IAAI,EAAE,OAAO,CAAA;IACb,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+FAA+F;IAC/F,cAAc,CAAC,EAAE,gBAAgB,CAAC,GAAG,EAAE,CAAA;IACvC,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,6FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/app/certified/badge/response.d.ts

@@ -0,0 +1,20 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import type * as AppCertifiedBadgeAward from './award.js';
+export interface Main {
+    $type: 'app.certified.badge.response';
+    badgeAward: AppCertifiedBadgeAward.Main;
+    /** The recipient’s response for the badge (accepted or rejected). */
+    response: 'accepted' | 'rejected';
+    /** Optional relative weight for accepted badges, assigned by the recipient. */
+    weight?: string;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "app.certified.badge.response", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=response.d.ts.map

package/dist/generated/types/app/certified/badge/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/app/certified/badge/response.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAQjE,OAAO,KAAK,KAAK,sBAAsB,MAAM,YAAY,CAAA;AAMzD,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,8BAA8B,CAAA;IACrC,UAAU,EAAE,sBAAsB,CAAC,IAAI,CAAA;IACvC,qEAAqE;IACrE,QAAQ,EAAE,UAAU,GAAG,UAAU,CAAA;IACjC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,2FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/app/certified/defs.d.ts

@@ -0,0 +1,3 @@
+/** A Decentralized Identifier (DID) string. */
+export type Did = string;
+//# sourceMappingURL=defs.d.ts.map

package/dist/generated/types/app/certified/defs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../../../generated/types/app/certified/defs.ts"],"names":[],"mappings":"AAYA,+CAA+C;AAC/C,MAAM,MAAM,GAAG,GAAG,MAAM,CAAA"}

package/dist/generated/types/app/certified/location.d.ts

@@ -0,0 +1,29 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import { type $Typed } from '../../../util';
+import type * as OrgHypercertsDefs from '../../org/hypercerts/defs.js';
+export interface Main {
+    $type: 'app.certified.location';
+    /** The version of the Location Protocol */
+    lpVersion: string;
+    /** The Spatial Reference System URI (e.g., http://www.opengis.net/def/crs/OGC/1.3/CRS84) that defines the coordinate system. */
+    srs: string;
+    /** An identifier for the format of the location data (e.g., coordinate-decimal, geojson-point) */
+    locationType: 'coordinate-decimal' | 'geojson-point' | (string & {});
+    location: $Typed<OrgHypercertsDefs.Uri> | $Typed<OrgHypercertsDefs.SmallBlob> | {
+        $type: string;
+    };
+    /** Optional name for this location */
+    name?: string;
+    /** Optional description for this location */
+    description?: string;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../util").$TypedObject<V, "app.certified.location", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=location.d.ts.map

package/dist/generated/types/app/certified/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../../../generated/types/app/certified/location.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EAAE,KAAK,MAAM,EAAuC,MAAM,eAAe,CAAA;AAChF,OAAO,KAAK,KAAK,iBAAiB,MAAM,8BAA8B,CAAA;AAMtE,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,wBAAwB,CAAA;IAC/B,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,gIAAgI;IAChI,GAAG,EAAE,MAAM,CAAA;IACX,kGAAkG;IAClG,YAAY,EAAE,oBAAoB,GAAG,eAAe,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;IACpE,QAAQ,EACJ,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,GACnC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,kFAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/com/atproto/repo/strongRef.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+export interface Main {
+    $type?: 'com.atproto.repo.strongRef';
+    uri: string;
+    cid: string;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "com.atproto.repo.strongRef", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+//# sourceMappingURL=strongRef.d.ts.map

package/dist/generated/types/com/atproto/repo/strongRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strongRef.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/com/atproto/repo/strongRef.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAajE,MAAM,WAAW,IAAI;IACnB,KAAK,CAAC,EAAE,4BAA4B,CAAA;IACpC,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;CACZ;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,yFAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC"}

package/dist/generated/types/org/hypercerts/claim/activity.d.ts

@@ -0,0 +1,57 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import { type $Typed } from '../../../../util';
+import type * as OrgHypercertsDefs from '../defs.js';
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js';
+export interface Main {
+    $type: 'org.hypercerts.claim.activity';
+    /** Title of the hypercert. */
+    title: string;
+    /** Short blurb of the impact work done. */
+    shortDescription: string;
+    /** Optional longer description of the impact work done. */
+    description?: string;
+    image?: $Typed<OrgHypercertsDefs.Uri> | $Typed<OrgHypercertsDefs.SmallImage> | {
+        $type: string;
+    };
+    workScope?: WorkScope;
+    /** When the work began */
+    startDate: string;
+    /** When the work ended */
+    endDate: string;
+    /** A strong reference to the contributions done to create the impact in the hypercerts. The record referenced must conform with the lexicon org.hypercerts.claim.contribution. */
+    contributions?: ComAtprotoRepoStrongRef.Main[];
+    rights?: ComAtprotoRepoStrongRef.Main;
+    location?: ComAtprotoRepoStrongRef.Main;
+    /** A reference (AT-URI) to the project record that this activity is part of. The record referenced must conform with the lexicon org.hypercerts.claim.project. This activity must also be referenced by the project, establishing a bidirectional link. */
+    project?: string;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.activity", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+/** Logical scope of the work using label-based conditions. All labels in `withinAllOf` must apply; at least one label in `withinAnyOf` must apply if provided; no label in `withinNoneOf` may apply. */
+export interface WorkScope {
+    $type?: 'org.hypercerts.claim.activity#workScope';
+    /** Labels that MUST all hold for the scope to apply. */
+    withinAllOf?: string[];
+    /** Labels of which AT LEAST ONE must hold (optional). If omitted or empty, imposes no additional condition. */
+    withinAnyOf?: string[];
+    /** Labels that MUST NOT hold for the scope to apply. */
+    withinNoneOf?: string[];
+}
+export declare function isWorkScope<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.activity", "workScope">;
+export declare function validateWorkScope<V>(v: V): ValidationResult<WorkScope & V>;
+export interface ActivityWeight {
+    $type?: 'org.hypercerts.claim.activity#activityWeight';
+    activity: ComAtprotoRepoStrongRef.Main;
+    /** The relative weight/importance of this hypercert activity (stored as a string to avoid float precision issues). Weights can be any positive numeric values and do not need to sum to a specific total; normalization can be performed by the consuming application as needed. */
+    weight: string;
+}
+export declare function isActivityWeight<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.activity", "activityWeight">;
+export declare function validateActivityWeight<V>(v: V): ValidationResult<ActivityWeight & V>;
+//# sourceMappingURL=activity.d.ts.map

package/dist/generated/types/org/hypercerts/claim/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/activity.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,iBAAiB,MAAM,YAAY,CAAA;AACpD,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AAMtF,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,+BAA+B,CAAA;IACtC,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,2CAA2C;IAC3C,gBAAgB,EAAE,MAAM,CAAA;IACxB,2DAA2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EACF,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,UAAU,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAA;IACjB,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,kLAAkL;IAClL,aAAa,CAAC,EAAE,uBAAuB,CAAC,IAAI,EAAE,CAAA;IAC9C,MAAM,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACrC,QAAQ,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACvC,2PAA2P;IAC3P,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,4FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA;AAED,wMAAwM;AACxM,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,yCAAyC,CAAA;IACjD,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,+GAA+G;IAC/G,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAID,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,iGAElC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,mCAExC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,8CAA8C,CAAA;IACtD,QAAQ,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACtC,oRAAoR;IACpR,MAAM,EAAE,MAAM,CAAA;CACf;AAID,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,sGAEvC;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,wCAE7C"}

package/dist/generated/types/org/hypercerts/claim/collection.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+import type * as OrgHypercertsClaimActivity from './activity.js';
+export interface Main {
+    $type: 'org.hypercerts.claim.collection';
+    /** The title of this collection */
+    title: string;
+    /** A short description of this collection */
+    shortDescription?: string;
+    /** Primary avatar image representing this collection across apps and views; typically a square image. */
+    avatar?: BlobRef;
+    /** The cover photo of this collection. */
+    coverPhoto?: BlobRef;
+    /** Array of activities with their associated weights in this collection */
+    activities: OrgHypercertsClaimActivity.ActivityWeight[];
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.collection", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=collection.d.ts.map

package/dist/generated/types/org/hypercerts/claim/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/collection.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAQjE,OAAO,KAAK,KAAK,0BAA0B,MAAM,eAAe,CAAA;AAMhE,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,iCAAiC,CAAA;IACxC,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,6CAA6C;IAC7C,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,yGAAyG;IACzG,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,2EAA2E;IAC3E,UAAU,EAAE,0BAA0B,CAAC,cAAc,EAAE,CAAA;IACvD,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/org/hypercerts/claim/contribution.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+export interface Main {
+    $type: 'org.hypercerts.claim.contribution';
+    /** Role or title of the contributor(s). */
+    role?: string;
+    /** List of the contributors (names, pseudonyms, or DIDs). If multiple contributors are stored in the same hypercertContribution, then they would have the exact same role. */
+    contributors: string[];
+    /** What the contribution concretely achieved */
+    description?: string;
+    /** When this contribution started. This should be a subset of the hypercert timeframe. */
+    startDate?: string;
+    /** When this contribution finished.  This should be a subset of the hypercert timeframe. */
+    endDate?: string;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.contribution", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=contribution.d.ts.map

package/dist/generated/types/org/hypercerts/claim/contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contribution.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/contribution.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAajE,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,mCAAmC,CAAA;IAC1C,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,8KAA8K;IAC9K,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0FAA0F;IAC1F,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4FAA4F;IAC5F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,gGAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/org/hypercerts/claim/evaluation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import { type $Typed } from '../../../../util';
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js';
+import type * as AppCertifiedDefs from '../../../app/certified/defs.js';
+import type * as OrgHypercertsDefs from '../defs.js';
+/** Overall score for an evaluation on a numeric scale. */
+export interface Score {
+    $type?: 'org.hypercerts.claim.evaluation#score';
+    /** Minimum value of the scale, e.g. 0 or 1. */
+    min: number;
+    /** Maximum value of the scale, e.g. 5 or 10. */
+    max: number;
+    /** Score within the inclusive range [min, max]. */
+    value: number;
+}
+export declare function isScore<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.evaluation", "score">;
+export declare function validateScore<V>(v: V): ValidationResult<Score & V>;
+export interface Main {
+    $type: 'org.hypercerts.claim.evaluation';
+    subject?: ComAtprotoRepoStrongRef.Main;
+    /** DIDs of the evaluators */
+    evaluators: AppCertifiedDefs.Did[];
+    /** Evaluation data (URIs or blobs) containing detailed reports or methodology */
+    content?: ($Typed<OrgHypercertsDefs.Uri> | $Typed<OrgHypercertsDefs.SmallBlob> | {
+        $type: string;
+    })[];
+    /** Optional references to the measurements that contributed to this evaluation. The record(s) referenced must conform with the lexicon org.hypercerts.claim.measurement */
+    measurements?: ComAtprotoRepoStrongRef.Main[];
+    /** Brief evaluation summary */
+    summary: string;
+    score?: Score;
+    location?: ComAtprotoRepoStrongRef.Main;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.evaluation", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=evaluation.d.ts.map

package/dist/generated/types/org/hypercerts/claim/evaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/evaluation.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AACtF,OAAO,KAAK,KAAK,gBAAgB,MAAM,gCAAgC,CAAA;AACvE,OAAO,KAAK,KAAK,iBAAiB,MAAM,YAAY,CAAA;AAMpD,0DAA0D;AAC1D,MAAM,WAAW,KAAK;IACpB,KAAK,CAAC,EAAE,uCAAuC,CAAA;IAC/C,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAA;IACX,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAA;IACX,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAA;CACd;AAID,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,+FAE9B;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,+BAEpC;AAED,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,iCAAiC,CAAA;IACxC,OAAO,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACtC,6BAA6B;IAC7B,UAAU,EAAE,gBAAgB,CAAC,GAAG,EAAE,CAAA;IAClC,iFAAiF;IACjF,OAAO,CAAC,EAAE,CACN,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,GACnC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CACpB,EAAE,CAAA;IACH,2KAA2K;IAC3K,YAAY,CAAC,EAAE,uBAAuB,CAAC,IAAI,EAAE,CAAA;IAC7C,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,QAAQ,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACvC,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/org/hypercerts/claim/evidence.d.ts

@@ -0,0 +1,29 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import { type $Typed } from '../../../../util';
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js';
+import type * as OrgHypercertsDefs from '../defs.js';
+export interface Main {
+    $type: 'org.hypercerts.claim.evidence';
+    subject?: ComAtprotoRepoStrongRef.Main;
+    content: $Typed<OrgHypercertsDefs.Uri> | $Typed<OrgHypercertsDefs.SmallBlob> | {
+        $type: string;
+    };
+    /** Title to describe the nature of the evidence. */
+    title: string;
+    /** Short description explaining what this evidence shows. */
+    shortDescription?: string;
+    /** Longer description describing the evidence in more detail. */
+    description?: string;
+    /** How this evidence relates to the subject. */
+    relationType?: 'supports' | 'challenges' | 'clarifies' | (string & {});
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.evidence", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=evidence.d.ts.map

package/dist/generated/types/org/hypercerts/claim/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/evidence.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AACtF,OAAO,KAAK,KAAK,iBAAiB,MAAM,YAAY,CAAA;AAMpD,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,+BAA+B,CAAA;IACtC,OAAO,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACtC,OAAO,EACH,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,GACnC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gDAAgD;IAChD,YAAY,CAAC,EAAE,UAAU,GAAG,YAAY,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;IACtE,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,4FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/org/hypercerts/claim/measurement.d.ts

@@ -0,0 +1,30 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js';
+import type * as AppCertifiedDefs from '../../../app/certified/defs.js';
+export interface Main {
+    $type: 'org.hypercerts.claim.measurement';
+    subject?: ComAtprotoRepoStrongRef.Main;
+    /** DIDs of the entity (or entities) that measured this data */
+    measurers: AppCertifiedDefs.Did[];
+    /** The metric being measured */
+    metric: string;
+    /** The measured value */
+    value: string;
+    /** Short identifier for the measurement methodology */
+    methodType?: string;
+    /** URI to methodology documentation, standard protocol, or measurement procedure */
+    methodURI?: string;
+    /** URIs to related evidence or underlying data (e.g. org.hypercerts.claim.evidence records or raw datasets) */
+    evidenceURI?: string[];
+    location?: ComAtprotoRepoStrongRef.Main;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.measurement", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=measurement.d.ts.map

package/dist/generated/types/org/hypercerts/claim/measurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/measurement.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAQjE,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AACtF,OAAO,KAAK,KAAK,gBAAgB,MAAM,gCAAgC,CAAA;AAMvE,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,kCAAkC,CAAA;IACzC,OAAO,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACtC,+DAA+D;IAC/D,SAAS,EAAE,gBAAgB,CAAC,GAAG,EAAE,CAAA;IACjC,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,oFAAoF;IACpF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+GAA+G;IAC/G,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,QAAQ,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACvC,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,+FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/org/hypercerts/claim/project.d.ts

@@ -0,0 +1,29 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+import type * as PubLeafletPagesLinearDocument from '../../../pub/leaflet/pages/linearDocument.js';
+import type * as OrgHypercertsClaimActivity from './activity.js';
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js';
+export interface Main {
+    $type: 'org.hypercerts.claim.project';
+    /** Title of this project */
+    title: string;
+    /** Short summary of this project, suitable for previews and list views. */
+    shortDescription: string;
+    description?: PubLeafletPagesLinearDocument.Main;
+    /** Primary avatar image representing this project across apps and views; typically a square logo or project identity image. */
+    avatar?: BlobRef;
+    /** The cover photo of this project. */
+    coverPhoto?: BlobRef;
+    /** Array of activities with their associated weights in this project */
+    activities?: OrgHypercertsClaimActivity.ActivityWeight[];
+    location?: ComAtprotoRepoStrongRef.Main;
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.project", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=project.d.ts.map

package/dist/generated/types/org/hypercerts/claim/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/project.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAQjE,OAAO,KAAK,KAAK,6BAA6B,MAAM,8CAA8C,CAAA;AAClG,OAAO,KAAK,KAAK,0BAA0B,MAAM,eAAe,CAAA;AAChE,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AAMtF,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,8BAA8B,CAAA;IACrC,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,2EAA2E;IAC3E,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,6BAA6B,CAAC,IAAI,CAAA;IAChD,+HAA+H;IAC/H,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,uCAAuC;IACvC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,wEAAwE;IACxE,UAAU,CAAC,EAAE,0BAA0B,CAAC,cAAc,EAAE,CAAA;IACxD,QAAQ,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACvC,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,2FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/org/hypercerts/claim/rights.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import { type $Typed } from '../../../../util';
+import type * as OrgHypercertsDefs from '../defs.js';
+export interface Main {
+    $type: 'org.hypercerts.claim.rights';
+    /** Full name of the rights */
+    rightsName: string;
+    /** Short rights identifier for easier search */
+    rightsType: string;
+    /** Description of the rights of this hypercert */
+    rightsDescription: string;
+    attachment?: $Typed<OrgHypercertsDefs.Uri> | $Typed<OrgHypercertsDefs.SmallBlob> | {
+        $type: string;
+    };
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.claim.rights", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=rights.d.ts.map

package/dist/generated/types/org/hypercerts/claim/rights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rights.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/rights.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,iBAAiB,MAAM,YAAY,CAAA;AAMpD,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,6BAA6B,CAAA;IACpC,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAA;IAClB,kDAAkD;IAClD,iBAAiB,EAAE,MAAM,CAAA;IACzB,UAAU,CAAC,EACP,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,GACnC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,0FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/org/hypercerts/defs.d.ts

@@ -0,0 +1,45 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+/** Object containing a URI to external data */
+export interface Uri {
+    $type?: 'org.hypercerts.defs#uri';
+    /** URI to external data */
+    uri: string;
+}
+export declare function isUri<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "uri">;
+export declare function validateUri<V>(v: V): ValidationResult<Uri & V>;
+/** Object containing a blob to external data */
+export interface SmallBlob {
+    $type?: 'org.hypercerts.defs#smallBlob';
+    /** Blob to external data (up to 10MB) */
+    blob: BlobRef;
+}
+export declare function isSmallBlob<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "smallBlob">;
+export declare function validateSmallBlob<V>(v: V): ValidationResult<SmallBlob & V>;
+/** Object containing a blob to external data */
+export interface LargeBlob {
+    $type?: 'org.hypercerts.defs#largeBlob';
+    /** Blob to external data (up to 100MB) */
+    blob: BlobRef;
+}
+export declare function isLargeBlob<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "largeBlob">;
+export declare function validateLargeBlob<V>(v: V): ValidationResult<LargeBlob & V>;
+/** Object containing a small image */
+export interface SmallImage {
+    $type?: 'org.hypercerts.defs#smallImage';
+    /** Image (up to 5MB) */
+    image: BlobRef;
+}
+export declare function isSmallImage<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "smallImage">;
+export declare function validateSmallImage<V>(v: V): ValidationResult<SmallImage & V>;
+/** Object containing a large image */
+export interface LargeImage {
+    $type?: 'org.hypercerts.defs#largeImage';
+    /** Image (up to 10MB) */
+    image: BlobRef;
+}
+export declare function isLargeImage<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "largeImage">;
+export declare function validateLargeImage<V>(v: V): ValidationResult<LargeImage & V>;
+//# sourceMappingURL=defs.d.ts.map

package/dist/generated/types/org/hypercerts/defs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../../../generated/types/org/hypercerts/defs.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AASjE,+CAA+C;AAC/C,MAAM,WAAW,GAAG;IAClB,KAAK,CAAC,EAAE,yBAAyB,CAAA;IACjC,2BAA2B;IAC3B,GAAG,EAAE,MAAM,CAAA;CACZ;AAID,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8EAE5B;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,6BAElC;AAED,gDAAgD;AAChD,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,+BAA+B,CAAA;IACvC,yCAAyC;IACzC,IAAI,EAAE,OAAO,CAAA;CACd;AAID,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oFAElC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,mCAExC;AAED,gDAAgD;AAChD,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,+BAA+B,CAAA;IACvC,0CAA0C;IAC1C,IAAI,EAAE,OAAO,CAAA;CACd;AAID,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oFAElC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,mCAExC;AAED,sCAAsC;AACtC,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,gCAAgC,CAAA;IACxC,wBAAwB;IACxB,KAAK,EAAE,OAAO,CAAA;CACf;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,qFAEnC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oCAEzC;AAED,sCAAsC;AACtC,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,gCAAgC,CAAA;IACxC,yBAAyB;IACzB,KAAK,EAAE,OAAO,CAAA;CACf;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,qFAEnC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oCAEzC"}

package/dist/generated/types/org/hypercerts/funding/receipt.d.ts

@@ -0,0 +1,34 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import type * as AppCertifiedDefs from '../../../app/certified/defs.js';
+export interface Main {
+    $type: 'org.hypercerts.funding.receipt';
+    from: AppCertifiedDefs.Did;
+    /** The recipient of the funds. Can be identified by DID or a clear-text name. */
+    to: string;
+    /** Amount of funding received. */
+    amount: string;
+    /** Currency of the payment (e.g. EUR, USD, ETH). */
+    currency: string;
+    /** How the funds were transferred (e.g. bank_transfer, credit_card, onchain, cash, check, payment_processor). */
+    paymentRail?: string;
+    /** Optional network within the payment rail (e.g. arbitrum, ethereum, sepa, visa, paypal). */
+    paymentNetwork?: string;
+    /** Identifier of the underlying payment transaction (e.g. bank reference, onchain transaction hash, or processor-specific ID). Use paymentNetwork to specify the network where applicable. */
+    transactionId?: string;
+    /** Optional reference to the activity, project, or organization this funding relates to. */
+    for?: string;
+    /** Optional notes or additional context for this funding receipt. */
+    notes?: string;
+    /** Timestamp when the payment occurred. */
+    occurredAt?: string;
+    /** Client-declared timestamp when this receipt record was created. */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.funding.receipt", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=receipt.d.ts.map

package/dist/generated/types/org/hypercerts/funding/receipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receipt.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/funding/receipt.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAQjE,OAAO,KAAK,KAAK,gBAAgB,MAAM,gCAAgC,CAAA;AAMvE,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,gCAAgC,CAAA;IACvC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAA;IAC1B,iFAAiF;IACjF,EAAE,EAAE,MAAM,CAAA;IACV,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAA;IAChB,iHAAiH;IACjH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8FAA8F;IAC9F,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,8LAA8L;IAC9L,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,4FAA4F;IAC5F,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,6FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}

package/dist/generated/types/pub/leaflet/pages/linearDocument.d.ts

@@ -0,0 +1,2 @@
+export * from '@atcute/leaflet/types/pages/linearDocument';
+//# sourceMappingURL=linearDocument.d.ts.map

package/dist/generated/types/pub/leaflet/pages/linearDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linearDocument.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/pub/leaflet/pages/linearDocument.ts"],"names":[],"mappings":"AAEA,cAAc,4CAA4C,CAAC"}

package/dist/generated/util.d.ts

@@ -0,0 +1,37 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+export type OmitKey<T, K extends keyof T> = {
+    [K2 in keyof T as K2 extends K ? never : K2]: T[K2];
+};
+export type $Typed<V, T extends string = string> = V & {
+    $type: T;
+};
+export type Un$Typed<V extends {
+    $type?: string;
+}> = OmitKey<V, '$type'>;
+export type $Type<Id extends string, Hash extends string> = Hash extends 'main' ? Id : `${Id}#${Hash}`;
+export type $TypedObject<V, Id extends string, Hash extends string> = V extends {
+    $type: $Type<Id, Hash>;
+} ? V : V extends {
+    $type?: string;
+} ? V extends {
+    $type?: infer T extends $Type<Id, Hash>;
+} ? V & {
+    $type: T;
+} : never : V & {
+    $type: $Type<Id, Hash>;
+};
+export declare function is$typed<V, Id extends string, Hash extends string>(v: V, id: Id, hash: Hash): v is $TypedObject<V, Id, Hash>;
+export declare function maybe$typed<V, Id extends string, Hash extends string>(v: V, id: Id, hash: Hash): v is V & object & {
+    $type?: $Type<Id, Hash>;
+};
+export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>;
+export type ValidatorParam<V extends Validator> = V extends Validator<infer R> ? R : never;
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+export declare function asPredicate<V extends Validator>(validate: V): <T>(v: T) => v is T & ValidatorParam<V>;
+//# sourceMappingURL=util.d.ts.map

package/dist/generated/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../generated/util.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI;KACzC,EAAE,IAAI,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,KAAK,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;CACpD,CAAA;AAED,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,CAAA;AACnE,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,IAAI,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;AAExE,MAAM,MAAM,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,IAAI,IAAI,SAAS,MAAM,GAC3E,EAAE,GACF,GAAG,EAAE,IAAI,IAAI,EAAE,CAAA;AAqBnB,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,EAAE,SAAS,MAAM,EACjB,IAAI,SAAS,MAAM,IACjB,CAAC,SAAS;IACZ,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CACvB,GACG,CAAC,GACD,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1B,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,SAAS,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CAAE,GACnD,CAAC,GAAG;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,GAChB,KAAK,GACP,CAAC,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CAAE,CAAA;AAEpC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAChE,CAAC,EAAE,CAAC,EACJ,EAAE,EAAE,EAAE,EACN,IAAI,EAAE,IAAI,GACT,CAAC,IAAI,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,CAEhC;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EACnE,CAAC,EAAE,CAAC,EACJ,EAAE,EAAE,EAAE,EACN,IAAI,EAAE,IAAI,GACT,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG;IAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CAAE,CAK/C;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,OAAO,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAA;AACxE,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,SAAS,IAC5C,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE1C;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,EAAE,QAAQ,EAAE,CAAC,IACzC,CAAC,EAAE,GAAG,CAAC,KAAG,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAGtD"}