@hsuite/smart-engines-cli 1.0.0

package/dist/libs/rules-engine/src/organisms/dao.organism.d.ts

@@ -0,0 +1,3615 @@
+import { z } from 'zod';
+import { BaseOrganism } from '../base/base-rule';
+import { ValidationResult } from '../interfaces/rule.interface';
+import { GenericChainContext } from '../interfaces/chain-context.interface';
+import { SmartNodeSecurity } from '../enums/security-levels.enum';
+export declare enum DAOType {
+    TOKEN_GOVERNED = "token_governed",
+    NFT_GOVERNED = "nft_governed",
+    MULTISIG = "multisig",
+    HYBRID = "hybrid"
+}
+export declare enum TreasuryAction {
+    TRANSFER = "transfer",
+    ALLOCATE = "allocate",
+    INVEST = "invest",
+    BURN = "burn"
+}
+export declare const TreasuryAllocationSchema: z.ZodObject<{
+    name: z.ZodString;
+    recipient: z.ZodString;
+    tokenId: z.ZodString;
+    amount: z.ZodString;
+    purpose: z.ZodString;
+    requiresProposal: z.ZodDefault<z.ZodBoolean>;
+    autoApprovalThreshold: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    tokenId: string;
+    amount: string;
+    recipient: string;
+    purpose: string;
+    requiresProposal: boolean;
+    autoApprovalThreshold?: string | undefined;
+}, {
+    name: string;
+    tokenId: string;
+    amount: string;
+    recipient: string;
+    purpose: string;
+    requiresProposal?: boolean | undefined;
+    autoApprovalThreshold?: string | undefined;
+}>;
+export type TreasuryAllocation = z.infer<typeof TreasuryAllocationSchema>;
+export declare const DAOConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    daoType: z.ZodNativeEnum<typeof DAOType>;
+    smartNodeSecurity: z.ZodDefault<z.ZodNativeEnum<typeof SmartNodeSecurity>>;
+    governance: z.ZodObject<{
+        governanceTokenId: z.ZodString;
+        decimals: z.ZodDefault<z.ZodNumber>;
+        votingPowerMethod: z.ZodDefault<z.ZodNativeEnum<typeof import("../molecules/governance.molecule").VotingPowerMethod>>;
+        quorumPercent: z.ZodDefault<z.ZodNumber>;
+        approvalThresholdPercent: z.ZodDefault<z.ZodNumber>;
+        proposalThreshold: z.ZodString;
+        votingPeriodMs: z.ZodNumber;
+        timeLockMs: z.ZodDefault<z.ZodNumber>;
+        maxExecutionDelayMs: z.ZodOptional<z.ZodNumber>;
+        votingEligibility: z.ZodOptional<z.ZodObject<{
+            fungibles: z.ZodOptional<z.ZodObject<{
+                tokens: z.ZodArray<z.ZodObject<{
+                    tokenId: z.ZodString;
+                    minBalance: z.ZodString;
+                    maxBalance: z.ZodOptional<z.ZodString>;
+                    decimals: z.ZodDefault<z.ZodNumber>;
+                    checkBalance: z.ZodDefault<z.ZodBoolean>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }, {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }>, "many">;
+                operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            }, "strip", z.ZodTypeAny, {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            }, {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            }>>;
+            nonFungibles: z.ZodOptional<z.ZodObject<{
+                tokens: z.ZodArray<z.ZodObject<{
+                    tokenId: z.ZodString;
+                    serialNumbers: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    minCount: z.ZodDefault<z.ZodNumber>;
+                    requiredAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }, {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }>, "many">;
+                operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            }, "strip", z.ZodTypeAny, {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            }, {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            }>>;
+            timeRange: z.ZodOptional<z.ZodObject<{
+                from: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                to: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                timezone: z.ZodDefault<z.ZodString>;
+                inclusive: z.ZodDefault<z.ZodBoolean>;
+                recurring: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["daily", "weekly", "monthly"]>;
+                    startHour: z.ZodNumber;
+                    endHour: z.ZodNumber;
+                    daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    daysOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                }, {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            }, {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            }>>;
+            snapshot: z.ZodOptional<z.ZodObject<{
+                cid: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodDate;
+                entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    accountId: z.ZodString;
+                    balances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    nfts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber, "many">>>;
+                    nativeBalance: z.ZodOptional<z.ZodString>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strip", z.ZodTypeAny, {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }, {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }>, "many">>;
+                tokenId: z.ZodOptional<z.ZodString>;
+                validationMode: z.ZodDefault<z.ZodEnum<["exact", "minimum", "held_at_snapshot", "exists"]>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            }, {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            }>>;
+            overallOperator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            allowDelegation: z.ZodDefault<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        }, {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        }>>;
+        proposalEligibility: z.ZodOptional<z.ZodObject<{
+            fungibles: z.ZodOptional<z.ZodObject<{
+                tokens: z.ZodArray<z.ZodObject<{
+                    tokenId: z.ZodString;
+                    minBalance: z.ZodString;
+                    maxBalance: z.ZodOptional<z.ZodString>;
+                    decimals: z.ZodDefault<z.ZodNumber>;
+                    checkBalance: z.ZodDefault<z.ZodBoolean>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }, {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }>, "many">;
+                operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            }, "strip", z.ZodTypeAny, {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            }, {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            }>>;
+            nonFungibles: z.ZodOptional<z.ZodObject<{
+                tokens: z.ZodArray<z.ZodObject<{
+                    tokenId: z.ZodString;
+                    serialNumbers: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    minCount: z.ZodDefault<z.ZodNumber>;
+                    requiredAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }, {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }>, "many">;
+                operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            }, "strip", z.ZodTypeAny, {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            }, {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            }>>;
+            timeRange: z.ZodOptional<z.ZodObject<{
+                from: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                to: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                timezone: z.ZodDefault<z.ZodString>;
+                inclusive: z.ZodDefault<z.ZodBoolean>;
+                recurring: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["daily", "weekly", "monthly"]>;
+                    startHour: z.ZodNumber;
+                    endHour: z.ZodNumber;
+                    daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    daysOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                }, {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            }, {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            }>>;
+            snapshot: z.ZodOptional<z.ZodObject<{
+                cid: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodDate;
+                entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    accountId: z.ZodString;
+                    balances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    nfts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber, "many">>>;
+                    nativeBalance: z.ZodOptional<z.ZodString>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strip", z.ZodTypeAny, {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }, {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }>, "many">>;
+                tokenId: z.ZodOptional<z.ZodString>;
+                validationMode: z.ZodDefault<z.ZodEnum<["exact", "minimum", "held_at_snapshot", "exists"]>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            }, {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            }>>;
+            overallOperator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            allowDelegation: z.ZodDefault<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        }, {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        }>>;
+        allowDelegation: z.ZodDefault<z.ZodBoolean>;
+        allowVoteChange: z.ZodDefault<z.ZodBoolean>;
+        vetoCouncil: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        maxActiveProposalsPerAccount: z.ZodDefault<z.ZodNumber>;
+        proposalCooldownMs: z.ZodDefault<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        decimals: number;
+        proposalThreshold: string;
+        allowDelegation: boolean;
+        governanceTokenId: string;
+        votingPowerMethod: import("../molecules/governance.molecule").VotingPowerMethod;
+        quorumPercent: number;
+        approvalThresholdPercent: number;
+        votingPeriodMs: number;
+        timeLockMs: number;
+        allowVoteChange: boolean;
+        maxActiveProposalsPerAccount: number;
+        proposalCooldownMs: number;
+        description?: string | undefined;
+        maxExecutionDelayMs?: number | undefined;
+        votingEligibility?: {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        } | undefined;
+        proposalEligibility?: {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        } | undefined;
+        vetoCouncil?: string[] | undefined;
+    }, {
+        proposalThreshold: string;
+        governanceTokenId: string;
+        votingPeriodMs: number;
+        decimals?: number | undefined;
+        description?: string | undefined;
+        allowDelegation?: boolean | undefined;
+        votingPowerMethod?: import("../molecules/governance.molecule").VotingPowerMethod | undefined;
+        quorumPercent?: number | undefined;
+        approvalThresholdPercent?: number | undefined;
+        timeLockMs?: number | undefined;
+        maxExecutionDelayMs?: number | undefined;
+        votingEligibility?: {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        } | undefined;
+        proposalEligibility?: {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        } | undefined;
+        allowVoteChange?: boolean | undefined;
+        vetoCouncil?: string[] | undefined;
+        maxActiveProposalsPerAccount?: number | undefined;
+        proposalCooldownMs?: number | undefined;
+    }>;
+    membership: z.ZodOptional<z.ZodObject<{
+        fungibles: z.ZodOptional<z.ZodObject<{
+            tokens: z.ZodArray<z.ZodObject<{
+                tokenId: z.ZodString;
+                minBalance: z.ZodString;
+                maxBalance: z.ZodOptional<z.ZodString>;
+                decimals: z.ZodDefault<z.ZodNumber>;
+                checkBalance: z.ZodDefault<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                decimals: number;
+                tokenId: string;
+                minBalance: string;
+                checkBalance: boolean;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+            }, {
+                tokenId: string;
+                minBalance: string;
+                decimals?: number | undefined;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+                checkBalance?: boolean | undefined;
+            }>, "many">;
+            operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+        }, "strip", z.ZodTypeAny, {
+            tokens: {
+                decimals: number;
+                tokenId: string;
+                minBalance: string;
+                checkBalance: boolean;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+            }[];
+            operator: "AND" | "OR";
+        }, {
+            tokens: {
+                tokenId: string;
+                minBalance: string;
+                decimals?: number | undefined;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+                checkBalance?: boolean | undefined;
+            }[];
+            operator?: "AND" | "OR" | undefined;
+        }>>;
+        nonFungibles: z.ZodOptional<z.ZodObject<{
+            tokens: z.ZodArray<z.ZodObject<{
+                tokenId: z.ZodString;
+                serialNumbers: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                minCount: z.ZodDefault<z.ZodNumber>;
+                requiredAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                tokenId: string;
+                minCount: number;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }, {
+                tokenId: string;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                minCount?: number | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }>, "many">;
+            operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+        }, "strip", z.ZodTypeAny, {
+            tokens: {
+                tokenId: string;
+                minCount: number;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }[];
+            operator: "AND" | "OR";
+        }, {
+            tokens: {
+                tokenId: string;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                minCount?: number | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }[];
+            operator?: "AND" | "OR" | undefined;
+        }>>;
+        timeRange: z.ZodOptional<z.ZodObject<{
+            from: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+            to: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+            timezone: z.ZodDefault<z.ZodString>;
+            inclusive: z.ZodDefault<z.ZodBoolean>;
+            recurring: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["daily", "weekly", "monthly"]>;
+                startHour: z.ZodNumber;
+                endHour: z.ZodNumber;
+                daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                daysOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            }, {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            inclusive: boolean;
+            from: number;
+            to: number;
+            timezone: string;
+            recurring?: {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            } | undefined;
+        }, {
+            from: string | number | Date;
+            to: string | number | Date;
+            inclusive?: boolean | undefined;
+            timezone?: string | undefined;
+            recurring?: {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            } | undefined;
+        }>>;
+        snapshot: z.ZodOptional<z.ZodObject<{
+            cid: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodDate;
+            entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                accountId: z.ZodString;
+                balances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                nfts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber, "many">>>;
+                nativeBalance: z.ZodOptional<z.ZodString>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }, {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }>, "many">>;
+            tokenId: z.ZodOptional<z.ZodString>;
+            validationMode: z.ZodDefault<z.ZodEnum<["exact", "minimum", "held_at_snapshot", "exists"]>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: Date;
+            validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+            entries?: {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }[] | undefined;
+            tokenId?: string | undefined;
+            description?: string | undefined;
+            cid?: string | undefined;
+        }, {
+            timestamp: Date;
+            entries?: {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }[] | undefined;
+            tokenId?: string | undefined;
+            description?: string | undefined;
+            cid?: string | undefined;
+            validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+        }>>;
+        overallOperator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+        allowDelegation: z.ZodDefault<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        overallOperator: "AND" | "OR";
+        allowDelegation: boolean;
+        description?: string | undefined;
+        timeRange?: {
+            inclusive: boolean;
+            from: number;
+            to: number;
+            timezone: string;
+            recurring?: {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            } | undefined;
+        } | undefined;
+        fungibles?: {
+            tokens: {
+                decimals: number;
+                tokenId: string;
+                minBalance: string;
+                checkBalance: boolean;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+            }[];
+            operator: "AND" | "OR";
+        } | undefined;
+        nonFungibles?: {
+            tokens: {
+                tokenId: string;
+                minCount: number;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }[];
+            operator: "AND" | "OR";
+        } | undefined;
+        snapshot?: {
+            timestamp: Date;
+            validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+            entries?: {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }[] | undefined;
+            tokenId?: string | undefined;
+            description?: string | undefined;
+            cid?: string | undefined;
+        } | undefined;
+    }, {
+        description?: string | undefined;
+        timeRange?: {
+            from: string | number | Date;
+            to: string | number | Date;
+            inclusive?: boolean | undefined;
+            timezone?: string | undefined;
+            recurring?: {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            } | undefined;
+        } | undefined;
+        fungibles?: {
+            tokens: {
+                tokenId: string;
+                minBalance: string;
+                decimals?: number | undefined;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+                checkBalance?: boolean | undefined;
+            }[];
+            operator?: "AND" | "OR" | undefined;
+        } | undefined;
+        nonFungibles?: {
+            tokens: {
+                tokenId: string;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                minCount?: number | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }[];
+            operator?: "AND" | "OR" | undefined;
+        } | undefined;
+        snapshot?: {
+            timestamp: Date;
+            entries?: {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }[] | undefined;
+            tokenId?: string | undefined;
+            description?: string | undefined;
+            cid?: string | undefined;
+            validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+        } | undefined;
+        overallOperator?: "AND" | "OR" | undefined;
+        allowDelegation?: boolean | undefined;
+    }>>;
+    treasury: z.ZodObject<{
+        accountId: z.ZodString;
+        controlledTokens: z.ZodArray<z.ZodString, "many">;
+        allocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            recipient: z.ZodString;
+            tokenId: z.ZodString;
+            amount: z.ZodString;
+            purpose: z.ZodString;
+            requiresProposal: z.ZodDefault<z.ZodBoolean>;
+            autoApprovalThreshold: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            tokenId: string;
+            amount: string;
+            recipient: string;
+            purpose: string;
+            requiresProposal: boolean;
+            autoApprovalThreshold?: string | undefined;
+        }, {
+            name: string;
+            tokenId: string;
+            amount: string;
+            recipient: string;
+            purpose: string;
+            requiresProposal?: boolean | undefined;
+            autoApprovalThreshold?: string | undefined;
+        }>, "many">>;
+        autoApprovalLimit: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        accountId: string;
+        controlledTokens: string[];
+        allocations?: {
+            name: string;
+            tokenId: string;
+            amount: string;
+            recipient: string;
+            purpose: string;
+            requiresProposal: boolean;
+            autoApprovalThreshold?: string | undefined;
+        }[] | undefined;
+        autoApprovalLimit?: string | undefined;
+    }, {
+        accountId: string;
+        controlledTokens: string[];
+        allocations?: {
+            name: string;
+            tokenId: string;
+            amount: string;
+            recipient: string;
+            purpose: string;
+            requiresProposal?: boolean | undefined;
+            autoApprovalThreshold?: string | undefined;
+        }[] | undefined;
+        autoApprovalLimit?: string | undefined;
+    }>;
+    multisig: z.ZodOptional<z.ZodObject<{
+        signers: z.ZodArray<z.ZodString, "many">;
+        threshold: z.ZodNumber;
+        proposalExpirationMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        threshold: number;
+        signers: string[];
+        proposalExpirationMs: number;
+    }, {
+        threshold: number;
+        signers: string[];
+        proposalExpirationMs?: number | undefined;
+    }>>;
+    subDAOs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        purpose: z.ZodString;
+        governance: z.ZodObject<{
+            governanceTokenId: z.ZodString;
+            decimals: z.ZodDefault<z.ZodNumber>;
+            votingPowerMethod: z.ZodDefault<z.ZodNativeEnum<typeof import("../molecules/governance.molecule").VotingPowerMethod>>;
+            quorumPercent: z.ZodDefault<z.ZodNumber>;
+            approvalThresholdPercent: z.ZodDefault<z.ZodNumber>;
+            proposalThreshold: z.ZodString;
+            votingPeriodMs: z.ZodNumber;
+            timeLockMs: z.ZodDefault<z.ZodNumber>;
+            maxExecutionDelayMs: z.ZodOptional<z.ZodNumber>;
+            votingEligibility: z.ZodOptional<z.ZodObject<{
+                fungibles: z.ZodOptional<z.ZodObject<{
+                    tokens: z.ZodArray<z.ZodObject<{
+                        tokenId: z.ZodString;
+                        minBalance: z.ZodString;
+                        maxBalance: z.ZodOptional<z.ZodString>;
+                        decimals: z.ZodDefault<z.ZodNumber>;
+                        checkBalance: z.ZodDefault<z.ZodBoolean>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }, {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }>, "many">;
+                    operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                }, {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                }>>;
+                nonFungibles: z.ZodOptional<z.ZodObject<{
+                    tokens: z.ZodArray<z.ZodObject<{
+                        tokenId: z.ZodString;
+                        serialNumbers: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                        minCount: z.ZodDefault<z.ZodNumber>;
+                        requiredAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }, {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }>, "many">;
+                    operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                }, {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                }>>;
+                timeRange: z.ZodOptional<z.ZodObject<{
+                    from: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                    to: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                    timezone: z.ZodDefault<z.ZodString>;
+                    inclusive: z.ZodDefault<z.ZodBoolean>;
+                    recurring: z.ZodOptional<z.ZodObject<{
+                        type: z.ZodEnum<["daily", "weekly", "monthly"]>;
+                        startHour: z.ZodNumber;
+                        endHour: z.ZodNumber;
+                        daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                        daysOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    }, "strip", z.ZodTypeAny, {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    }, {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                }, {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                }>>;
+                snapshot: z.ZodOptional<z.ZodObject<{
+                    cid: z.ZodOptional<z.ZodString>;
+                    timestamp: z.ZodDate;
+                    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        accountId: z.ZodString;
+                        balances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        nfts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber, "many">>>;
+                        nativeBalance: z.ZodOptional<z.ZodString>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, "strip", z.ZodTypeAny, {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }, {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }>, "many">>;
+                    tokenId: z.ZodOptional<z.ZodString>;
+                    validationMode: z.ZodDefault<z.ZodEnum<["exact", "minimum", "held_at_snapshot", "exists"]>>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                }, {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                }>>;
+                overallOperator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+                allowDelegation: z.ZodDefault<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            }, {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            }>>;
+            proposalEligibility: z.ZodOptional<z.ZodObject<{
+                fungibles: z.ZodOptional<z.ZodObject<{
+                    tokens: z.ZodArray<z.ZodObject<{
+                        tokenId: z.ZodString;
+                        minBalance: z.ZodString;
+                        maxBalance: z.ZodOptional<z.ZodString>;
+                        decimals: z.ZodDefault<z.ZodNumber>;
+                        checkBalance: z.ZodDefault<z.ZodBoolean>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }, {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }>, "many">;
+                    operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                }, {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                }>>;
+                nonFungibles: z.ZodOptional<z.ZodObject<{
+                    tokens: z.ZodArray<z.ZodObject<{
+                        tokenId: z.ZodString;
+                        serialNumbers: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                        minCount: z.ZodDefault<z.ZodNumber>;
+                        requiredAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }, {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }>, "many">;
+                    operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                }, {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                }>>;
+                timeRange: z.ZodOptional<z.ZodObject<{
+                    from: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                    to: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                    timezone: z.ZodDefault<z.ZodString>;
+                    inclusive: z.ZodDefault<z.ZodBoolean>;
+                    recurring: z.ZodOptional<z.ZodObject<{
+                        type: z.ZodEnum<["daily", "weekly", "monthly"]>;
+                        startHour: z.ZodNumber;
+                        endHour: z.ZodNumber;
+                        daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                        daysOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    }, "strip", z.ZodTypeAny, {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    }, {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                }, {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                }>>;
+                snapshot: z.ZodOptional<z.ZodObject<{
+                    cid: z.ZodOptional<z.ZodString>;
+                    timestamp: z.ZodDate;
+                    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        accountId: z.ZodString;
+                        balances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                        nfts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber, "many">>>;
+                        nativeBalance: z.ZodOptional<z.ZodString>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, "strip", z.ZodTypeAny, {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }, {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }>, "many">>;
+                    tokenId: z.ZodOptional<z.ZodString>;
+                    validationMode: z.ZodDefault<z.ZodEnum<["exact", "minimum", "held_at_snapshot", "exists"]>>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                }, {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                }>>;
+                overallOperator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+                allowDelegation: z.ZodDefault<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            }, {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            }>>;
+            allowDelegation: z.ZodDefault<z.ZodBoolean>;
+            allowVoteChange: z.ZodDefault<z.ZodBoolean>;
+            vetoCouncil: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            maxActiveProposalsPerAccount: z.ZodDefault<z.ZodNumber>;
+            proposalCooldownMs: z.ZodDefault<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            decimals: number;
+            proposalThreshold: string;
+            allowDelegation: boolean;
+            governanceTokenId: string;
+            votingPowerMethod: import("../molecules/governance.molecule").VotingPowerMethod;
+            quorumPercent: number;
+            approvalThresholdPercent: number;
+            votingPeriodMs: number;
+            timeLockMs: number;
+            allowVoteChange: boolean;
+            maxActiveProposalsPerAccount: number;
+            proposalCooldownMs: number;
+            description?: string | undefined;
+            maxExecutionDelayMs?: number | undefined;
+            votingEligibility?: {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            } | undefined;
+            proposalEligibility?: {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            } | undefined;
+            vetoCouncil?: string[] | undefined;
+        }, {
+            proposalThreshold: string;
+            governanceTokenId: string;
+            votingPeriodMs: number;
+            decimals?: number | undefined;
+            description?: string | undefined;
+            allowDelegation?: boolean | undefined;
+            votingPowerMethod?: import("../molecules/governance.molecule").VotingPowerMethod | undefined;
+            quorumPercent?: number | undefined;
+            approvalThresholdPercent?: number | undefined;
+            timeLockMs?: number | undefined;
+            maxExecutionDelayMs?: number | undefined;
+            votingEligibility?: {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            } | undefined;
+            proposalEligibility?: {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            } | undefined;
+            allowVoteChange?: boolean | undefined;
+            vetoCouncil?: string[] | undefined;
+            maxActiveProposalsPerAccount?: number | undefined;
+            proposalCooldownMs?: number | undefined;
+        }>;
+        autonomy: z.ZodEnum<["full", "partial", "advisory"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        governance: {
+            decimals: number;
+            proposalThreshold: string;
+            allowDelegation: boolean;
+            governanceTokenId: string;
+            votingPowerMethod: import("../molecules/governance.molecule").VotingPowerMethod;
+            quorumPercent: number;
+            approvalThresholdPercent: number;
+            votingPeriodMs: number;
+            timeLockMs: number;
+            allowVoteChange: boolean;
+            maxActiveProposalsPerAccount: number;
+            proposalCooldownMs: number;
+            description?: string | undefined;
+            maxExecutionDelayMs?: number | undefined;
+            votingEligibility?: {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            } | undefined;
+            proposalEligibility?: {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            } | undefined;
+            vetoCouncil?: string[] | undefined;
+        };
+        purpose: string;
+        autonomy: "partial" | "full" | "advisory";
+    }, {
+        name: string;
+        governance: {
+            proposalThreshold: string;
+            governanceTokenId: string;
+            votingPeriodMs: number;
+            decimals?: number | undefined;
+            description?: string | undefined;
+            allowDelegation?: boolean | undefined;
+            votingPowerMethod?: import("../molecules/governance.molecule").VotingPowerMethod | undefined;
+            quorumPercent?: number | undefined;
+            approvalThresholdPercent?: number | undefined;
+            timeLockMs?: number | undefined;
+            maxExecutionDelayMs?: number | undefined;
+            votingEligibility?: {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            } | undefined;
+            proposalEligibility?: {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            } | undefined;
+            allowVoteChange?: boolean | undefined;
+            vetoCouncil?: string[] | undefined;
+            maxActiveProposalsPerAccount?: number | undefined;
+            proposalCooldownMs?: number | undefined;
+        };
+        purpose: string;
+        autonomy: "partial" | "full" | "advisory";
+    }>, "many">>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        permissions: z.ZodArray<z.ZodString, "many">;
+        memberTokenGate: z.ZodOptional<z.ZodObject<{
+            fungibles: z.ZodOptional<z.ZodObject<{
+                tokens: z.ZodArray<z.ZodObject<{
+                    tokenId: z.ZodString;
+                    minBalance: z.ZodString;
+                    maxBalance: z.ZodOptional<z.ZodString>;
+                    decimals: z.ZodDefault<z.ZodNumber>;
+                    checkBalance: z.ZodDefault<z.ZodBoolean>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }, {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }>, "many">;
+                operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            }, "strip", z.ZodTypeAny, {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            }, {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            }>>;
+            nonFungibles: z.ZodOptional<z.ZodObject<{
+                tokens: z.ZodArray<z.ZodObject<{
+                    tokenId: z.ZodString;
+                    serialNumbers: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    minCount: z.ZodDefault<z.ZodNumber>;
+                    requiredAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }, {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }>, "many">;
+                operator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            }, "strip", z.ZodTypeAny, {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            }, {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            }>>;
+            timeRange: z.ZodOptional<z.ZodObject<{
+                from: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                to: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodDate]>, number, string | number | Date>;
+                timezone: z.ZodDefault<z.ZodString>;
+                inclusive: z.ZodDefault<z.ZodBoolean>;
+                recurring: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["daily", "weekly", "monthly"]>;
+                    startHour: z.ZodNumber;
+                    endHour: z.ZodNumber;
+                    daysOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                    daysOfMonth: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                }, {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            }, {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            }>>;
+            snapshot: z.ZodOptional<z.ZodObject<{
+                cid: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodDate;
+                entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    accountId: z.ZodString;
+                    balances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    nfts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber, "many">>>;
+                    nativeBalance: z.ZodOptional<z.ZodString>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strip", z.ZodTypeAny, {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }, {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }>, "many">>;
+                tokenId: z.ZodOptional<z.ZodString>;
+                validationMode: z.ZodDefault<z.ZodEnum<["exact", "minimum", "held_at_snapshot", "exists"]>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            }, {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            }>>;
+            overallOperator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
+            allowDelegation: z.ZodDefault<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        }, {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        permissions: string[];
+        memberTokenGate?: {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        permissions: string[];
+        memberTokenGate?: {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        } | undefined;
+    }>, "many">>;
+    hcsTopicId: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    treasury: {
+        accountId: string;
+        controlledTokens: string[];
+        allocations?: {
+            name: string;
+            tokenId: string;
+            amount: string;
+            recipient: string;
+            purpose: string;
+            requiresProposal: boolean;
+            autoApprovalThreshold?: string | undefined;
+        }[] | undefined;
+        autoApprovalLimit?: string | undefined;
+    };
+    smartNodeSecurity: SmartNodeSecurity;
+    governance: {
+        decimals: number;
+        proposalThreshold: string;
+        allowDelegation: boolean;
+        governanceTokenId: string;
+        votingPowerMethod: import("../molecules/governance.molecule").VotingPowerMethod;
+        quorumPercent: number;
+        approvalThresholdPercent: number;
+        votingPeriodMs: number;
+        timeLockMs: number;
+        allowVoteChange: boolean;
+        maxActiveProposalsPerAccount: number;
+        proposalCooldownMs: number;
+        description?: string | undefined;
+        maxExecutionDelayMs?: number | undefined;
+        votingEligibility?: {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        } | undefined;
+        proposalEligibility?: {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        } | undefined;
+        vetoCouncil?: string[] | undefined;
+    };
+    daoType: DAOType;
+    multisig?: {
+        threshold: number;
+        signers: string[];
+        proposalExpirationMs: number;
+    } | undefined;
+    description?: string | undefined;
+    membership?: {
+        overallOperator: "AND" | "OR";
+        allowDelegation: boolean;
+        description?: string | undefined;
+        timeRange?: {
+            inclusive: boolean;
+            from: number;
+            to: number;
+            timezone: string;
+            recurring?: {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            } | undefined;
+        } | undefined;
+        fungibles?: {
+            tokens: {
+                decimals: number;
+                tokenId: string;
+                minBalance: string;
+                checkBalance: boolean;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+            }[];
+            operator: "AND" | "OR";
+        } | undefined;
+        nonFungibles?: {
+            tokens: {
+                tokenId: string;
+                minCount: number;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }[];
+            operator: "AND" | "OR";
+        } | undefined;
+        snapshot?: {
+            timestamp: Date;
+            validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+            entries?: {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }[] | undefined;
+            tokenId?: string | undefined;
+            description?: string | undefined;
+            cid?: string | undefined;
+        } | undefined;
+    } | undefined;
+    subDAOs?: {
+        name: string;
+        governance: {
+            decimals: number;
+            proposalThreshold: string;
+            allowDelegation: boolean;
+            governanceTokenId: string;
+            votingPowerMethod: import("../molecules/governance.molecule").VotingPowerMethod;
+            quorumPercent: number;
+            approvalThresholdPercent: number;
+            votingPeriodMs: number;
+            timeLockMs: number;
+            allowVoteChange: boolean;
+            maxActiveProposalsPerAccount: number;
+            proposalCooldownMs: number;
+            description?: string | undefined;
+            maxExecutionDelayMs?: number | undefined;
+            votingEligibility?: {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            } | undefined;
+            proposalEligibility?: {
+                overallOperator: "AND" | "OR";
+                allowDelegation: boolean;
+                description?: string | undefined;
+                timeRange?: {
+                    inclusive: boolean;
+                    from: number;
+                    to: number;
+                    timezone: string;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        decimals: number;
+                        tokenId: string;
+                        minBalance: string;
+                        checkBalance: boolean;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minCount: number;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator: "AND" | "OR";
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                } | undefined;
+            } | undefined;
+            vetoCouncil?: string[] | undefined;
+        };
+        purpose: string;
+        autonomy: "partial" | "full" | "advisory";
+    }[] | undefined;
+    roles?: {
+        name: string;
+        permissions: string[];
+        memberTokenGate?: {
+            overallOperator: "AND" | "OR";
+            allowDelegation: boolean;
+            description?: string | undefined;
+            timeRange?: {
+                inclusive: boolean;
+                from: number;
+                to: number;
+                timezone: string;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    decimals: number;
+                    tokenId: string;
+                    minBalance: string;
+                    checkBalance: boolean;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minCount: number;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator: "AND" | "OR";
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                validationMode: "minimum" | "exact" | "held_at_snapshot" | "exists";
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }[] | undefined;
+    hcsTopicId?: string | undefined;
+}, {
+    name: string;
+    treasury: {
+        accountId: string;
+        controlledTokens: string[];
+        allocations?: {
+            name: string;
+            tokenId: string;
+            amount: string;
+            recipient: string;
+            purpose: string;
+            requiresProposal?: boolean | undefined;
+            autoApprovalThreshold?: string | undefined;
+        }[] | undefined;
+        autoApprovalLimit?: string | undefined;
+    };
+    governance: {
+        proposalThreshold: string;
+        governanceTokenId: string;
+        votingPeriodMs: number;
+        decimals?: number | undefined;
+        description?: string | undefined;
+        allowDelegation?: boolean | undefined;
+        votingPowerMethod?: import("../molecules/governance.molecule").VotingPowerMethod | undefined;
+        quorumPercent?: number | undefined;
+        approvalThresholdPercent?: number | undefined;
+        timeLockMs?: number | undefined;
+        maxExecutionDelayMs?: number | undefined;
+        votingEligibility?: {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        } | undefined;
+        proposalEligibility?: {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        } | undefined;
+        allowVoteChange?: boolean | undefined;
+        vetoCouncil?: string[] | undefined;
+        maxActiveProposalsPerAccount?: number | undefined;
+        proposalCooldownMs?: number | undefined;
+    };
+    daoType: DAOType;
+    multisig?: {
+        threshold: number;
+        signers: string[];
+        proposalExpirationMs?: number | undefined;
+    } | undefined;
+    description?: string | undefined;
+    smartNodeSecurity?: SmartNodeSecurity | undefined;
+    membership?: {
+        description?: string | undefined;
+        timeRange?: {
+            from: string | number | Date;
+            to: string | number | Date;
+            inclusive?: boolean | undefined;
+            timezone?: string | undefined;
+            recurring?: {
+                type: "daily" | "weekly" | "monthly";
+                startHour: number;
+                endHour: number;
+                daysOfWeek?: number[] | undefined;
+                daysOfMonth?: number[] | undefined;
+            } | undefined;
+        } | undefined;
+        fungibles?: {
+            tokens: {
+                tokenId: string;
+                minBalance: string;
+                decimals?: number | undefined;
+                description?: string | undefined;
+                maxBalance?: string | undefined;
+                checkBalance?: boolean | undefined;
+            }[];
+            operator?: "AND" | "OR" | undefined;
+        } | undefined;
+        nonFungibles?: {
+            tokens: {
+                tokenId: string;
+                description?: string | undefined;
+                serialNumbers?: number[] | undefined;
+                minCount?: number | undefined;
+                requiredAttributes?: Record<string, unknown> | undefined;
+            }[];
+            operator?: "AND" | "OR" | undefined;
+        } | undefined;
+        snapshot?: {
+            timestamp: Date;
+            entries?: {
+                accountId: string;
+                metadata?: Record<string, unknown> | undefined;
+                nativeBalance?: string | undefined;
+                balances?: Record<string, string> | undefined;
+                nfts?: Record<string, number[]> | undefined;
+            }[] | undefined;
+            tokenId?: string | undefined;
+            description?: string | undefined;
+            cid?: string | undefined;
+            validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+        } | undefined;
+        overallOperator?: "AND" | "OR" | undefined;
+        allowDelegation?: boolean | undefined;
+    } | undefined;
+    subDAOs?: {
+        name: string;
+        governance: {
+            proposalThreshold: string;
+            governanceTokenId: string;
+            votingPeriodMs: number;
+            decimals?: number | undefined;
+            description?: string | undefined;
+            allowDelegation?: boolean | undefined;
+            votingPowerMethod?: import("../molecules/governance.molecule").VotingPowerMethod | undefined;
+            quorumPercent?: number | undefined;
+            approvalThresholdPercent?: number | undefined;
+            timeLockMs?: number | undefined;
+            maxExecutionDelayMs?: number | undefined;
+            votingEligibility?: {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            } | undefined;
+            proposalEligibility?: {
+                description?: string | undefined;
+                timeRange?: {
+                    from: string | number | Date;
+                    to: string | number | Date;
+                    inclusive?: boolean | undefined;
+                    timezone?: string | undefined;
+                    recurring?: {
+                        type: "daily" | "weekly" | "monthly";
+                        startHour: number;
+                        endHour: number;
+                        daysOfWeek?: number[] | undefined;
+                        daysOfMonth?: number[] | undefined;
+                    } | undefined;
+                } | undefined;
+                fungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        minBalance: string;
+                        decimals?: number | undefined;
+                        description?: string | undefined;
+                        maxBalance?: string | undefined;
+                        checkBalance?: boolean | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                nonFungibles?: {
+                    tokens: {
+                        tokenId: string;
+                        description?: string | undefined;
+                        serialNumbers?: number[] | undefined;
+                        minCount?: number | undefined;
+                        requiredAttributes?: Record<string, unknown> | undefined;
+                    }[];
+                    operator?: "AND" | "OR" | undefined;
+                } | undefined;
+                snapshot?: {
+                    timestamp: Date;
+                    entries?: {
+                        accountId: string;
+                        metadata?: Record<string, unknown> | undefined;
+                        nativeBalance?: string | undefined;
+                        balances?: Record<string, string> | undefined;
+                        nfts?: Record<string, number[]> | undefined;
+                    }[] | undefined;
+                    tokenId?: string | undefined;
+                    description?: string | undefined;
+                    cid?: string | undefined;
+                    validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+                } | undefined;
+                overallOperator?: "AND" | "OR" | undefined;
+                allowDelegation?: boolean | undefined;
+            } | undefined;
+            allowVoteChange?: boolean | undefined;
+            vetoCouncil?: string[] | undefined;
+            maxActiveProposalsPerAccount?: number | undefined;
+            proposalCooldownMs?: number | undefined;
+        };
+        purpose: string;
+        autonomy: "partial" | "full" | "advisory";
+    }[] | undefined;
+    roles?: {
+        name: string;
+        permissions: string[];
+        memberTokenGate?: {
+            description?: string | undefined;
+            timeRange?: {
+                from: string | number | Date;
+                to: string | number | Date;
+                inclusive?: boolean | undefined;
+                timezone?: string | undefined;
+                recurring?: {
+                    type: "daily" | "weekly" | "monthly";
+                    startHour: number;
+                    endHour: number;
+                    daysOfWeek?: number[] | undefined;
+                    daysOfMonth?: number[] | undefined;
+                } | undefined;
+            } | undefined;
+            fungibles?: {
+                tokens: {
+                    tokenId: string;
+                    minBalance: string;
+                    decimals?: number | undefined;
+                    description?: string | undefined;
+                    maxBalance?: string | undefined;
+                    checkBalance?: boolean | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            nonFungibles?: {
+                tokens: {
+                    tokenId: string;
+                    description?: string | undefined;
+                    serialNumbers?: number[] | undefined;
+                    minCount?: number | undefined;
+                    requiredAttributes?: Record<string, unknown> | undefined;
+                }[];
+                operator?: "AND" | "OR" | undefined;
+            } | undefined;
+            snapshot?: {
+                timestamp: Date;
+                entries?: {
+                    accountId: string;
+                    metadata?: Record<string, unknown> | undefined;
+                    nativeBalance?: string | undefined;
+                    balances?: Record<string, string> | undefined;
+                    nfts?: Record<string, number[]> | undefined;
+                }[] | undefined;
+                tokenId?: string | undefined;
+                description?: string | undefined;
+                cid?: string | undefined;
+                validationMode?: "minimum" | "exact" | "held_at_snapshot" | "exists" | undefined;
+            } | undefined;
+            overallOperator?: "AND" | "OR" | undefined;
+            allowDelegation?: boolean | undefined;
+        } | undefined;
+    }[] | undefined;
+    hcsTopicId?: string | undefined;
+}>;
+export type DAOConfig = z.infer<typeof DAOConfigSchema>;
+export interface DAOState {
+    memberCount: number;
+    totalProposals: number;
+    activeProposals: number;
+    treasuryBalances: Record<string, string>;
+    isActive: boolean;
+    createdAt: Date;
+}
+export interface DAOValidationContext extends GenericChainContext {
+    action: 'join' | 'leave' | 'propose' | 'vote' | 'execute' | 'treasury_action' | 'check_membership';
+    daoState?: DAOState;
+    treasuryAction?: {
+        type: TreasuryAction;
+        tokenId: string;
+        amount: string;
+        recipient: string;
+    };
+    roleName?: string;
+    governanceTokenBalance?: string;
+    proposalData?: any;
+}
+export declare class DAOOrganism extends BaseOrganism<DAOConfig, DAOValidationContext> {
+    private governanceMolecule;
+    private membershipGate?;
+    constructor(config: DAOConfig);
+    getSchema(): z.ZodSchema<DAOConfig>;
+    validate(context: DAOValidationContext): Promise<ValidationResult>;
+    private validateJoin;
+    private validateLeave;
+    private validatePropose;
+    private validateVote;
+    private validateExecute;
+    private validateTreasuryAction;
+    private checkMembership;
+    private checkRole;
+    getMultisigRequirements(): {
+        signers: string[];
+        threshold: number;
+    } | null;
+    getTreasuryInfo(): {
+        accountId: string;
+        controlledTokens: string[];
+        autoApprovalLimit?: string;
+    };
+    getSummary(): {
+        name: string;
+        daoType: DAOType;
+        smartNodeSecurity: SmartNodeSecurity;
+        governanceTokenId: string;
+        treasuryAccountId: string;
+        hasMultisig: boolean;
+        subDAOCount: number;
+        roleCount: number;
+    };
+}
+//# sourceMappingURL=dao.organism.d.ts.map