@openzeppelin/contracts-mcp 0.5.6 → 0.5.7

package/src/cairo/tools/account.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { AccountOptions } from '@openzeppelin/wizard-cairo';
 import { account } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { accountSchema } from '../schemas';
+import { cairoAccountSchema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoAccount(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-account',
     makeDetailedPrompt(cairoPrompts.Account),
-    accountSchema,
+    cairoAccountSchema,
     async ({ name, type, declare, deploy, pubkey, outsideExecution, upgradeable, info, macros }) => {
       const opts: AccountOptions = {
         name,

package/src/cairo/tools/custom.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { CustomOptions } from '@openzeppelin/wizard-cairo';
 import { custom } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { customSchema } from '../schemas';
+import { cairoCustomSchema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoCustom(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-custom',
     makeDetailedPrompt(cairoPrompts.Custom),
-    customSchema,
+    cairoCustomSchema,
     async ({ name, pausable, access, upgradeable, info, macros }) => {
       const opts: CustomOptions = {
         name,

package/src/cairo/tools/erc1155.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC1155Options } from '@openzeppelin/wizard-cairo';
 import { erc1155 } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc1155Schema } from '../schemas';
+import { cairoERC1155Schema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoERC1155(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-erc1155',
     makeDetailedPrompt(cairoPrompts.ERC1155),
-    erc1155Schema,
+    cairoERC1155Schema,
     async ({
       name,
       baseUri,

package/src/cairo/tools/erc20.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC20Options } from '@openzeppelin/wizard-cairo';
 import { erc20 } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc20Schema } from '../schemas';
+import { cairoERC20Schema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoERC20(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-erc20',
     makeDetailedPrompt(cairoPrompts.ERC20),
-    erc20Schema,
+    cairoERC20Schema,
     async ({
       name,
       symbol,

package/src/cairo/tools/erc721.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC721Options } from '@openzeppelin/wizard-cairo';
 import { erc721 } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc721Schema } from '../schemas';
+import { cairoERC721Schema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoERC721(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-erc721',
     makeDetailedPrompt(cairoPrompts.ERC721),
-    erc721Schema,
+    cairoERC721Schema,
     async ({
       name,
       symbol,

package/src/cairo/tools/governor.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { GovernorOptions } from '@openzeppelin/wizard-cairo';
 import { governor } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { governorSchema } from '../schemas';
+import { cairoGovernorSchema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoGovernor(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-governor',
     makeDetailedPrompt(cairoPrompts.Governor),
-    governorSchema,
+    cairoGovernorSchema,
     async ({
       name,
       delay,

package/src/cairo/tools/multisig.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { MultisigOptions } from '@openzeppelin/wizard-cairo';
 import { multisig } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { multisigSchema } from '../schemas';
+import { cairoMultisigSchema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoMultisig(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-multisig',
     makeDetailedPrompt(cairoPrompts.Multisig),
-    multisigSchema,
+    cairoMultisigSchema,
     async ({ name, quorum, upgradeable, info, macros }) => {
       const opts: MultisigOptions = {
         name,

package/src/cairo/tools/vesting.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { VestingOptions } from '@openzeppelin/wizard-cairo';
 import { vesting } from '@openzeppelin/wizard-cairo';
 import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
-import { vestingSchema } from '../schemas';
+import { cairoVestingSchema } from '@openzeppelin/wizard-common/schemas';
 import { cairoPrompts } from '@openzeppelin/wizard-common';
 
 export function registerCairoVesting(server: McpServer): RegisteredTool {
   return server.tool(
     'cairo-vesting',
     makeDetailedPrompt(cairoPrompts.Vesting),
-    vestingSchema,
+    cairoVestingSchema,
     async ({ name, startDate, duration, cliffDuration, schedule, info, macros }) => {
       const opts: VestingOptions = {
         name,

package/src/confidential/tools/erc7984.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC7984Options } from '@openzeppelin/wizard-confidential';
 import { erc7984 } from '@openzeppelin/wizard-confidential';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc7984Schema } from '../schemas';
+import { confidentialERC7984Schema } from '@openzeppelin/wizard-common/schemas';
 import { confidentialPrompts } from '@openzeppelin/wizard-common';
 
 export function registerConfidentialERC7984(server: McpServer): RegisteredTool {
   return server.tool(
     'erc7984',
     makeDetailedPrompt(confidentialPrompts.ERC7984),
-    erc7984Schema,
+    confidentialERC7984Schema,
     async ({ name, symbol, contractURI, premint, networkConfig, wrappable, votes, info }) => {
       const opts: ERC7984Options = {
         name,

package/src/solidity/tools/account.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { AccountOptions } from '@openzeppelin/wizard';
 import { account } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { accountSchema } from '../schemas';
+import { solidityAccountSchema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityAccount(server: McpServer): RegisteredTool {
   return server.tool(
     'solidity-account',
     makeDetailedPrompt(solidityPrompts.Account),
-    accountSchema,
+    solidityAccountSchema,
     async ({
       name,
       signatureValidation,

package/src/solidity/tools/custom.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { CustomOptions } from '@openzeppelin/wizard';
 import { custom } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { customSchema } from '../schemas';
+import { solidityCustomSchema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityCustom(server: McpServer): RegisteredTool {
   return server.tool(
     'solidity-custom',
     makeDetailedPrompt(solidityPrompts.Custom),
-    customSchema,
+    solidityCustomSchema,
     async ({ name, pausable, access, upgradeable, info }) => {
       const opts: CustomOptions = {
         name,

package/src/solidity/tools/erc1155.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC1155Options } from '@openzeppelin/wizard';
 import { erc1155 } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc1155Schema } from '../schemas';
+import { solidityERC1155Schema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityERC1155(server: McpServer): RegisteredTool {
   return server.tool(
     'solidity-erc1155',
     makeDetailedPrompt(solidityPrompts.ERC1155),
-    erc1155Schema,
+    solidityERC1155Schema,
     async ({ name, uri, burnable, pausable, mintable, supply, updatableUri, access, upgradeable, info }) => {
       const opts: ERC1155Options = {
         name,

package/src/solidity/tools/erc20.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC20Options } from '@openzeppelin/wizard';
 import { erc20 } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc20Schema } from '../schemas';
+import { solidityERC20Schema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityERC20(server: McpServer): RegisteredTool {
   return server.tool(
     'solidity-erc20',
     makeDetailedPrompt(solidityPrompts.ERC20),
-    erc20Schema,
+    solidityERC20Schema,
     async ({
       name,
       symbol,

package/src/solidity/tools/erc721.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC721Options } from '@openzeppelin/wizard';
 import { erc721 } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc721Schema } from '../schemas';
+import { solidityERC721Schema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityERC721(server: McpServer): RegisteredTool {
   return server.tool(
     'solidity-erc721',
     makeDetailedPrompt(solidityPrompts.ERC721),
-    erc721Schema,
+    solidityERC721Schema,
     async ({
       name,
       symbol,

package/src/solidity/tools/governor.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { GovernorOptions } from '@openzeppelin/wizard';
 import { governor } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { governorSchema } from '../schemas';
+import { solidityGovernorSchema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityGovernor(server: McpServer): RegisteredTool {
   return server.tool(
     'solidity-governor',
     makeDetailedPrompt(solidityPrompts.Governor),
-    governorSchema,
+    solidityGovernorSchema,
     async ({
       name,
       delay,

package/src/solidity/tools/rwa.ts

@@ -2,14 +2,14 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { StablecoinOptions } from '@openzeppelin/wizard';
 import { realWorldAsset } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { rwaSchema } from '../schemas';
+import { solidityRWASchema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityRWA(server: McpServer) {
   return server.tool(
     'solidity-rwa',
     makeDetailedPrompt(solidityPrompts.RWA),
-    rwaSchema,
+    solidityRWASchema,
     async ({
       name,
       symbol,

package/src/solidity/tools/stablecoin.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { StablecoinOptions } from '@openzeppelin/wizard';
 import { stablecoin } from '@openzeppelin/wizard';
 import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
-import { stablecoinSchema } from '../schemas';
+import { solidityStablecoinSchema } from '@openzeppelin/wizard-common/schemas';
 import { solidityPrompts } from '@openzeppelin/wizard-common';
 
 export function registerSolidityStablecoin(server: McpServer): RegisteredTool {
   return server.tool(
     'solidity-stablecoin',
     makeDetailedPrompt(solidityPrompts.Stablecoin),
-    stablecoinSchema,
+    solidityStablecoinSchema,
     async ({
       name,
       symbol,

package/src/stellar/tools/fungible.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { FungibleOptions } from '@openzeppelin/wizard-stellar';
 import { fungible } from '@openzeppelin/wizard-stellar';
 import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
-import { fungibleSchema } from '../schemas';
+import { stellarFungibleSchema } from '@openzeppelin/wizard-common/schemas';
 import { stellarPrompts } from '@openzeppelin/wizard-common';
 
 export function registerStellarFungible(server: McpServer): RegisteredTool {
   return server.tool(
     'stellar-fungible',
     makeDetailedPrompt(stellarPrompts.Fungible),
-    fungibleSchema,
+    stellarFungibleSchema,
     async ({
       name,
       symbol,

package/src/stellar/tools/non-fungible.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { NonFungibleOptions } from '@openzeppelin/wizard-stellar';
 import { nonFungible } from '@openzeppelin/wizard-stellar';
 import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
-import { nonFungibleSchema } from '../schemas';
+import { stellarNonFungibleSchema } from '@openzeppelin/wizard-common/schemas';
 import { stellarPrompts } from '@openzeppelin/wizard-common';
 
 export function registerStellarNonFungible(server: McpServer): RegisteredTool {
   return server.tool(
     'stellar-non-fungible',
     makeDetailedPrompt(stellarPrompts.NonFungible),
-    nonFungibleSchema,
+    stellarNonFungibleSchema,
     async ({
       name,
       symbol,

package/src/stellar/tools/stablecoin.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { StablecoinOptions } from '@openzeppelin/wizard-stellar';
 import { stablecoin } from '@openzeppelin/wizard-stellar';
 import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
-import { stablecoinSchema } from '../schemas';
+import { stellarStablecoinSchema } from '@openzeppelin/wizard-common/schemas';
 import { stellarPrompts } from '@openzeppelin/wizard-common';
 
 export function registerStellarStablecoin(server: McpServer): RegisteredTool {
   return server.tool(
     'stellar-stablecoin',
     makeDetailedPrompt(stellarPrompts.Stablecoin),
-    stablecoinSchema,
+    stellarStablecoinSchema,
     async ({
       name,
       symbol,

package/src/stylus/tools/erc1155.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC1155Options } from '@openzeppelin/wizard-stylus';
 import { erc1155 } from '@openzeppelin/wizard-stylus';
 import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc1155Schema } from '../schemas';
+import { stylusERC1155Schema } from '@openzeppelin/wizard-common/schemas';
 import { stylusPrompts } from '@openzeppelin/wizard-common';
 
 export function registerStylusERC1155(server: McpServer): RegisteredTool {
   return server.tool(
     'stylus-erc1155',
     makeDetailedPrompt(stylusPrompts.ERC1155),
-    erc1155Schema,
+    stylusERC1155Schema,
     async ({ name, burnable, supply, info }) => {
       const opts: ERC1155Options = {
         name,

package/src/stylus/tools/erc20.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC20Options } from '@openzeppelin/wizard-stylus';
 import { erc20 } from '@openzeppelin/wizard-stylus';
 import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc20Schema } from '../schemas';
+import { stylusERC20Schema } from '@openzeppelin/wizard-common/schemas';
 import { stylusPrompts } from '@openzeppelin/wizard-common';
 
 export function registerStylusERC20(server: McpServer): RegisteredTool {
   return server.tool(
     'stylus-erc20',
     makeDetailedPrompt(stylusPrompts.ERC20),
-    erc20Schema,
+    stylusERC20Schema,
     async ({ name, burnable, permit, flashmint, info }) => {
       const opts: ERC20Options = {
         name,

package/src/stylus/tools/erc721.ts

@@ -2,14 +2,14 @@ import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server
 import type { ERC721Options } from '@openzeppelin/wizard-stylus';
 import { erc721 } from '@openzeppelin/wizard-stylus';
 import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
-import { erc721Schema } from '../schemas';
+import { stylusERC721Schema } from '@openzeppelin/wizard-common/schemas';
 import { stylusPrompts } from '@openzeppelin/wizard-common';
 
 export function registerStylusERC721(server: McpServer): RegisteredTool {
   return server.tool(
     'stylus-erc721',
     makeDetailedPrompt(stylusPrompts.ERC721),
-    erc721Schema,
+    stylusERC721Schema,
     async ({ name, burnable, enumerable, info }) => {
       const opts: ERC721Options = {
         name,

package/src/uniswap-hooks/tools/hooks.ts

@@ -1,6 +1,6 @@
 import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { hooks, type HooksOptions } from '@openzeppelin/wizard-uniswap-hooks';
-import { hooksSchema } from '../schemas';
+import { uniswapHooksHooksSchema } from '@openzeppelin/wizard-common/schemas';
 import { makeDetailedPrompt, safePrintSolidityCodeBlock } from '../../utils';
 import { uniswapHooksPrompts } from '@openzeppelin/wizard-common';
 
@@ -8,7 +8,7 @@ export function registerUniswapHooks(server: McpServer): RegisteredTool {
   return server.tool(
     'uniswap-hooks',
     makeDetailedPrompt(uniswapHooksPrompts.Hooks),
-    hooksSchema,
+    uniswapHooksHooksSchema,
     async ({
       hook,
       name,

package/dist/cairo/schemas.d.ts

@@ -1,200 +0,0 @@
-import { z } from 'zod';
-export declare const commonSchema: {
-    readonly access: z.ZodObject<{
-        type: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"ownable">, z.ZodLiteral<"roles">]>, z.ZodLiteral<"roles-dar">]>, z.ZodLiteral<false>]>;
-        darInitialDelay: z.ZodString;
-        darDefaultDelayIncrease: z.ZodString;
-        darMaxTransferDelay: z.ZodString;
-    }, z.core.$strip>;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-};
-export declare const erc20Schema: {
-    readonly access: z.ZodObject<{
-        type: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"ownable">, z.ZodLiteral<"roles">]>, z.ZodLiteral<"roles-dar">]>, z.ZodLiteral<false>]>;
-        darInitialDelay: z.ZodString;
-        darDefaultDelayIncrease: z.ZodString;
-        darMaxTransferDelay: z.ZodString;
-    }, z.core.$strip>;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-    readonly name: z.ZodString;
-    readonly symbol: z.ZodString;
-    readonly decimals: z.ZodOptional<z.ZodString>;
-    readonly burnable: z.ZodOptional<z.ZodBoolean>;
-    readonly pausable: z.ZodOptional<z.ZodBoolean>;
-    readonly premint: z.ZodOptional<z.ZodString>;
-    readonly mintable: z.ZodOptional<z.ZodBoolean>;
-    readonly votes: z.ZodOptional<z.ZodBoolean>;
-    readonly appName: z.ZodOptional<z.ZodString>;
-    readonly appVersion: z.ZodOptional<z.ZodString>;
-};
-export declare const erc721Schema: {
-    readonly access: z.ZodObject<{
-        type: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"ownable">, z.ZodLiteral<"roles">]>, z.ZodLiteral<"roles-dar">]>, z.ZodLiteral<false>]>;
-        darInitialDelay: z.ZodString;
-        darDefaultDelayIncrease: z.ZodString;
-        darMaxTransferDelay: z.ZodString;
-    }, z.core.$strip>;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-    readonly name: z.ZodString;
-    readonly symbol: z.ZodString;
-    readonly baseUri: z.ZodOptional<z.ZodString>;
-    readonly burnable: z.ZodOptional<z.ZodBoolean>;
-    readonly pausable: z.ZodOptional<z.ZodBoolean>;
-    readonly mintable: z.ZodOptional<z.ZodBoolean>;
-    readonly enumerable: z.ZodOptional<z.ZodBoolean>;
-    readonly votes: z.ZodOptional<z.ZodBoolean>;
-    readonly royaltyInfo: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodBoolean;
-        defaultRoyaltyFraction: z.ZodString;
-        feeDenominator: z.ZodString;
-    }, z.core.$strip>>;
-    readonly appName: z.ZodOptional<z.ZodString>;
-    readonly appVersion: z.ZodOptional<z.ZodString>;
-};
-export declare const erc1155Schema: {
-    readonly access: z.ZodObject<{
-        type: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"ownable">, z.ZodLiteral<"roles">]>, z.ZodLiteral<"roles-dar">]>, z.ZodLiteral<false>]>;
-        darInitialDelay: z.ZodString;
-        darDefaultDelayIncrease: z.ZodString;
-        darMaxTransferDelay: z.ZodString;
-    }, z.core.$strip>;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-    readonly name: z.ZodString;
-    readonly baseUri: z.ZodString;
-    readonly burnable: z.ZodOptional<z.ZodBoolean>;
-    readonly pausable: z.ZodOptional<z.ZodBoolean>;
-    readonly mintable: z.ZodOptional<z.ZodBoolean>;
-    readonly updatableUri: z.ZodOptional<z.ZodBoolean>;
-    readonly royaltyInfo: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodBoolean;
-        defaultRoyaltyFraction: z.ZodString;
-        feeDenominator: z.ZodString;
-    }, z.core.$strip>>;
-};
-export declare const accountSchema: {
-    readonly name: z.ZodString;
-    readonly type: z.ZodEnum<{
-        stark: "stark";
-        eth: "eth";
-    }>;
-    readonly declare: z.ZodOptional<z.ZodBoolean>;
-    readonly deploy: z.ZodOptional<z.ZodBoolean>;
-    readonly pubkey: z.ZodOptional<z.ZodBoolean>;
-    readonly outsideExecution: z.ZodOptional<z.ZodBoolean>;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-};
-export declare const multisigSchema: {
-    readonly name: z.ZodString;
-    readonly quorum: z.ZodString;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-};
-export declare const governorSchema: {
-    readonly name: z.ZodString;
-    readonly delay: z.ZodString;
-    readonly period: z.ZodString;
-    readonly votes: z.ZodOptional<z.ZodEnum<{
-        erc20votes: "erc20votes";
-        erc721votes: "erc721votes";
-    }>>;
-    readonly clockMode: z.ZodOptional<z.ZodEnum<{
-        timestamp: "timestamp";
-    }>>;
-    readonly timelock: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodLiteral<"openzeppelin">]>>;
-    readonly decimals: z.ZodOptional<z.ZodNumber>;
-    readonly proposalThreshold: z.ZodOptional<z.ZodString>;
-    readonly quorumMode: z.ZodOptional<z.ZodEnum<{
-        percent: "percent";
-        absolute: "absolute";
-    }>>;
-    readonly quorumPercent: z.ZodOptional<z.ZodNumber>;
-    readonly quorumAbsolute: z.ZodOptional<z.ZodString>;
-    readonly settings: z.ZodOptional<z.ZodBoolean>;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly appName: z.ZodOptional<z.ZodString>;
-    readonly appVersion: z.ZodOptional<z.ZodString>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-};
-export declare const vestingSchema: {
-    readonly name: z.ZodString;
-    readonly startDate: z.ZodString;
-    readonly duration: z.ZodString;
-    readonly cliffDuration: z.ZodString;
-    readonly schedule: z.ZodEnum<{
-        custom: "custom";
-        linear: "linear";
-    }>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-};
-export declare const customSchema: {
-    readonly access: z.ZodObject<{
-        type: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"ownable">, z.ZodLiteral<"roles">]>, z.ZodLiteral<"roles-dar">]>, z.ZodLiteral<false>]>;
-        darInitialDelay: z.ZodString;
-        darDefaultDelayIncrease: z.ZodString;
-        darMaxTransferDelay: z.ZodString;
-    }, z.core.$strip>;
-    readonly upgradeable: z.ZodOptional<z.ZodBoolean>;
-    readonly info: z.ZodOptional<z.ZodObject<{
-        securityContact: z.ZodOptional<z.ZodString>;
-        license: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    readonly macros: z.ZodOptional<z.ZodObject<{
-        withComponents: z.ZodBoolean;
-    }, z.core.$strip>>;
-    readonly name: z.ZodString;
-    readonly pausable: z.ZodOptional<z.ZodBoolean>;
-};
-//# sourceMappingURL=schemas.d.ts.map

package/dist/cairo/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/cairo/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;CA0BS,CAAC;AAEnC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAYU,CAAC;AAEnC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBS,CAAC;AAEnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBQ,CAAC;AAEnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;CAUQ,CAAC;AAEnC,eAAO,MAAM,cAAc;;;;;;;;;;;CAMO,CAAC;AAEnC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBO,CAAC;AAEnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAQQ,CAAC;AAEnC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAIS,CAAC"}