@degenerate/generic 0.2.6 → 0.3.2

package/dist/models/shareblock/shareblock-models.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IShareBlockMarkFullyDistributedInputSchema = exports.IShareBlockDisburseInputSchema = exports.IShareBlockFundInputSchema = exports.IShareBlockRegisterLenderInputSchema = exports.IShareBlockCommitInputSchema = exports.IShareBlockCloseInputSchema = exports.IShareBlockWithdrawInputSchema = exports.IShareBlockDepositInputSchema = exports.IShareBlockInitialStateInputSchema = exports.IShareBlockMetadataSchema = exports.IDistributionShareBlockStateSchema = exports.IFundingShareBlockStateSchema = exports.IShareBlockStateSchema = exports.IShareBlockParticipantSchema = exports.ShareBlockParticipantRoleSchema = exports.ShareBlockParticipantRole = exports.ShareBlockTypeSchema = exports.ShareBlockType = void 0;
+const zod_1 = __importDefault(require("zod"));
+//#region Enums
+/**
+ * The three ShareBlock specializations the platform uses to move money
+ * through a loan's lifecycle.
+ *
+ *   - `Clearing`     — neutral holding spot funds pass through before they're
+ *                      committed to either side of a deal. Used to net
+ *                      borrower and lender flows before settling.
+ *   - `Funding`      — the lender-funded pool that backs a specific loan.
+ *                      Holds principal between funding and disbursement.
+ *   - `Distribution` — the destination ShareBlock that pays principal to a
+ *                      borrower or returns/interest to a lender.
+ *
+ * New ShareBlock variants should be additive — never re-use a value with new
+ * semantics, since downstream rule libraries pattern-match on the literal.
+ */
+var ShareBlockType;
+(function (ShareBlockType) {
+    ShareBlockType["Clearing"] = "Clearing";
+    ShareBlockType["Funding"] = "Funding";
+    ShareBlockType["Distribution"] = "Distribution";
+})(ShareBlockType || (exports.ShareBlockType = ShareBlockType = {}));
+exports.ShareBlockTypeSchema = zod_1.default.enum([
+    'Clearing',
+    'Funding',
+    'Distribution',
+]);
+//#endregion Enums
+//#region Participant
+/**
+ * Roles a participant plays inside a ShareBlock. A single party may hold
+ * multiple roles across different ShareBlocks (e.g. the same uid is `Lender`
+ * on a Funding block and `Recipient` on a Distribution block).
+ */
+var ShareBlockParticipantRole;
+(function (ShareBlockParticipantRole) {
+    ShareBlockParticipantRole["Borrower"] = "Borrower";
+    ShareBlockParticipantRole["Lender"] = "Lender";
+    ShareBlockParticipantRole["Platform"] = "Platform";
+    ShareBlockParticipantRole["Recipient"] = "Recipient";
+})(ShareBlockParticipantRole || (exports.ShareBlockParticipantRole = ShareBlockParticipantRole = {}));
+exports.ShareBlockParticipantRoleSchema = zod_1.default.enum([
+    'Borrower',
+    'Lender',
+    'Platform',
+    'Recipient',
+]);
+/**
+ * A party in a ShareBlock with their associated role and committed amount.
+ * `committedAmount` is the headline contribution promised by the participant;
+ * `settledAmount` tracks how much has actually moved (so partial fills are
+ * representable). Both are in the ShareBlock's `currency`.
+ */
+exports.IShareBlockParticipantSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    role: exports.ShareBlockParticipantRoleSchema,
+    committedAmount: zod_1.default.number().nonnegative(),
+    settledAmount: zod_1.default.number().nonnegative(),
+});
+//#endregion Participant
+//#region State
+/**
+ * The mutable state carried inside a ShareBlock's `_currentState`. This is
+ * the canonical shape rules and functions inspect when proposing changes.
+ *
+ *   - `balance` — funds currently held in the ShareBlock. Never negative.
+ *   - `currency` — ISO-4217 code (e.g. `'USD'`, `'CAD'`). Pinned at creation.
+ *   - `isOpen` — whether the ShareBlock will accept further transactions.
+ *                Closing is irreversible; once `false`, all standard rules
+ *                reject mutating proposals.
+ *   - `participants` — committed parties keyed by `userId`. Adding a
+ *                participant goes through a rule-gated function so the
+ *                participant list itself is auditable.
+ */
+exports.IShareBlockStateSchema = zod_1.default.object({
+    blockType: exports.ShareBlockTypeSchema,
+    balance: zod_1.default.number().nonnegative(),
+    currency: zod_1.default.string().min(3).max(3),
+    isOpen: zod_1.default.boolean(),
+    participants: zod_1.default.record(zod_1.default.string(), exports.IShareBlockParticipantSchema),
+});
+/**
+ * Funding-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `committed` — once `true`, the block's funds are locked: deposits and
+ *                   withdrawals become no-ops, and a "committed-is-monotonic"
+ *                   rule blocks any proposal that flips it back to `false`.
+ *   - `committedBy` / `committedAt` — audit attribution for the commit moment.
+ *
+ * Clearing ShareBlocks don't carry these fields; the discriminator is the
+ * `blockType` on the base state.
+ */
+exports.IFundingShareBlockStateSchema = exports.IShareBlockStateSchema.extend({
+    blockType: zod_1.default.literal(exports.ShareBlockTypeSchema.enum.Funding),
+    committed: zod_1.default.boolean(),
+    committedBy: zod_1.default.string().optional(),
+    committedAt: zod_1.default.number().optional(),
+});
+/**
+ * Distribution-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `distributed` — once `true`, the block is fully paid out and further
+ *                     disbursements become no-ops. Enforced as monotonic by
+ *                     a dedicated rule (mirrors Funding's `committed`).
+ *   - `distributedAt` — audit attribution for the moment the block was
+ *                       marked fully distributed.
+ *
+ * Clearing ShareBlocks don't carry these fields; the discriminator is the
+ * `blockType` on the base state.
+ */
+exports.IDistributionShareBlockStateSchema = exports.IShareBlockStateSchema.extend({
+    blockType: zod_1.default.literal(exports.ShareBlockTypeSchema.enum.Distribution),
+    distributed: zod_1.default.boolean(),
+    distributedBy: zod_1.default.string().optional(),
+    distributedAt: zod_1.default.number().optional(),
+});
+//#endregion State
+//#region Metadata
+/**
+ * Static information about a ShareBlock — set at construction and never
+ * mutated through transactions. Lives outside `IShareBlockState` because
+ * the rule-evaluation engine compares state shapes, and including identity
+ * metadata in that comparison would treat any new ShareBlock as a "change."
+ */
+exports.IShareBlockMetadataSchema = zod_1.default.object({
+    shareBlockId: zod_1.default.string(),
+    blockType: exports.ShareBlockTypeSchema,
+    relatedLoanApplicationId: zod_1.default.string().optional(),
+    description: zod_1.default.string().optional(),
+    createdAt: zod_1.default.number(),
+    createdBy: zod_1.default.string(),
+});
+/**
+ * Input shape every ShareBlock factory's `initialState` argument accepts.
+ * The factory layers the variant-specific defaults on top (`blockType`,
+ * `committed: false`, `distributed: false`, `isOpen: true`) — callers only
+ * supply the genuinely variant-agnostic fields.
+ *
+ * Used by the HTTP create route to validate the wire payload before
+ * dispatching to the matching factory.
+ */
+exports.IShareBlockInitialStateInputSchema = zod_1.default.object({
+    currency: zod_1.default.string().min(3).max(3),
+    participants: zod_1.default.record(zod_1.default.string(), exports.IShareBlockParticipantSchema),
+    balance: zod_1.default.number().nonnegative().optional(),
+});
+//#endregion Metadata
+//#region Transaction Function Inputs
+/**
+ * Input shapes for the standard ShareBlock mutating functions. Each function
+ * the factory wires up takes one of these and proposes a new
+ * `IShareBlockState`. Rules judge the transition; the ShareData container
+ * applies it iff every rule passes.
+ */
+exports.IShareBlockDepositInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    amount: zod_1.default.number().positive(),
+});
+exports.IShareBlockWithdrawInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    amount: zod_1.default.number().positive(),
+});
+exports.IShareBlockCloseInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(), // Who is closing the block — used for audit attribution.
+});
+/**
+ * Input for the Funding-specific `commit` function. Records who pulled the
+ * trigger on locking the funded amount; the function itself stamps
+ * `committedAt` from the system clock.
+ */
+exports.IShareBlockCommitInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+});
+/**
+ * Input for the Funding-specific `registerLender` function. Adds a new
+ * `Lender`-role participant to the block so they can subsequently
+ * `deposit` (deposit gates on participant.role === Lender).
+ *
+ * The caller (Rapture's authenticated endpoint) is responsible for
+ * authorizing the registration — i.e. for confirming that `userId` is the
+ * authenticated user pledging on this loan. The shareblock layer just
+ * enforces structural invariants (no duplicate userId, positive
+ * committedAmount, block must be open and not committed).
+ */
+exports.IShareBlockRegisterLenderInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    committedAmount: zod_1.default.number().positive().finite(),
+});
+/**
+ * Input for the Distribution-specific `fund` function. Distinct from
+ * `IShareBlockDepositInput` only at the type level: keeps the wire shape
+ * narrow to "money coming in from another block" semantics rather than the
+ * general-purpose deposit on Clearing.
+ */
+exports.IShareBlockFundInputSchema = zod_1.default.object({
+    fromBlockId: zod_1.default.string().optional(), // upstream block id when known
+    amount: zod_1.default.number().positive(),
+});
+/**
+ * Input for the Distribution-specific `disburse` function. `userId` must
+ * resolve to a participant with role `Recipient`, or the function no-ops.
+ */
+exports.IShareBlockDisburseInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    amount: zod_1.default.number().positive(),
+});
+/**
+ * Input for the Distribution-specific `markFullyDistributed` function.
+ * Records who declared the block fully paid out; the function stamps
+ * `distributedAt`.
+ */
+exports.IShareBlockMarkFullyDistributedInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+});
+//#endregion Transaction Function Inputs

package/dist/transactions/authority/create-safe-transaction-authority-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-safe-transaction-authority-data.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority-data.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACtB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,6BAA6B,EAAE,MAAM,gEAAgE,CAAC;AAE/G;;;;;;;;GAQG;AACH,QAAA,MAAM,kCAAkC,wBACf,mBAAmB,0BAChB,MAAM,2BACL,uBAAuB,iBACjC,mBAAmB,EAAE,KACrC,6BAOF,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}
+{"version":3,"file":"create-safe-transaction-authority-data.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority-data.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACtB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,6BAA6B,EAAE,MAAM,gEAAgE,CAAC;AAE/G;;;;;;;;GAQG;AACH,QAAA,MAAM,kCAAkC,GACpC,qBAAqB,mBAAmB,EACxC,wBAAwB,MAAM,EAC9B,yBAAyB,uBAAuB,EAChD,eAAe,mBAAmB,EAAE,KACrC,6BAOF,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}

package/dist/transactions/authority/create-safe-transaction-authority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-safe-transaction-authority.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,yBAAyB,EAE5B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACH,6BAA6B,EAC7B,yBAAyB,EAC5B,MAAM,gEAAgE,CAAC;AAExE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,8BAA8B,uBACZ,MAAM,sBACN,MAAM,qBACP,yBAAyB,QACtC,6BAA6B,2CAGpC,yBAYF,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}
+{"version":3,"file":"create-safe-transaction-authority.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,yBAAyB,EAE5B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACH,6BAA6B,EAC7B,yBAAyB,EAC5B,MAAM,gEAAgE,CAAC;AAExE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,8BAA8B,GAChC,oBAAoB,MAAM,EAC1B,oBAAoB,MAAM,EAC1B,mBAAmB,yBAAyB,EAC5C,MAAM,6BAA6B,EACnC,gBAAW,EACX,kBAAsB,KACvB,yBAYF,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

package/package.json

@@ -1,14 +1,23 @@
 {
   "name": "@degenerate/generic",
-  "version": "0.2.6",
+  "version": "0.3.2",
   "description": "This contains the generic information needed for the ShareData Adaptive Framework Ecosystem (SAFE) network",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
     "compile": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
-    "test": "jest --forceExit --detectOpenHandles --verbose --silent=false --env node --config tsconfig.pkg.json",
-    "test:coverage": "jest --forceExit --coverage --detectOpenHandles --verbose --silent=false --env node  --config tsconfig.pkg.json",
+    "test": "jest --forceExit --detectOpenHandles --verbose --silent=false --env node",
+    "test:coverage": "jest --forceExit --coverage --detectOpenHandles --verbose --silent=false --env node ",
     "test:clearCache": "jest --clearCache"
   },
   "repository": {
@@ -32,27 +41,29 @@
     "@types/elliptic": "^6.4.18",
     "bip39": "^3.1.0",
     "elliptic": "^6.6.1",
-    "firebase-admin": "^13.0.1",
-    "firebase-functions": "^6.1.2",
-    "jsonwebtoken": "^9.0.2",
-    "zod": "^3.24.1"
+    "firebase-admin": "^13.9.0",
+    "jsonwebtoken": "^9.0.3",
+    "zod": "^4.4.3"
   },
-  "gitHead": "a1ef457f3b707fb642b2e3296239c74bd75614b8",
+  "gitHead": "c33ed2f06679f5bd76c2eccf7054212c1820a014",
   "devDependencies": {
-    "@eslint/js": "^9.17.0",
+    "@eslint/js": "^10.0.1",
     "@types/eslint__js": "^8.42.3",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.10.2",
-    "@typescript-eslint/eslint-plugin": "^8.18.1",
-    "@typescript-eslint/parser": "^8.18.1",
-    "eslint": "^9.17.0",
-    "eslint-import-resolver-typescript": "^3.7.0",
-    "eslint-plugin-import": "^2.31.0",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "ts-jest": "^29.2.5",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.19.18",
+    "@typescript-eslint/eslint-plugin": "^8.59.3",
+    "@typescript-eslint/parser": "^8.59.3",
+    "eslint": "^10.3.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.4.2",
+    "jest-environment-jsdom": "^30.4.1",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.18.1"
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.3"
+  },
+  "engines": {
+    "node": ">=22"
   }
 }

package/dist/models/share-data/share-data.d.ts

@@ -1,181 +0,0 @@
-import z from 'zod';
-/**
- * This contains the data for the share data object
- */
-export declare enum ShareDataTypes {
-    AUTHORIZATION = "AUTHORIZATION",
-    RULE = "RULE",
-    FUNCTION = "FUNCTION",
-    TRANSACTION_HISTORY = "TRANSACTION_HISTORY",
-    DATA = "DATA"
-}
-export declare const ShareDataTypesSchema: z.ZodEnum<["AUTHORIZATION", "RULE", "FUNCTION", "TRANSACTION_HISTORY", "DATA"]>;
-/**
- * This contains the interface for a data in a share data object
- */
-export declare const IShareDataSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
-export type IShareData = z.infer<typeof IShareDataSchema>;
-/**
- * This contains the interface for a share function record in the share data object
- */
-export declare const IShareFunctionRecordSchema: z.ZodObject<{
-    id: z.ZodString;
-    groupingId: z.ZodString;
-    groupingName: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodString;
-    hash: z.ZodString;
-    stringifiedFunction: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    stringifiedFunction: string;
-    id: string;
-    name: string;
-    description: string;
-    groupingId: string;
-    groupingName: string;
-    hash: string;
-}, {
-    stringifiedFunction: string;
-    id: string;
-    name: string;
-    description: string;
-    groupingId: string;
-    groupingName: string;
-    hash: string;
-}>;
-export type IShareFunctionRecord = z.infer<typeof IShareFunctionRecordSchema>;
-/**
- * This contains the interface for a share function in the share data object
- */
-export declare const IShareFunctionSchema: z.ZodObject<{
-    input: z.ZodAny;
-    func: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-    output: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    func: (...args: unknown[]) => unknown;
-    output?: any;
-    input?: any;
-}, {
-    func: (...args: unknown[]) => unknown;
-    output?: any;
-    input?: any;
-}>;
-export interface IShareFunction<TInput, TFunction extends (...args: any[]) => any, TOutput> {
-    input: TInput;
-    func: TFunction;
-    output: TOutput;
-}
-/**
- * This contains the interface for the rule failures in the share data object
- */
-export declare const IShareDataRuleFailuresSchema: z.ZodObject<{
-    ruleId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    ruleId: string;
-}, {
-    ruleId: string;
-}>;
-export type IShareDataRuleFailures = z.infer<typeof IShareDataRuleFailuresSchema>;
-/**
- * This contains the interface for the share transaction history in the share data object
- */
-export declare const IShareDataTransactionBaseSchema: z.ZodObject<{
-    ruleOutcome: z.ZodBoolean;
-    ruleFailures: z.ZodArray<z.ZodObject<{
-        ruleId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        ruleId: string;
-    }, {
-        ruleId: string;
-    }>, "many">;
-    transactionFunction: z.ZodObject<{
-        input: z.ZodAny;
-        func: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-        output: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-}, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-}>;
-export type IShareDataTransactionBase = z.infer<typeof IShareDataTransactionBaseSchema>;
-/**
- * This contains the interface for the share transaction history in the share data object
- * This is done for storage
- */
-export declare const IShareDataTransactionHistorySchema: z.ZodObject<z.objectUtil.extendShape<{
-    ruleOutcome: z.ZodBoolean;
-    ruleFailures: z.ZodArray<z.ZodObject<{
-        ruleId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        ruleId: string;
-    }, {
-        ruleId: string;
-    }>, "many">;
-    transactionFunction: z.ZodObject<{
-        input: z.ZodAny;
-        func: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-        output: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }>;
-}, {
-    transactionId: z.ZodString;
-    transactionTime: z.ZodNumber;
-}>, "strip", z.ZodTypeAny, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-    transactionId: string;
-    transactionTime: number;
-}, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-    transactionId: string;
-    transactionTime: number;
-}>;
-export type IShareDataTransactionHistory = z.infer<typeof IShareDataTransactionHistorySchema>;
-//# sourceMappingURL=share-data.d.ts.map

package/dist/models/share-data/share-data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"share-data.d.ts","sourceRoot":"","sources":["../../../src/models/share-data/share-data.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB;;GAEG;AACH,oBAAY,cAAc;IACtB,aAAa,kBAAkB;IAC/B,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,mBAAmB,wBAAwB;IAC3C,IAAI,SAAS;CAChB;AAED,eAAO,MAAM,oBAAoB,iFAM/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oCAAoB,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;EAQrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAGH,MAAM,WAAW,cAAc,CAAC,MAAM,EAAE,SAAS,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,OAAO;IACtF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACnB;AAGD;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;EAEvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;GAGG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC"}