@xyo-network/payload-plugins 7.0.3 → 7.1.0

package/dist/neutral/modules/crypto-contract-function-read/Payload.d.ts

@@ -0,0 +1,341 @@
+import type { WitnessConfig } from '@xyo-network/sdk';
+import type { JsonFragment } from 'ethers';
+import * as z from 'zod/mini';
+export declare const CryptoContractFunctionReadWitnessConfigSchema: "network.xyo.crypto.contract.function.read.config" & {
+    readonly __schema: true;
+};
+export type CryptoContractFunctionReadWitnessConfigSchema = typeof CryptoContractFunctionReadWitnessConfigSchema;
+export declare const AbiZod: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniCustom<string | JsonFragment, string | JsonFragment>>]>;
+export type Abi = string | readonly (JsonFragment | string)[];
+export type CryptoContractFunctionReadWitnessConfig = WitnessConfig<{
+    abi: Abi;
+    address?: string;
+    args?: unknown[];
+    functionName?: string;
+    schema: CryptoContractFunctionReadWitnessConfigSchema;
+}>;
+export declare const CryptoContractFunctionCallSchema: "network.xyo.crypto.contract.function.call" & {
+    readonly __schema: true;
+};
+export type CryptoContractFunctionCallSchema = typeof CryptoContractFunctionCallSchema;
+export declare const CryptoContractFunctionCallZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.crypto.contract.function.call" & {
+        readonly __schema: true;
+    }>;
+    address: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    args: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
+    functionName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type CryptoContractFunctionCall = z.infer<typeof CryptoContractFunctionCallZod>;
+export declare const isCryptoContractFunctionCall: <T>(value: T) => value is T & {
+    schema: "network.xyo.crypto.contract.function.call" & {
+        readonly __schema: true;
+    };
+    address?: string | undefined;
+    args?: unknown[] | undefined;
+    functionName?: string | undefined;
+};
+export declare const asCryptoContractFunctionCall: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.crypto.contract.function.call" & {
+            readonly __schema: true;
+        };
+        address?: string | undefined;
+        args?: unknown[] | undefined;
+        functionName?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.crypto.contract.function.call" & {
+            readonly __schema: true;
+        };
+        address?: string | undefined;
+        args?: unknown[] | undefined;
+        functionName?: string | undefined;
+    };
+};
+export declare const toCryptoContractFunctionCall: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.crypto.contract.function.call" & {
+            readonly __schema: true;
+        };
+        address?: string | undefined;
+        args?: unknown[] | undefined;
+        functionName?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.crypto.contract.function.call" & {
+            readonly __schema: true;
+        };
+        address?: string | undefined;
+        args?: unknown[] | undefined;
+        functionName?: string | undefined;
+    };
+};
+export declare const CryptoContractFunctionCallResultSchema: "network.xyo.crypto.contract.function.call.result" & {
+    readonly __schema: true;
+};
+export type CryptoContractFunctionCallResultSchema = typeof CryptoContractFunctionCallResultSchema;
+export declare const CryptoContractFunctionCallResultBaseZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    }>;
+    address: z.ZodMiniString<string>;
+    args: z.ZodMiniArray<z.ZodMiniUnknown>;
+    chainId: z.ZodMiniNumber<number>;
+    functionName: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type CryptoContractFunctionCallResultBase = z.infer<typeof CryptoContractFunctionCallResultBaseZod>;
+export declare const CryptoContractFunctionCallSuccessZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    }>;
+    address: z.ZodMiniString<string>;
+    args: z.ZodMiniArray<z.ZodMiniUnknown>;
+    chainId: z.ZodMiniNumber<number>;
+    functionName: z.ZodMiniString<string>;
+    result: z.ZodMiniUnknown;
+}, z.core.$strip>;
+export type CryptoContractFunctionCallSuccess = CryptoContractFunctionCallResultBase & {
+    result: unknown;
+};
+export declare const CryptoContractFunctionCallFailureZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    }>;
+    address: z.ZodMiniString<string>;
+    args: z.ZodMiniArray<z.ZodMiniUnknown>;
+    chainId: z.ZodMiniNumber<number>;
+    functionName: z.ZodMiniString<string>;
+    error: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type CryptoContractFunctionCallFailure = CryptoContractFunctionCallResultBase & {
+    error: string;
+};
+export declare const CryptoContractFunctionCallResultZod: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    }>;
+    address: z.ZodMiniString<string>;
+    args: z.ZodMiniArray<z.ZodMiniUnknown>;
+    chainId: z.ZodMiniNumber<number>;
+    functionName: z.ZodMiniString<string>;
+    result: z.ZodMiniUnknown;
+}, z.core.$strip>, z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    }>;
+    address: z.ZodMiniString<string>;
+    args: z.ZodMiniArray<z.ZodMiniUnknown>;
+    chainId: z.ZodMiniNumber<number>;
+    functionName: z.ZodMiniString<string>;
+    error: z.ZodMiniString<string>;
+}, z.core.$strip>]>;
+export type CryptoContractFunctionCallResult = CryptoContractFunctionCallSuccess | CryptoContractFunctionCallFailure;
+export declare const isCryptoContractFunctionCallResult: <T>(value: T) => value is T & ({
+    schema: "network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    };
+    address: string;
+    args: unknown[];
+    chainId: number;
+    functionName: string;
+    result: unknown;
+} | {
+    schema: "network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    };
+    address: string;
+    args: unknown[];
+    chainId: number;
+    functionName: string;
+    error: string;
+});
+export declare const asCryptoContractFunctionCallResult: {
+    <T>(value: T): (T & ({
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    } | {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    })) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & ({
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    } | {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    });
+};
+export declare const toCryptoContractFunctionCallResult: {
+    <T>(value: T): (T & ({
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    } | {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    })) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & ({
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    } | {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    });
+};
+export declare const isCryptoContractFunctionCallSuccess: <T>(value: T) => value is T & {
+    schema: "network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    };
+    address: string;
+    args: unknown[];
+    chainId: number;
+    functionName: string;
+    result: unknown;
+};
+export declare const asCryptoContractFunctionCallSuccess: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    };
+};
+export declare const toCryptoContractFunctionCallSuccess: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        result: unknown;
+    };
+};
+export declare const isCryptoContractFunctionCallFailure: <T>(value: T) => value is T & {
+    schema: "network.xyo.crypto.contract.function.call.result" & {
+        readonly __schema: true;
+    };
+    address: string;
+    args: unknown[];
+    chainId: number;
+    functionName: string;
+    error: string;
+};
+export declare const asCryptoContractFunctionCallFailure: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    };
+};
+export declare const toCryptoContractFunctionCallFailure: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.crypto.contract.function.call.result" & {
+            readonly __schema: true;
+        };
+        address: string;
+        args: unknown[];
+        chainId: number;
+        functionName: string;
+        error: string;
+    };
+};
+//# sourceMappingURL=Payload.d.ts.map

package/dist/neutral/modules/crypto-contract-function-read/Payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../src/modules/crypto-contract-function-read/Payload.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAC1C,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,6CAA6C;;CAAqE,CAAA;AAC/H,MAAM,MAAM,6CAA6C,GAAG,OAAO,6CAA6C,CAAA;AAEhH,eAAO,MAAM,MAAM,mIAAoE,CAAA;AAEvF,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,SAAS,CAAC,YAAY,GAAG,MAAM,CAAC,EAAE,CAAA;AAE7D,MAAM,MAAM,uCAAuC,GAAG,aAAa,CAAC;IAClE,GAAG,EAAE,GAAG,CAAA;IACR,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,6CAA6C,CAAA;CACtD,CAAC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;CAA8D,CAAA;AAC3G,MAAM,MAAM,gCAAgC,GAAG,OAAO,gCAAgC,CAAA;AAEtF,eAAO,MAAM,6BAA6B;;;;;;;iBAIxC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEtF,eAAO,MAAM,4BAA4B;;;;;;;CAA8C,CAAA;AACvF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;CAA8E,CAAA;AACvH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;CAA8E,CAAA;AAEvH,eAAO,MAAM,sCAAsC;;CAAqE,CAAA;AACxH,MAAM,MAAM,sCAAsC,GAAG,OAAO,sCAAsC,CAAA;AAElG,eAAO,MAAM,uCAAuC;;;;;;;;iBAKlD,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAA;AAE1G,eAAO,MAAM,oCAAoC;;;;;;;;;iBAEgC,CAAA;AAEjF,MAAM,MAAM,iCAAiC,GAAG,oCAAoC,GAAG;IACrF,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;iBAA2E,CAAA;AAE5H,MAAM,MAAM,iCAAiC,GAAG,oCAAoC,GAAG;IACrF,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;mBAAwF,CAAA;AAExI,MAAM,MAAM,gCAAgC,GAAG,iCAAiC,GAAG,iCAAiC,CAAA;AAEpH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;EAAoD,CAAA;AACnG,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0F,CAAA;AACzI,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0F,CAAA;AAEzI,eAAO,MAAM,mCAAmC;;;;;;;;;CAAqD,CAAA;AACrG,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;CAA4F,CAAA;AAC5I,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;CAA4F,CAAA;AAE5I,eAAO,MAAM,mCAAmC;;;;;;;;;CAAqD,CAAA;AACrG,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;CAA4F,CAAA;AAC5I,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;CAA4F,CAAA"}

package/dist/neutral/modules/crypto-contract-function-read/Plugin.d.ts

@@ -0,0 +1,3 @@
+import type { CryptoContractFunctionCallResult } from './Payload.js';
+export declare const CryptoContractFunctionCallPayloadPlugin: () => import("@xyo-network/sdk").PayloadPlugin<CryptoContractFunctionCallResult>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/neutral/modules/crypto-contract-function-read/Plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../../../src/modules/crypto-contract-function-read/Plugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,cAAc,CAAA;AAGpE,eAAO,MAAM,uCAAuC,kFACuD,CAAA"}

package/dist/neutral/modules/crypto-contract-function-read/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Diviner/index.js';
+export * from './Payload.js';
+export { CryptoContractFunctionCallPayloadPlugin, CryptoContractFunctionCallPayloadPlugin as default } from './Plugin.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/crypto-contract-function-read/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/crypto-contract-function-read/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA;AAC5B,OAAO,EAAE,uCAAuC,EAAE,uCAAuC,IAAI,OAAO,EAAE,MAAM,aAAa,CAAA"}

package/dist/neutral/modules/crypto-market/index.d.ts

@@ -0,0 +1,7 @@
+export * from '../coingecko-crypto-market/index.js';
+export * from '../crypto-asset/index.js';
+export * from '../uniswap-crypto-market/index.js';
+import type { PayloadPluginFunc } from '@xyo-network/sdk';
+export declare const CryptoMarketPayloadPlugins: PayloadPluginFunc[];
+export default CryptoMarketPayloadPlugins;
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/crypto-market/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/crypto-market/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,wBAAwB,CAAA;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAMzD,eAAO,MAAM,0BAA0B,EAAE,iBAAiB,EAIzD,CAAA;AAED,eAAe,0BAA0B,CAAA"}

package/dist/neutral/modules/crypto-nft/Diviner/Config.d.ts

@@ -0,0 +1,9 @@
+import type { DivinerConfig } from '@xyo-network/sdk';
+export type NftScoreDivinerConfigSchema = typeof NftScoreDivinerConfigSchema;
+export declare const NftScoreDivinerConfigSchema: string & {
+    readonly __schema: true;
+};
+export type NftScoreDivinerConfig = DivinerConfig<{
+    schema: NftScoreDivinerConfigSchema;
+}>;
+//# sourceMappingURL=Config.d.ts.map

package/dist/neutral/modules/crypto-nft/Diviner/Config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../../../src/modules/crypto-nft/Diviner/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAKrD,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA;AAC5E,eAAO,MAAM,2BAA2B;;CAAqD,CAAA;AAE7F,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC;IAAE,MAAM,EAAE,2BAA2B,CAAA;CAAE,CAAC,CAAA"}

package/dist/neutral/modules/crypto-nft/Diviner/Payload.d.ts

@@ -0,0 +1,122 @@
+import * as z from 'zod/mini';
+import type { Score } from '../../crypto-nft-score/index.js';
+export declare const AttributesScoringCriteriaZod: z.ZodMiniLiteral<"Attributes">;
+export type AttributesScoringCriteria = z.infer<typeof AttributesScoringCriteriaZod>;
+export declare const MetadataScoringCriteriaZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Animation URL">, z.ZodMiniLiteral<"Background Color">, z.ZodMiniLiteral<"Description">, z.ZodMiniLiteral<"External Url">, z.ZodMiniLiteral<"Image">, z.ZodMiniLiteral<"Image Data">, z.ZodMiniLiteral<"Name">, z.ZodMiniLiteral<"YouTube URL">, z.ZodMiniLiteral<"Attributes">]>;
+export type MetadataScoringCriteria = z.infer<typeof MetadataScoringCriteriaZod>;
+export declare const ScoringCriteriaZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Contract Address">, z.ZodMiniLiteral<"Supply">, z.ZodMiniLiteral<"Token Id">, z.ZodMiniLiteral<"Type">, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Animation URL">, z.ZodMiniLiteral<"Background Color">, z.ZodMiniLiteral<"Description">, z.ZodMiniLiteral<"External Url">, z.ZodMiniLiteral<"Image">, z.ZodMiniLiteral<"Image Data">, z.ZodMiniLiteral<"Name">, z.ZodMiniLiteral<"YouTube URL">, z.ZodMiniLiteral<"Attributes">]>]>;
+export type ScoringCriteria = z.infer<typeof ScoringCriteriaZod>;
+export declare const ScoringCriteriaKeyZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Contract Address">, z.ZodMiniLiteral<"Supply">, z.ZodMiniLiteral<"Token Id">, z.ZodMiniLiteral<"Type">, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Animation URL">, z.ZodMiniLiteral<"Background Color">, z.ZodMiniLiteral<"Description">, z.ZodMiniLiteral<"External Url">, z.ZodMiniLiteral<"Image">, z.ZodMiniLiteral<"Image Data">, z.ZodMiniLiteral<"Name">, z.ZodMiniLiteral<"YouTube URL">, z.ZodMiniLiteral<"Attributes">]>]>;
+export type ScoringCriteriaKey = ScoringCriteria;
+export declare const NftAnalysisZod: z.ZodMiniRecord<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Contract Address">, z.ZodMiniLiteral<"Supply">, z.ZodMiniLiteral<"Token Id">, z.ZodMiniLiteral<"Type">, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Animation URL">, z.ZodMiniLiteral<"Background Color">, z.ZodMiniLiteral<"Description">, z.ZodMiniLiteral<"External Url">, z.ZodMiniLiteral<"Image">, z.ZodMiniLiteral<"Image Data">, z.ZodMiniLiteral<"Name">, z.ZodMiniLiteral<"YouTube URL">, z.ZodMiniLiteral<"Attributes">]>]>, z.ZodMiniCustom<[number, number] | [number, 1], [number, number] | [number, 1]>>;
+export type NftAnalysis = Record<ScoringCriteriaKey, Score>;
+export declare const NftScoresZod: z.ZodMiniObject<{
+    scores: z.ZodMiniRecord<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Contract Address">, z.ZodMiniLiteral<"Supply">, z.ZodMiniLiteral<"Token Id">, z.ZodMiniLiteral<"Type">, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Animation URL">, z.ZodMiniLiteral<"Background Color">, z.ZodMiniLiteral<"Description">, z.ZodMiniLiteral<"External Url">, z.ZodMiniLiteral<"Image">, z.ZodMiniLiteral<"Image Data">, z.ZodMiniLiteral<"Name">, z.ZodMiniLiteral<"YouTube URL">, z.ZodMiniLiteral<"Attributes">]>]>, z.ZodMiniCustom<[number, number] | [number, 1], [number, number] | [number, 1]>>;
+}, z.core.$strip>;
+export type NftScores = Omit<z.infer<typeof NftScoresZod>, 'scores'> & {
+    scores: NftAnalysis;
+};
+export declare const NftScoreFieldsZod: z.ZodMiniObject<{
+    sources: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    scores: z.ZodMiniRecord<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Contract Address">, z.ZodMiniLiteral<"Supply">, z.ZodMiniLiteral<"Token Id">, z.ZodMiniLiteral<"Type">, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Animation URL">, z.ZodMiniLiteral<"Background Color">, z.ZodMiniLiteral<"Description">, z.ZodMiniLiteral<"External Url">, z.ZodMiniLiteral<"Image">, z.ZodMiniLiteral<"Image Data">, z.ZodMiniLiteral<"Name">, z.ZodMiniLiteral<"YouTube URL">, z.ZodMiniLiteral<"Attributes">]>]>, z.ZodMiniCustom<[number, number] | [number, 1], [number, number] | [number, 1]>>;
+    address: z.ZodMiniString<string>;
+    chainId: z.ZodMiniNumber<number>;
+    implementation: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    type: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>;
+    types: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>>;
+}, z.core.$strip>;
+export type NftScoreFields = Omit<z.infer<typeof NftScoreFieldsZod>, 'scores'> & {
+    scores: NftAnalysis;
+};
+export declare const NftScoreZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<string & {
+        readonly __schema: true;
+    }>;
+    sources: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    scores: z.ZodMiniRecord<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Contract Address">, z.ZodMiniLiteral<"Supply">, z.ZodMiniLiteral<"Token Id">, z.ZodMiniLiteral<"Type">, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Animation URL">, z.ZodMiniLiteral<"Background Color">, z.ZodMiniLiteral<"Description">, z.ZodMiniLiteral<"External Url">, z.ZodMiniLiteral<"Image">, z.ZodMiniLiteral<"Image Data">, z.ZodMiniLiteral<"Name">, z.ZodMiniLiteral<"YouTube URL">, z.ZodMiniLiteral<"Attributes">]>]>, z.ZodMiniCustom<[number, number] | [number, 1], [number, number] | [number, 1]>>;
+    address: z.ZodMiniString<string>;
+    chainId: z.ZodMiniNumber<number>;
+    implementation: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    type: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>;
+    types: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>>;
+}, z.core.$strip>;
+export type NftScore = Omit<z.infer<typeof NftScoreZod>, 'scores'> & {
+    scores: NftAnalysis;
+};
+export declare const isNftScore: <T>(value: T) => value is T & {
+    schema: string & {
+        readonly __schema: true;
+    };
+    scores: Record<"Attributes" | "Animation URL" | "Background Color" | "Description" | "External Url" | "Image" | "Image Data" | "Name" | "YouTube URL" | "Contract Address" | "Supply" | "Token Id" | "Type", [number, number] | [number, 1]>;
+    address: string;
+    chainId: number;
+    sources?: string[] | undefined;
+    implementation?: string | undefined;
+    type?: "ERC721" | "ERC1155" | null | undefined;
+    types?: ("ERC721" | "ERC1155" | null)[] | undefined;
+};
+export declare const asNftScore: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        scores: Record<"Attributes" | "Animation URL" | "Background Color" | "Description" | "External Url" | "Image" | "Image Data" | "Name" | "YouTube URL" | "Contract Address" | "Supply" | "Token Id" | "Type", [number, number] | [number, 1]>;
+        address: string;
+        chainId: number;
+        sources?: string[] | undefined;
+        implementation?: string | undefined;
+        type?: "ERC721" | "ERC1155" | null | undefined;
+        types?: ("ERC721" | "ERC1155" | null)[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        scores: Record<"Attributes" | "Animation URL" | "Background Color" | "Description" | "External Url" | "Image" | "Image Data" | "Name" | "YouTube URL" | "Contract Address" | "Supply" | "Token Id" | "Type", [number, number] | [number, 1]>;
+        address: string;
+        chainId: number;
+        sources?: string[] | undefined;
+        implementation?: string | undefined;
+        type?: "ERC721" | "ERC1155" | null | undefined;
+        types?: ("ERC721" | "ERC1155" | null)[] | undefined;
+    };
+};
+export declare const toNftScore: {
+    <T>(value: T): (T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        scores: Record<"Attributes" | "Animation URL" | "Background Color" | "Description" | "External Url" | "Image" | "Image Data" | "Name" | "YouTube URL" | "Contract Address" | "Supply" | "Token Id" | "Type", [number, number] | [number, 1]>;
+        address: string;
+        chainId: number;
+        sources?: string[] | undefined;
+        implementation?: string | undefined;
+        type?: "ERC721" | "ERC1155" | null | undefined;
+        types?: ("ERC721" | "ERC1155" | null)[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: string & {
+            readonly __schema: true;
+        };
+        scores: Record<"Attributes" | "Animation URL" | "Background Color" | "Description" | "External Url" | "Image" | "Image Data" | "Name" | "YouTube URL" | "Contract Address" | "Supply" | "Token Id" | "Type", [number, number] | [number, 1]>;
+        address: string;
+        chainId: number;
+        sources?: string[] | undefined;
+        implementation?: string | undefined;
+        type?: "ERC721" | "ERC1155" | null | undefined;
+        types?: ("ERC721" | "ERC1155" | null)[] | undefined;
+    };
+};
+//# sourceMappingURL=Payload.d.ts.map

package/dist/neutral/modules/crypto-nft/Diviner/Payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Payload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/crypto-nft/Diviner/Payload.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAK9C,eAAO,MAAM,4BAA4B,gCAA0B,CAAA;AAEnE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,eAAO,MAAM,0BAA0B,6TAUrC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,eAAO,MAAM,kBAAkB,kdAM7B,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,qBAAqB,kdAAqB,CAAA;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAA;AAEhD,eAAO,MAAM,cAAc,ojBAAqD,CAAA;AAEhF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAA;AAE3D,eAAO,MAAM,YAAY;;iBAAuC,CAAA;AAEhE,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,QAAQ,CAAC,GAAG;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,CAAA;AAE9F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;iBAI5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,EAAE,QAAQ,CAAC,GAAG;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,CAAA;AAExG,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAA+E,CAAA;AAEvG,MAAM,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,EAAE,QAAQ,CAAC,GAAG;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,CAAA;AAE5F,eAAO,MAAM,UAAU;;;;;;;;;;;CAA4B,CAAA;AACnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;CAA0C,CAAA;AACjE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;CAA0C,CAAA"}

package/dist/neutral/modules/crypto-nft/Diviner/Schema.d.ts

@@ -0,0 +1,5 @@
+export type NftScoreSchema = typeof NftScoreSchema;
+export declare const NftScoreSchema: string & {
+    readonly __schema: true;
+};
+//# sourceMappingURL=Schema.d.ts.map

package/dist/neutral/modules/crypto-nft/Diviner/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../../../../src/modules/crypto-nft/Diviner/Schema.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAClD,eAAO,MAAM,cAAc;;CAAuC,CAAA"}

package/dist/neutral/modules/crypto-nft/Diviner/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Config.js';
+export * from './Payload.js';
+export * from './Schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/crypto-nft/Diviner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/crypto-nft/Diviner/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA"}

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftAttribute.d.ts

@@ -0,0 +1,9 @@
+import type { JsonValue } from '@ariestools/sdk';
+import * as z from 'zod/mini';
+export declare const NftAttributeZod: z.ZodMiniObject<{
+    display_type: z.ZodMiniOptional<z.ZodMiniCustom<JsonValue, JsonValue>>;
+    trait_type: z.ZodMiniOptional<z.ZodMiniCustom<JsonValue, JsonValue>>;
+    value: z.ZodMiniOptional<z.ZodMiniCustom<JsonValue, JsonValue>>;
+}, z.core.$strip>;
+export type NftAttribute = z.infer<typeof NftAttributeZod> & Record<string, JsonValue>;
+//# sourceMappingURL=NftAttribute.d.ts.map

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftAttribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NftAttribute.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/crypto-nft/Payload/NftInfo/NftAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,eAAe;;;;iBAI1B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA"}

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftContractInformation.d.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod/mini';
+export declare const NftContractInformationZod: z.ZodMiniObject<{
+    address: z.ZodMiniString<string>;
+    chainId: z.ZodMiniNumber<number>;
+    implementation: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    type: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>;
+    types: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>>;
+}, z.core.$strip>;
+export type NftContractInformation = z.infer<typeof NftContractInformationZod>;
+//# sourceMappingURL=NftContractInformation.d.ts.map

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftContractInformation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NftContractInformation.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/crypto-nft/Payload/NftInfo/NftContractInformation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAI7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAOpC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA"}

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftInfoFields.d.ts

@@ -0,0 +1,28 @@
+import * as z from 'zod/mini';
+import type { NftMetadata } from './NftMetadata.js';
+export declare const NftInfoFieldsZod: z.ZodMiniObject<{
+    metadata: z.ZodMiniOptional<z.ZodMiniObject<{
+        attributes: z.ZodMiniOptional<z.ZodMiniCustom<import("@ariestools/sdk").JsonValue, import("@ariestools/sdk").JsonValue>>;
+        description: z.ZodMiniOptional<z.ZodMiniCustom<import("@ariestools/sdk").JsonValue, import("@ariestools/sdk").JsonValue>>;
+        image: z.ZodMiniOptional<z.ZodMiniCustom<import("@ariestools/sdk").JsonValue, import("@ariestools/sdk").JsonValue>>;
+        name: z.ZodMiniOptional<z.ZodMiniCustom<import("@ariestools/sdk").JsonValue, import("@ariestools/sdk").JsonValue>>;
+    }, z.core.$strip>>;
+    metadataUri: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    supply: z.ZodMiniString<string>;
+    tokenId: z.ZodMiniString<string>;
+    address: z.ZodMiniString<string>;
+    chainId: z.ZodMiniNumber<number>;
+    implementation: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    type: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>;
+    types: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniEnum<{
+        ERC721: "ERC721";
+        ERC1155: "ERC1155";
+    }>>>>;
+}, z.core.$strip>;
+export type NftInfoFields = Omit<z.infer<typeof NftInfoFieldsZod>, 'metadata'> & {
+    metadata?: NftMetadata;
+};
+//# sourceMappingURL=NftInfoFields.d.ts.map

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftInfoFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NftInfoFields.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/crypto-nft/Payload/NftInfo/NftInfoFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;iBAM3B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,EAAE,UAAU,CAAC,GAAG;IAC/E,QAAQ,CAAC,EAAE,WAAW,CAAA;CACvB,CAAA"}

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftMetadata.d.ts

@@ -0,0 +1,10 @@
+import type { JsonValue } from '@ariestools/sdk';
+import * as z from 'zod/mini';
+export declare const NftMetadataZod: z.ZodMiniObject<{
+    attributes: z.ZodMiniOptional<z.ZodMiniCustom<JsonValue, JsonValue>>;
+    description: z.ZodMiniOptional<z.ZodMiniCustom<JsonValue, JsonValue>>;
+    image: z.ZodMiniOptional<z.ZodMiniCustom<JsonValue, JsonValue>>;
+    name: z.ZodMiniOptional<z.ZodMiniCustom<JsonValue, JsonValue>>;
+}, z.core.$strip>;
+export type NftMetadata = z.infer<typeof NftMetadataZod> & Record<string, JsonValue>;
+//# sourceMappingURL=NftMetadata.d.ts.map

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/NftMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NftMetadata.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/crypto-nft/Payload/NftInfo/NftMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA"}

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/TokenType.d.ts

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const TokenTypeZod: z.ZodMiniNullable<z.ZodMiniEnum<{
+    ERC721: "ERC721";
+    ERC1155: "ERC1155";
+}>>;
+export type TokenType = z.infer<typeof TokenTypeZod>;
+export declare const toTokenType: (value: string | null) => TokenType;
+//# sourceMappingURL=TokenType.d.ts.map

package/dist/neutral/modules/crypto-nft/Payload/NftInfo/TokenType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenType.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/crypto-nft/Payload/NftInfo/TokenType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,eAAO,MAAM,YAAY;;;GAA4C,CAAA;AAErE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAMpD,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,GAAG,IAAI,KAAG,SAQlD,CAAA"}