@better-giving/endowment 2.0.6 → 3.0.2

package/dist/cloudsearch.d.mts

@@ -1,6 +1,6 @@
 import type { ToDoc, ToHitFields, ToUpdate } from "@better-giving/types/cloudsearch";
+import type { Environment } from "@better-giving/types/list";
 import { type InferInput, type InferOutput } from "valibot";
-import { type Environment } from "./schema.mjs";
 export declare const cloudsearchEndowFields: import("valibot").ObjectSchema<{
     readonly contributions_total: import("valibot").NumberSchema<undefined>;
     readonly contributions_count: import("valibot").NumberSchema<undefined>;

package/dist/cloudsearch.mjs

@@ -1,13 +1,13 @@
 import { $int_gte1, org_designation, unsdg_num } from "@better-giving/schemas";
-import { array, boolean, integer, keyof, mapItems, minValue, number, object, optional, pick, pipe, string, transform, } from "valibot";
-import { $, csvStrs, endowment } from "./schema.mjs";
+import { array, boolean, keyof, mapItems, number, object, optional, pick, pipe, } from "valibot";
+import { $, csvStrs, npo } from "./schema.mjs";
 const boolCsv = pipe(csvStrs, mapItems((x) => x === "true"), array(boolean()));
 export const cloudsearchEndowFields = object({
     contributions_total: number(),
     contributions_count: number(),
 });
 export const cloudsearchEndow = object({
-    ...pick(endowment, [
+    ...pick(npo, [
         "card_img",
         "name",
         "tagline",

package/dist/db.d.mts

@@ -1,120 +1,143 @@
-import type { Ensure } from "@better-giving/types/utils";
-import type { Endowment as EndowmentShape, Environment, MediaId, MediaType, MilestoneId, Milestone as MilestoneShape, ProgramId, Program as ProgramShape } from "./schema.mjs";
-export type { SocialMediaURLs, Allocation, Increment, EndowDesignation, Environment, ProgramId, } from "./schema.mjs";
-export declare const endowGsi: {
-    readonly regnumEnv: "regnum-env-gsi";
-    readonly slugEnv: "slug-env-gsi";
-};
-export declare namespace EndowCount {
-    interface Keys {
-        PK: "Count";
-        SK: Environment;
-    }
-    interface NonKeyAttributes {
-        count: number;
-    }
-}
-export declare namespace Endow {
-    type Keys = {
-        PK: `Endow#${number}`;
-        SK: Environment;
+import { Db } from "@better-giving/db";
+import type { IMedia, IMediaPage, INpoReferredBy, INpoWithRegNum, INpoWithRid, TBinFlag, TNpoDbKeys, TNpoDbProjectedTo } from "./interfaces.mjs";
+import type { IMediaSearchObj, IMilestone, IMilestoneUpdate, INpo, INpoUpdate, IProgram, IProgramDb, IProgramNew, IProgramUpdate, TMediaType } from "./schema.mjs";
+export declare class NpoDb extends Db {
+    static readonly name = "endowments_v3";
+    static readonly slug_env_gsi: "slug-env-gsi";
+    static readonly regnum_env_gsi: "regnum-env-gsi";
+    key_npo(id: number): {
+        PK: string;
+        SK: import("@better-giving/types/list").Environment;
     };
-    type NonKeyAttributes = EndowmentShape & {
-        /** referral id */
-        gsi1PK?: `ReferredBy#${string}`;
-        /** expiry / date onboarded */
-        gsi1SK?: string;
-        /** Rid#referral_id */
-        gsi2PK?: `Rid#${string}`;
-        gsi2SK?: `Rid#${string}`;
-        /** will only be present for unclaimed NPOs */
-        updated_at_auto?: string;
-        /** in USD @deprecated */
-        payout_minimum?: number;
-        /** @deprecated */
-        splitLiqPct?: number;
-        /** @deprecated */
-        splitFixed?: boolean;
-        /** @deprecated */
-        sfCompounded?: boolean;
+    get key_count(): {
+        PK: string;
+        SK: import("@better-giving/types/list").Environment;
     };
-    interface DbRecord extends Keys, NonKeyAttributes {
-    }
-}
-export declare namespace RegNumEnvGsi {
-    type Name = typeof endowGsi.regnumEnv;
-    interface Keys extends Pick<Endow.NonKeyAttributes, "registration_number" | "env"> {
-    }
-    interface DbRecord extends Keys, Endow.Keys, Pick<Endow.NonKeyAttributes, "claimed" | "name" | "hq_country" | "id"> {
-    }
-}
-export declare namespace SlugEnvGsi {
-    type Name = typeof endowGsi.slugEnv;
-    interface Keys extends Pick<Endow.NonKeyAttributes, "slug" | "env"> {
-    }
-    interface DbRecord extends Endow.DbRecord {
-    }
-}
-export declare namespace Program {
-    interface Keys {
-        PK: `Endow#${number}#${Environment}`;
-        SK: `Prog#${ProgramId}`;
-    }
-    interface NonKeyAttributes extends ProgramShape {
-    }
-    interface DbRecord extends Keys, NonKeyAttributes {
-    }
-}
-export declare namespace Milestone {
-    interface Keys {
-        PK: `Prog#${string}#${Environment}`;
-        SK: `Mile#${MilestoneId}`;
-    }
-    interface DbRecord extends Keys, MilestoneShape {
-    }
-}
-export declare namespace Media {
-    interface Keys {
-        PK: `Endow#${number}#${Environment}`;
-        SK: `Media#${MediaId}`;
-    }
-    /** "0" - featured (goes before 1), "1" - not-featured */
-    type FeaturedFlag = "0" | "1";
-    interface NonKeyAttributes {
-        id: MediaId;
-        gsi1PK: Keys["PK"];
-        gsi1SK: `MediaList#${FeaturedFlag}#${MediaId}#${MediaType}`;
-        /** iso string */
+    key_npo_program(id: string, npo: number): {
+        PK: string;
+        SK: string;
+    };
+    key_prog_milestone(id: string, prog: string): {
+        PK: string;
+        SK: string;
+    };
+    key_npo_med(ksuid: string, npo: number): {
+        PK: string;
+        SK: string;
+    };
+    gsi1_npo(id: string): {
+        gsi1PK: string;
+        gsi1SK: import("@better-giving/types/list").Environment;
+    };
+    gsi2_npo(id: string): {
+        gsi2PK: string;
+        gsi2SK: string;
+    };
+    gsi1_npo_med(id: string, npo: number, featured: TBinFlag, type: TMediaType): {
+        gsi1PK: string;
+        gsi1SK: string;
+    };
+    npo_media(npo: number, opts: IMediaSearchObj): Promise<IMediaPage>;
+    npo_referred_by(id: string): Promise<INpoReferredBy[]>;
+    npo_with_rid(id: string): Promise<INpoWithRid | undefined>;
+    npo_with_regnum(regnum: string, country?: string): Promise<INpoWithRegNum | undefined>;
+    npo_record(data: INpo): {
+        gsi2PK?: string | undefined;
+        gsi2SK?: string | undefined;
+        gsi1PK?: string | undefined;
+        gsi1SK?: import("@better-giving/types/list").Environment | undefined;
+        active_in_countries: string[];
+        sdgs: (2 | 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17)[];
+        id: number;
+        env: "staging" | "production";
+        registration_number: string;
+        name: string;
+        endow_designation: "Charity" | "Religious Organization" | "University" | "Hospital" | "Other";
+        hq_country: string;
+        social_media_urls: {
+            facebook?: string | undefined;
+            twitter?: string | undefined;
+            linkedin?: string | undefined;
+            discord?: string | undefined;
+            instagram?: string | undefined;
+            youtube?: string | undefined;
+            tiktok?: string | undefined;
+        };
+        claimed: boolean;
+        kyc_donors_only: boolean;
+        fiscal_sponsored: boolean;
+        url?: string | undefined;
+        slug?: string | undefined;
+        overview?: string | undefined;
+        tagline?: string | undefined;
+        image?: string | undefined;
+        logo?: string | undefined;
+        card_img?: string | undefined;
+        street_address?: string | undefined;
+        receiptMsg?: string | undefined;
+        hide_bg_tip?: boolean | undefined;
+        published?: boolean | undefined;
+        progDonationsAllowed?: boolean | undefined;
+        allocation?: {
+            cash: number;
+            liq: number;
+            lock: number;
+        } | undefined;
+        donateMethods?: ("stripe" | "crypto" | "daf" | "stocks")[] | undefined;
+        increments?: {
+            value: string;
+            label: string;
+        }[] | undefined;
+        fund_opt_in?: boolean | undefined;
+        target?: string | undefined;
+        referral_id?: string | undefined;
+        referrer?: string | undefined;
+        referrer_expiry?: string | undefined;
+        w_form?: string | undefined;
+        payout_minimum?: number | undefined;
+        PK: string;
+        SK: import("@better-giving/types/list").Environment;
+    };
+    npo_prog_record(npo: number, data: IProgramDb): {
+        id: string;
+        title: string;
+        description: string;
+        banner?: string | undefined;
+        targetRaise?: number | null | undefined;
+        totalDonations?: number | undefined;
+        PK: string;
+        SK: string;
+    };
+    prog_milestone_record(prog: string, data: IMilestone): {
+        id: string;
+        date: string;
+        title: string;
+        description: string;
+        media?: string | undefined;
+        PK: string;
+        SK: string;
+    };
+    npo_med_record(npo_id: number, { featured /** not saved as attribute  */, ...d }: IMedia): {
+        id: string;
+        type: Extract<TMediaType, "video">;
         dateCreated: string;
-    }
-    interface VideoAttributes extends NonKeyAttributes {
-        type: Extract<MediaType, "video">;
         url: string;
-    }
-    interface VideoDbRecord extends Keys, VideoAttributes {
-    }
-    type DbRecord = VideoDbRecord;
-}
-export declare namespace Gsi1 {
-    namespace MediaList {
-        interface Keys extends Pick<Media.NonKeyAttributes, "gsi1PK" | "gsi1SK"> {
-        }
-        interface DbRecord extends Media.DbRecord {
-        }
-    }
-    namespace ReferredNpos {
-        interface Keys extends Required<Pick<Endow.NonKeyAttributes, "gsi1PK" | "gsi1SK">> {
-        }
-        interface DbRecord extends Ensure<Endow.DbRecord, "gsi1PK" | "gsi1SK" | "referrer" | "referrer_expiry"> {
-        }
-    }
-}
-export declare namespace Gsi2 {
-    namespace Rid {
-        interface Keys extends Required<Pick<Endow.NonKeyAttributes, "gsi1PK" | "gsi1SK">> {
-        }
-        interface DbRecord extends Ensure<Endow.DbRecord, "gsi1PK" | "gsi1SK" | "referral_id"> {
-        }
-    }
+        gsi1PK: string;
+        gsi1SK: string;
+        PK: string;
+        SK: string;
+    };
+    npo_med_put(npo: number, url: string): Promise<string>;
+    npo_med(npo: number, mid: string): Promise<IMedia | undefined>;
+    npo_med_delete(npo: number, mid: string): Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;
+    npo<T extends TNpoDbKeys[]>(id: string | number, fields?: T): Promise<TNpoDbProjectedTo<T> | undefined>;
+    npo_update(id: number, { target, slug, social_media_urls, ...update }: INpoUpdate): Promise<import("@aws-sdk/lib-dynamodb").UpdateCommandOutput>;
+    prog_milestones(id: string): Promise<IMilestone[]>;
+    prog_milestone_delete(pid: string, mid: string): Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;
+    prog_milestone_update(pid: string, mid: string, update: IMilestoneUpdate): Promise<Record<string, any> | undefined>;
+    npo_program(id: string, npo_id: number): Promise<IProgram | undefined>;
+    npo_programs(id: number): Promise<IProgramDb[]>;
+    npo_program_put(npo: number, content: IProgramNew): Promise<string>;
+    npo_prog_del(npo: number, prog: string): Promise<import("@aws-sdk/lib-dynamodb").TransactWriteCommandOutput>;
+    npo_prog_update(npo: number, prog: string, update: IProgramUpdate): Promise<Record<string, any> | undefined>;
 }
-export type DbRecord = Endow.DbRecord | Program.DbRecord;

package/dist/db.mjs

@@ -1,4 +1,355 @@
-export const endowGsi = {
-    regnumEnv: "regnum-env-gsi",
-    slugEnv: "slug-env-gsi",
-};
+import { DeleteCommand, GetCommand, PutCommand, QueryCommand, TransactWriteCommand, UpdateCommand, } from "@aws-sdk/lib-dynamodb";
+import { Db, Txs, UpdateBuilder } from "@better-giving/db";
+import KSUID from "ksuid";
+import { med_key_filter, med_sk, to_imedia } from "./media.mjs";
+import { projection } from "./npo.mjs";
+export class NpoDb extends Db {
+    static name = "endowments_v3";
+    static slug_env_gsi = "slug-env-gsi";
+    static regnum_env_gsi = "regnum-env-gsi";
+    key_npo(id) {
+        return {
+            PK: `Endow#${id}`,
+            SK: this.env,
+        };
+    }
+    get key_count() {
+        return {
+            PK: "Count",
+            SK: this.env,
+        };
+    }
+    key_npo_program(id, npo) {
+        return {
+            PK: `Endow#${npo}#${this.env}`,
+            SK: `Prog#${id}`,
+        };
+    }
+    key_prog_milestone(id, prog) {
+        return {
+            PK: `Prog#${prog}#${this.env}`,
+            SK: `Mile#${id}`,
+        };
+    }
+    key_npo_med(ksuid, npo) {
+        return {
+            PK: `Endow#${npo}#${this.env}`,
+            SK: `Media#${ksuid}`,
+        };
+    }
+    gsi1_npo(id) {
+        return {
+            gsi1PK: `ReferredBy#${id}`,
+            gsi1SK: this.env,
+        };
+    }
+    gsi2_npo(id) {
+        return {
+            gsi2PK: `Rid#${id}`,
+            gsi2SK: `Rid#${id}`,
+        };
+    }
+    gsi1_npo_med(id, npo, featured, type) {
+        return {
+            gsi1PK: this.key_npo_med(id, npo).PK,
+            gsi1SK: med_sk(id, type, featured),
+        };
+    }
+    async npo_media(npo, opts) {
+        const PK = this.key_npo_med("ksuid-sk", npo).PK;
+        const [expression, values] = med_key_filter(PK, opts);
+        const cmd = new QueryCommand({
+            TableName: NpoDb.name,
+            IndexName: "gsi1",
+            Limit: opts.limit,
+            KeyConditionExpression: expression,
+            ExpressionAttributeValues: values,
+            ExclusiveStartKey: this.key_to_obj(opts.next),
+        });
+        const res = await this.client.send(cmd);
+        const page = this.to_page(res, to_imedia);
+        return page;
+    }
+    async npo_referred_by(id) {
+        const cmd = new QueryCommand({
+            TableName: NpoDb.name,
+            IndexName: "gsi1",
+            KeyConditionExpression: "#pk = :pk",
+            ExpressionAttributeValues: {
+                ":pk": this.gsi1_npo(id).gsi1PK,
+            },
+            ExpressionAttributeNames: { "#pk": "gsi1PK" },
+        });
+        const { Items = [] } = await this.client.send(cmd);
+        return Items.map((x) => this.sans_keys(x));
+    }
+    async npo_with_rid(id) {
+        const cmd = new QueryCommand({
+            TableName: NpoDb.name,
+            IndexName: "gsi2",
+            KeyConditionExpression: "gsi2PK = :pk",
+            ExpressionAttributeValues: {
+                ":pk": this.gsi2_npo(id).gsi2PK,
+            },
+            Limit: 1,
+        });
+        const { Items = [] } = await this.client.send(cmd);
+        const i = Items[0];
+        return i && this.sans_keys(i);
+    }
+    async npo_with_regnum(regnum, country = "United States") {
+        const cmd = new QueryCommand({
+            TableName: NpoDb.name,
+            IndexName: NpoDb.regnum_env_gsi,
+            Limit: 1,
+            KeyConditionExpression: "#rn = :rn AND #env = :env",
+            FilterExpression: "#country = :country",
+            ExpressionAttributeNames: {
+                "#rn": "registration_number",
+                "#env": "env",
+                "#country": "hq_country",
+            },
+            ExpressionAttributeValues: {
+                ":rn": regnum,
+                ":env": this.env,
+                ":country": country,
+            },
+        });
+        const { Items = [] } = await this.client.send(cmd);
+        const i = Items[0];
+        return i && this.sans_keys(i);
+    }
+    npo_record(data) {
+        return {
+            ...this.key_npo(data.id),
+            ...data,
+            ...(data.referrer ? this.gsi1_npo(data.referrer) : {}),
+            ...(data.referral_id ? this.gsi2_npo(data.referral_id) : {}),
+        };
+    }
+    npo_prog_record(npo, data) {
+        return {
+            ...this.key_npo_program(data.id, npo),
+            ...data,
+        };
+    }
+    prog_milestone_record(prog, data) {
+        return {
+            ...this.key_prog_milestone(data.id, prog),
+            ...data,
+        };
+    }
+    npo_med_record(npo_id, { featured /** not saved as attribute  */, ...d }) {
+        return {
+            ...this.key_npo_med(d.id, npo_id),
+            ...this.gsi1_npo_med(d.id, npo_id, featured ? "1" : "0", d.type),
+            ...d,
+        };
+    }
+    async npo_med_put(npo, url) {
+        const ksuid = KSUID.randomSync();
+        const mid = ksuid.string;
+        const item = this.npo_med_record(npo, {
+            id: mid,
+            url,
+            type: "video",
+            dateCreated: ksuid.date.toISOString(),
+            featured: false,
+        });
+        const command = new PutCommand({
+            TableName: NpoDb.name,
+            Item: item,
+        });
+        await this.client.send(command);
+        return mid;
+    }
+    async npo_med(npo, mid) {
+        const cmd = new GetCommand({
+            TableName: NpoDb.name,
+            Key: this.key_npo_med(mid, npo),
+        });
+        const { Item: i } = await this.client.send(cmd);
+        return i && to_imedia(i);
+    }
+    async npo_med_delete(npo, mid) {
+        const cmd = new DeleteCommand({
+            TableName: NpoDb.name,
+            Key: this.key_npo_med(mid, npo),
+        });
+        return this.client.send(cmd);
+    }
+    async npo(id, fields) {
+        const { names, expression } = projection(fields);
+        if (typeof id === "string") {
+            const cmd = new QueryCommand({
+                TableName: NpoDb.name,
+                IndexName: NpoDb.slug_env_gsi,
+                KeyConditionExpression: "#slug = :slug and #env = :env",
+                ExpressionAttributeValues: {
+                    ":slug": id,
+                    ":env": this.env,
+                },
+                ProjectionExpression: expression,
+                ExpressionAttributeNames: {
+                    ...names,
+                    "#env": "env",
+                    "#slug": "slug",
+                },
+            });
+            const [x] = await this.client.send(cmd).then(({ Items: x = [] }) => x);
+            return x ? this.sans_keys(x) : undefined;
+        }
+        const cmd = new GetCommand({
+            TableName: NpoDb.name,
+            Key: this.key_npo(id),
+            ProjectionExpression: expression,
+            ExpressionAttributeNames: names,
+        });
+        const { Item: i } = await this.client.send(cmd);
+        return i ? this.sans_keys(i) : undefined;
+    }
+    async npo_update(id, { target, slug, social_media_urls, ...update }) {
+        const updates = new UpdateBuilder();
+        if (slug)
+            updates.set("slug", slug);
+        if (slug === "")
+            updates.remove("slug");
+        if (target || target === "0") {
+            updates.set("target", target);
+        }
+        if (social_media_urls) {
+            for (const [k, v] of Object.entries(social_media_urls)) {
+                if (v === undefined)
+                    continue;
+                updates.set(`social_media_urls.${k}`, v);
+            }
+        }
+        for (const [k, v] of Object.entries(update)) {
+            if (v === undefined)
+                continue;
+            updates.set(k, v);
+        }
+        const cmd = new UpdateCommand({
+            TableName: NpoDb.name,
+            Key: this.key_npo(id),
+            ReturnValues: "ALL_NEW",
+            ...updates.collect(),
+        });
+        return this.client.send(cmd);
+    }
+    async prog_milestones(id) {
+        const command = new QueryCommand({
+            TableName: NpoDb.name,
+            KeyConditionExpression: `PK = :PK`,
+            ExpressionAttributeValues: {
+                ":PK": this.key_prog_milestone("not-used", id).PK,
+            },
+        });
+        return this.client
+            .send(command)
+            .then(({ Items: x = [] }) => x.map((i) => this.sans_keys(i)));
+    }
+    async prog_milestone_delete(pid, mid) {
+        const cmd = new DeleteCommand({
+            TableName: NpoDb.name,
+            Key: this.key_prog_milestone(mid, pid),
+        });
+        return this.client.send(cmd);
+    }
+    async prog_milestone_update(pid, mid, update) {
+        const upd8 = new UpdateBuilder();
+        for (const [key, value] of Object.entries(update)) {
+            upd8.set(key, value);
+        }
+        const cmd = new UpdateCommand({
+            TableName: NpoDb.name,
+            Key: this.key_prog_milestone(mid, pid),
+            ...upd8.collect(),
+            ReturnValues: "ALL_NEW",
+        });
+        return this.client.send(cmd).then((res) => res.Attributes);
+    }
+    async npo_program(id, npo_id) {
+        const cmd = new GetCommand({
+            TableName: NpoDb.name,
+            Key: this.key_npo_program(id, npo_id),
+        });
+        const { Item: p } = await this.client.send(cmd);
+        if (!p)
+            return undefined;
+        const milestones = await this.prog_milestones(id);
+        return {
+            ...this.sans_keys(p),
+            milestones: milestones.toSorted((a, b) => a.date.localeCompare(b.date)),
+        };
+    }
+    async npo_programs(id) {
+        const cmd = new QueryCommand({
+            TableName: NpoDb.name,
+            KeyConditionExpression: `PK = :PK and begins_with(SK, :SK)`,
+            ExpressionAttributeValues: {
+                ":PK": this.key_npo_program("not-used", id).PK,
+                ":SK": "Prog#",
+            },
+        });
+        const { Items: x = [] } = await this.client.send(cmd);
+        return x.map((i) => this.sans_keys(i));
+    }
+    async npo_program_put(npo, content) {
+        const pid = crypto.randomUUID();
+        const { milestones, ...prog } = content;
+        const txs = new Txs();
+        const db_prog = this.npo_prog_record(npo, {
+            ...prog,
+            id: pid,
+            totalDonations: 0,
+        });
+        txs.put({
+            TableName: NpoDb.name,
+            Item: db_prog,
+        });
+        for (const m of milestones || []) {
+            const mid = crypto.randomUUID();
+            txs.put({
+                TableName: NpoDb.name,
+                Item: this.prog_milestone_record(pid, { ...m, id: mid }),
+            });
+        }
+        const cmd = new TransactWriteCommand({
+            TransactItems: txs.all,
+        });
+        await this.client.send(cmd);
+        return pid;
+    }
+    async npo_prog_del(npo, prog) {
+        const milestones = await this.prog_milestones(prog);
+        const txs = new Txs();
+        txs.del({
+            TableName: NpoDb.name,
+            Key: this.key_npo_program(prog, npo),
+        });
+        for (const m of milestones) {
+            txs.del({
+                TableName: NpoDb.name,
+                Key: this.key_prog_milestone(m.id, prog),
+            });
+        }
+        const cmd = new TransactWriteCommand({
+            TransactItems: txs.all,
+        });
+        return this.client.send(cmd);
+    }
+    async npo_prog_update(npo, prog, update) {
+        const upd8 = new UpdateBuilder();
+        for (const [key, value] of Object.entries(update)) {
+            upd8.set(key, value);
+        }
+        const cmd = new UpdateCommand({
+            TableName: NpoDb.name,
+            Key: this.key_npo_program(prog, npo),
+            ...upd8.collect(),
+            ReturnValues: "ALL_NEW",
+        });
+        return this.client.send(cmd).then((res) => res.Attributes);
+    }
+}

package/dist/index.d.mts

@@ -1,21 +1,3 @@
-import type { IPageKeyed } from "@better-giving/types/api";
-import type { CloudsearchEndow as EndowItem } from "./cloudsearch.mjs";
-import type { Media } from "./db.mjs";
-import type { Milestone, Program as ProgramShape } from "./schema.mjs";
-export type { Allocation, DonateMethodId, EndowDesignation, Endowment as Endow, EndowFields, EndowQueryParams, EndowUpdate, Environment, Increment, MediaQueryParams, MediaQueryParamsObj, MediaType, MediaUpdate, Milestone, MilestoneUpdate, NewMilestone, NewProgram, ProgramUpdate, SocialMediaURLs, UnSdgNum, } from "./schema.mjs";
+export * from "./interfaces.mjs";
+export { NpoDb } from "./db.mjs";
 export type { CloudsearchEndow as EndowItem, CloudsearchEndowsQueryParams as EndowsQueryParams, CloudsearchEndowsQueryParamsParsed as EndowsQueryParamsParsed, } from "./cloudsearch.mjs";
-/** client responsible on T depending on keys projected */
-export interface EndowsPage<T extends keyof EndowItem = keyof EndowItem> {
-    items: Pick<EndowItem, T>[];
-    page: number;
-    pages: number;
-}
-export interface Program extends ProgramShape {
-    milestones: Milestone[];
-}
-/** web-app format */
-export interface IMedia extends Omit<Media.DbRecord, "PK" | "SK" | "gsi1PK" | "gsi1SK"> {
-    featured: boolean;
-}
-export interface MediaPage extends IPageKeyed<IMedia> {
-}

package/dist/index.mjs

@@ -1 +1,2 @@
-export {};
+export * from "./interfaces.mjs";
+export { NpoDb } from "./db.mjs";