//this file is auto-generated by the InfinityMint CLI
    //do not modify this file directly
    import { InfinityMintDeploymentScript, InfinityMintDeploymentParameters, InfinityMintDeploymentLocal, InfinityMintDeploymentLive, ValuesReturnType  } from '@app/interfaces';
    import { Dictionary } from '@app/helpers';
    import { InfinityMintDeployment } from '@app/deployments';
    import { Contract } from '@ethersproject/contracts';
    import { DefaultMinter as DefaultMinterContract } from '@typechain-types/index';
import { DefaultRoyalty as DefaultRoyaltyContract } from '@typechain-types/index';
import { InfinityMint as InfinityMintContract } from '@typechain-types/index';
import { InfinityMintApi as InfinityMintApiContract } from '@typechain-types/index';
import { InfinityMintFlags as InfinityMintFlagsContract } from '@typechain-types/index';
import { InfinityMintLinker as InfinityMintLinkerContract } from '@typechain-types/index';
import { InfinityMintProject as InfinityMintProjectContract } from '@typechain-types/index';
import { InfinityMintStorage as InfinityMintStorageContract } from '@typechain-types/index';
import { InfinityMintValues as InfinityMintValuesContract } from '@typechain-types/index';
import { RarityAny as RarityAnyContract } from '@typechain-types/index';
import { RarityImage as RarityImageContract } from '@typechain-types/index';
import { RaritySVG as RaritySVGContract } from '@typechain-types/index';
import { SeededRandom as SeededRandomContract } from '@typechain-types/index';
import { SelectiveMinter as SelectiveMinterContract } from '@typechain-types/index';
import { SimpleAny as SimpleAnyContract } from '@typechain-types/index';
import { SimpleImage as SimpleImageContract } from '@typechain-types/index';
import { SimpleSVG as SimpleSVGContract } from '@typechain-types/index';
import { SimpleToken as SimpleTokenContract } from '@typechain-types/index';
import { SplitRoyalty as SplitRoyaltyContract } from '@typechain-types/index';
import { UnsafeRandom as UnsafeRandomContract } from '@typechain-types/index';

            export abstract class DefaultMinterDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends DefaultMinterDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): DefaultMinterContract {
                    return super.getContract() as DefaultMinterContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<DefaultMinterContract> {
                    return super.getSignedContract<DefaultMinterContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     DefaultMinter?: DefaultMinterDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     DefaultMinter?: DefaultMinterDeploymentLive_Facade;
    }
}

export interface DefaultMinterDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface DefaultMinterScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: DefaultMinterDeploymentClass;
    deployScript?: DefaultMinterDeployScript;
}

export type DefaultMinterDeployArgType = (params: DefaultMinterScriptParameters) => Promise<string[]> | string[];

export interface DefaultMinterDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: DefaultMinterScriptParameters) => Promise<void>;
    cleanup?: (script: DefaultMinterScriptParameters) => Promise<void | string[]>;
    update?: (script: DefaultMinterScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: DefaultMinterScriptParameters) => Promise<void>;
    deploy?: (script: DefaultMinterScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: DefaultMinterScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | DefaultMinterDeployArgType
;}

export const DefaultMinter: DefaultMinterDeployScript = {
    "unique": true,
    "module": "minter",
    "index": 7,
    "deployArgs": [
        "values",
        "storage",
        "assets",
        "random"
    ],
    "solidityFolder": "alpha",
    "requestPermissions": [
        "erc721"
    ],
    "permissions": [
        "all",
        "erc721",
        "assets"
    ],
    "key": "DefaultMinter"
};


            export abstract class DefaultRoyaltyDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends DefaultRoyaltyDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): DefaultRoyaltyContract {
                    return super.getContract() as DefaultRoyaltyContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<DefaultRoyaltyContract> {
                    return super.getSignedContract<DefaultRoyaltyContract>();
                }
                
                public get values(): DefaultRoyaltyOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     DefaultRoyalty?: DefaultRoyaltyDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     DefaultRoyalty?: DefaultRoyaltyDeploymentLive_Facade;
    }
}

export interface DefaultRoyaltyDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: DefaultRoyaltyOnChainValues;
}

export interface DefaultRoyaltyScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: DefaultRoyaltyDeploymentClass;
    deployScript?: DefaultRoyaltyDeployScript;
}

export type DefaultRoyaltyDeployArgType = (params: DefaultRoyaltyScriptParameters) => Promise<string[]> | string[];

export interface DefaultRoyaltyDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: DefaultRoyaltyScriptParameters) => Promise<void>;
    cleanup?: (script: DefaultRoyaltyScriptParameters) => Promise<void | string[]>;
    update?: (script: DefaultRoyaltyScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: DefaultRoyaltyScriptParameters) => Promise<void>;
    deploy?: (script: DefaultRoyaltyScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: DefaultRoyaltyScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | DefaultRoyaltyDeployArgType
;    values?: DefaultRoyaltyOnChainValues
;}

export const DefaultRoyalty: DefaultRoyaltyDeployScript = {
    "unique": true,
    "module": "royalty",
    "index": 5,
    "deployArgs": [
        "values"
    ],
    "solidityFolder": "alpha",
    "requestPermissions": [
        "erc721"
    ],
    "permissions": [
        "all",
        "erc721",
        "assets"
    ],
    "values": {
        "baseTokenValue": 1000000000000000000,
        "stickerSplit": 20
    },
    "key": "DefaultRoyalty"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        startingPrice?: ValuesReturnType;
baseTokenValue?: number;
stickerSplit?: number;
    }
}

    export interface DefaultRoyaltyOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        startingPrice?: ValuesReturnType;
baseTokenValue?: number;
stickerSplit?: number;
    }

            export abstract class InfinityMintDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): InfinityMintContract {
                    return super.getContract() as InfinityMintContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<InfinityMintContract> {
                    return super.getSignedContract<InfinityMintContract>();
                }
                
                public get values(): InfinityMintOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     InfinityMint?: InfinityMintDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     InfinityMint?: InfinityMintDeploymentLive_Facade;
    }
}

export interface InfinityMintDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: InfinityMintOnChainValues;
}

export interface InfinityMintScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintDeploymentClass;
    deployScript?: InfinityMintDeployScript;
}

export type InfinityMintDeployArgType = (params: InfinityMintScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintDeployArgType
;    values?: InfinityMintOnChainValues
;}

export const InfinityMint: InfinityMintDeployScript = {
    "module": "erc721",
    "index": 8,
    "settings": {
        "erc721": {
            "generateTokenURI": false,
            "pregenerateTokens": 100
        }
    },
    "values": {
        "previewCount": 3,
        "previewCooldownSeconds": 18000,
        "incrementalMode": false,
        "matchedMode": false,
        "disableMintArguments": false,
        "byteMint": false,
        "disableRegisteredTokens": false,
        "maxSupply": 124,
        "maxTokensPerWallet": 256
    },
    "config": {
        "test": "test"
    },
    "deployArgs": [
        "%token_name%",
        "%token_symbol%",
        "storage",
        "values",
        "minter",
        "royalty"
    ],
    "requestPermissions": [
        "storage",
        "royalty"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "all"
    ],
    "key": "InfinityMint"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsERC721  {
        generateTokenURI?: boolean;
pregenerateTokens?: number;
    }
}

declare module '@app/interfaces' {
    export interface  InfinityMintConfigSettingsDeploy {
        test?: string;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        previewCount?: number;
previewCooldownSeconds?: number;
incrementalMode?: boolean;
matchedMode?: boolean;
disableMintArguments?: boolean;
byteMint?: boolean;
disableRegisteredTokens?: boolean;
maxSupply?: number;
maxTokensPerWallet?: number;
    }
}

    export interface InfinityMintOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        previewCount?: number;
previewCooldownSeconds?: number;
incrementalMode?: boolean;
matchedMode?: boolean;
disableMintArguments?: boolean;
byteMint?: boolean;
disableRegisteredTokens?: boolean;
maxSupply?: number;
maxTokensPerWallet?: number;
    }

            export abstract class InfinityMintApiDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintApiDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): InfinityMintApiContract {
                    return super.getContract() as InfinityMintApiContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<InfinityMintApiContract> {
                    return super.getSignedContract<InfinityMintApiContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     InfinityMintApi?: InfinityMintApiDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     InfinityMintApi?: InfinityMintApiDeploymentLive_Facade;
    }
}

export interface InfinityMintApiDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface InfinityMintApiScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintApiDeploymentClass;
    deployScript?: InfinityMintApiDeployScript;
}

export type InfinityMintApiDeployArgType = (params: InfinityMintApiScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintApiDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintApiScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintApiScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintApiScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintApiScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintApiScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintApiScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintApiDeployArgType
;}

export const InfinityMintApi: InfinityMintApiDeployScript = {
    "module": "api",
    "index": 10,
    "deployArgs": [
        "erc721",
        "storage",
        "assets",
        "values",
        "royalty",
        "project"
    ],
    "solidityFolder": "alpha",
    "requestPermissions": [
        "erc721",
        "storage",
        "flags",
        "linker"
    ],
    "key": "InfinityMintApi"
};


            export abstract class InfinityMintFlagsDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintFlagsDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): InfinityMintFlagsContract {
                    return super.getContract() as InfinityMintFlagsContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<InfinityMintFlagsContract> {
                    return super.getSignedContract<InfinityMintFlagsContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     InfinityMintFlags?: InfinityMintFlagsDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     InfinityMintFlags?: InfinityMintFlagsDeploymentLive_Facade;
    }
}

export interface InfinityMintFlagsDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface InfinityMintFlagsScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintFlagsDeploymentClass;
    deployScript?: InfinityMintFlagsDeployScript;
}

export type InfinityMintFlagsDeployArgType = (params: InfinityMintFlagsScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintFlagsDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintFlagsScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintFlagsScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintFlagsScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintFlagsScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintFlagsScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintFlagsScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintFlagsDeployArgType
;}

export const InfinityMintFlags: InfinityMintFlagsDeployScript = {
    "module": "flags",
    "index": 10,
    "deployArgs": [
        "storage",
        "erc721"
    ],
    "solidityFolder": "alpha",
    "requestPermissions": [
        "storage"
    ],
    "key": "InfinityMintFlags"
};


            export abstract class InfinityMintLinkerDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintLinkerDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): InfinityMintLinkerContract {
                    return super.getContract() as InfinityMintLinkerContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<InfinityMintLinkerContract> {
                    return super.getSignedContract<InfinityMintLinkerContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     InfinityMintLinker?: InfinityMintLinkerDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     InfinityMintLinker?: InfinityMintLinkerDeploymentLive_Facade;
    }
}

export interface InfinityMintLinkerDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface InfinityMintLinkerScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintLinkerDeploymentClass;
    deployScript?: InfinityMintLinkerDeployScript;
}

export type InfinityMintLinkerDeployArgType = (params: InfinityMintLinkerScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintLinkerDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintLinkerScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintLinkerScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintLinkerScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintLinkerScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintLinkerScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintLinkerScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintLinkerDeployArgType
;}

export const InfinityMintLinker: InfinityMintLinkerDeployScript = {
    "module": "linker",
    "index": 10,
    "deployArgs": [
        "storage",
        "erc721"
    ],
    "solidityFolder": "alpha",
    "requestPermissions": [
        "storage",
        "erc721"
    ],
    "key": "InfinityMintLinker"
};


            export abstract class InfinityMintProjectDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintProjectDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): InfinityMintProjectContract {
                    return super.getContract() as InfinityMintProjectContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<InfinityMintProjectContract> {
                    return super.getSignedContract<InfinityMintProjectContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     InfinityMintProject?: InfinityMintProjectDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     InfinityMintProject?: InfinityMintProjectDeploymentLive_Facade;
    }
}

export interface InfinityMintProjectDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface InfinityMintProjectScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintProjectDeploymentClass;
    deployScript?: InfinityMintProjectDeployScript;
}

export type InfinityMintProjectDeployArgType = (params: InfinityMintProjectScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintProjectDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintProjectScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintProjectScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintProjectScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintProjectScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintProjectScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintProjectScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintProjectDeployArgType
;}

export const InfinityMintProject: InfinityMintProjectDeployScript = {
    "module": "project",
    "index": 8,
    "solidityFolder": "alpha",
    "permissions": [
        "all"
    ],
    "key": "InfinityMintProject"
};


            export abstract class InfinityMintStorageDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintStorageDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): InfinityMintStorageContract {
                    return super.getContract() as InfinityMintStorageContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<InfinityMintStorageContract> {
                    return super.getSignedContract<InfinityMintStorageContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     InfinityMintStorage?: InfinityMintStorageDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     InfinityMintStorage?: InfinityMintStorageDeploymentLive_Facade;
    }
}

export interface InfinityMintStorageDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface InfinityMintStorageScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintStorageDeploymentClass;
    deployScript?: InfinityMintStorageDeployScript;
}

export type InfinityMintStorageDeployArgType = (params: InfinityMintStorageScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintStorageDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintStorageScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintStorageScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintStorageScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintStorageScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintStorageScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintStorageScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintStorageDeployArgType
;}

export const InfinityMintStorage: InfinityMintStorageDeployScript = {
    "module": "storage",
    "index": 3,
    "solidityFolder": "alpha",
    "key": "InfinityMintStorage"
};


            export abstract class InfinityMintUtilDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintUtilDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                

            }

        export interface InfinityMintUtilDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface InfinityMintUtilScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintUtilDeploymentClass;
    deployScript?: InfinityMintUtilDeployScript;
}

export type InfinityMintUtilDeployArgType = (params: InfinityMintUtilScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintUtilDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintUtilScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintUtilScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintUtilScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintUtilScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintUtilScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintUtilScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintUtilDeployArgType
;}

export const InfinityMintUtil: InfinityMintUtilDeployScript = {
    "module": "utils",
    "index": 1,
    "solidityFolder": "alpha",
    "library": true,
    "key": "InfinityMintUtil"
};


            export abstract class InfinityMintValuesDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends InfinityMintValuesDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): InfinityMintValuesContract {
                    return super.getContract() as InfinityMintValuesContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<InfinityMintValuesContract> {
                    return super.getSignedContract<InfinityMintValuesContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     InfinityMintValues?: InfinityMintValuesDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     InfinityMintValues?: InfinityMintValuesDeploymentLive_Facade;
    }
}

export interface InfinityMintValuesDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface InfinityMintValuesScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: InfinityMintValuesDeploymentClass;
    deployScript?: InfinityMintValuesDeployScript;
}

export type InfinityMintValuesDeployArgType = (params: InfinityMintValuesScriptParameters) => Promise<string[]> | string[];

export interface InfinityMintValuesDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: InfinityMintValuesScriptParameters) => Promise<void>;
    cleanup?: (script: InfinityMintValuesScriptParameters) => Promise<void | string[]>;
    update?: (script: InfinityMintValuesScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: InfinityMintValuesScriptParameters) => Promise<void>;
    deploy?: (script: InfinityMintValuesScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: InfinityMintValuesScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | InfinityMintValuesDeployArgType
;}

export const InfinityMintValues: InfinityMintValuesDeployScript = {
    "static": true,
    "instantlySetup": true,
    "unique": true,
    "important": true,
    "module": "values",
    "permissions": [
        "all"
    ],
    "index": 1,
    "solidityFolder": "alpha",
    "key": "InfinityMintValues"
};


            export abstract class EADStickersDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends EADStickersDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                

            }

        export interface EADStickersDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface EADStickersScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: EADStickersDeploymentClass;
    deployScript?: EADStickersDeployScript;
}

export type EADStickersDeployArgType = (params: EADStickersScriptParameters) => Promise<string[]> | string[];

export interface EADStickersDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: EADStickersScriptParameters) => Promise<void>;
    cleanup?: (script: EADStickersScriptParameters) => Promise<void | string[]>;
    update?: (script: EADStickersScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: EADStickersScriptParameters) => Promise<void>;
    deploy?: (script: EADStickersScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: EADStickersScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | EADStickersDeployArgType
;}

export const EADStickers: EADStickersDeployScript = {
    "index": 1,
    "solidityFolder": "alpha",
    "important": true,
    "link": {
        "description": "Enables prototype ethereum ad service integration",
        "args": [
            "tokenId",
            "erc721"
        ],
        "key": "stickers",
        "erc721": true,
        "verify": true
    },
    "key": "EADStickers"
};


            export abstract class StickersV2DeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends StickersV2DeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                

            }

        export interface StickersV2DeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface StickersV2ScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: StickersV2DeploymentClass;
    deployScript?: StickersV2DeployScript;
}

export type StickersV2DeployArgType = (params: StickersV2ScriptParameters) => Promise<string[]> | string[];

export interface StickersV2DeployScript extends InfinityMintDeploymentScript {
    setup?: (script: StickersV2ScriptParameters) => Promise<void>;
    cleanup?: (script: StickersV2ScriptParameters) => Promise<void | string[]>;
    update?: (script: StickersV2ScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: StickersV2ScriptParameters) => Promise<void>;
    deploy?: (script: StickersV2ScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: StickersV2ScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | StickersV2DeployArgType
;}

export const StickersV2: StickersV2DeployScript = {
    "index": 1,
    "solidityFolder": "alpha",
    "important": false,
    "link": {
        "description": "Sticers V2 Test",
        "args": [
            "oracleDestination",
            "erc721",
            "tokenId",
            "tokenName",
            "tokenSymbol"
        ],
        "key": "eads_endpoint",
        "erc721": true,
        "verify": true
    },
    "key": "StickersV2"
};


            export abstract class TokenAccountDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends TokenAccountDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                

            }

        export interface TokenAccountDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface TokenAccountScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: TokenAccountDeploymentClass;
    deployScript?: TokenAccountDeployScript;
}

export type TokenAccountDeployArgType = (params: TokenAccountScriptParameters) => Promise<string[]> | string[];

export interface TokenAccountDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: TokenAccountScriptParameters) => Promise<void>;
    cleanup?: (script: TokenAccountScriptParameters) => Promise<void | string[]>;
    update?: (script: TokenAccountScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: TokenAccountScriptParameters) => Promise<void>;
    deploy?: (script: TokenAccountScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: TokenAccountScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | TokenAccountDeployArgType
;}

export const TokenAccount: TokenAccountDeployScript = {
    "index": 0,
    "solidityFolder": "alpha",
    "important": true,
    "link": {
        "description": "A smart-contract wallet account capable of holding ERC-20 tokens and ERC-721 tokens",
        "args": [
            "tokenId",
            "erc721"
        ],
        "key": "wallet",
        "verify": true
    },
    "key": "TokenAccount"
};


            export abstract class RarityAnyDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends RarityAnyDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): RarityAnyContract {
                    return super.getContract() as RarityAnyContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<RarityAnyContract> {
                    return super.getSignedContract<RarityAnyContract>();
                }
                
                public get values(): RarityAnyOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     RarityAny?: RarityAnyDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     RarityAny?: RarityAnyDeploymentLive_Facade;
    }
}

export interface RarityAnyDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: RarityAnyOnChainValues;
}

export interface RarityAnyScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: RarityAnyDeploymentClass;
    deployScript?: RarityAnyDeployScript;
}

export type RarityAnyDeployArgType = (params: RarityAnyScriptParameters) => Promise<string[]> | string[];

export interface RarityAnyDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: RarityAnyScriptParameters) => Promise<void>;
    cleanup?: (script: RarityAnyScriptParameters) => Promise<void | string[]>;
    update?: (script: RarityAnyScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: RarityAnyScriptParameters) => Promise<void>;
    deploy?: (script: RarityAnyScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: RarityAnyScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | RarityAnyDeployArgType
;    values?: RarityAnyOnChainValues
;}

export const RarityAny: RarityAnyDeployScript = {
    "unique": true,
    "module": "assets",
    "index": 4,
    "values": {
        "mustGenerateName": true,
        "nameCount": 3,
        "colourChunkSize": 32,
        "extraColours": 32,
        "randomRarity": true,
        "lowestRarity": true,
        "highestRarity": false,
        "stopDuplicateMint": false
    },
    "deployArgs": [
        "%token_name%",
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "minter"
    ],
    "key": "RarityAny"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }
}

    export interface RarityAnyOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }

            export abstract class RarityImageDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends RarityImageDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): RarityImageContract {
                    return super.getContract() as RarityImageContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<RarityImageContract> {
                    return super.getSignedContract<RarityImageContract>();
                }
                
                public get values(): RarityImageOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     RarityImage?: RarityImageDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     RarityImage?: RarityImageDeploymentLive_Facade;
    }
}

export interface RarityImageDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: RarityImageOnChainValues;
}

export interface RarityImageScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: RarityImageDeploymentClass;
    deployScript?: RarityImageDeployScript;
}

export type RarityImageDeployArgType = (params: RarityImageScriptParameters) => Promise<string[]> | string[];

export interface RarityImageDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: RarityImageScriptParameters) => Promise<void>;
    cleanup?: (script: RarityImageScriptParameters) => Promise<void | string[]>;
    update?: (script: RarityImageScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: RarityImageScriptParameters) => Promise<void>;
    deploy?: (script: RarityImageScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: RarityImageScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | RarityImageDeployArgType
;    values?: RarityImageOnChainValues
;}

export const RarityImage: RarityImageDeployScript = {
    "unique": true,
    "module": "assets",
    "index": 4,
    "values": {
        "mustGenerateName": true,
        "nameCount": 3,
        "colourChunkSize": 32,
        "extraColours": 32,
        "randomRarity": true,
        "lowestRarity": true,
        "highestRarity": false,
        "stopDuplicateMint": false
    },
    "config": {
        "paths": {
            "rarityChunkSize": 64
        }
    },
    "deployArgs": [
        "%token_name%",
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "minter"
    ],
    "key": "RarityImage"
};

declare module '@app/interfaces' {
    export interface  InfinityMintConfigSettingsDeploy {
        paths?: {
rarityChunkSize?: number;
};
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }
}

    export interface RarityImageOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }

            export abstract class RaritySVGDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends RaritySVGDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): RaritySVGContract {
                    return super.getContract() as RaritySVGContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<RaritySVGContract> {
                    return super.getSignedContract<RaritySVGContract>();
                }
                
                public get values(): RaritySVGOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     RaritySVG?: RaritySVGDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     RaritySVG?: RaritySVGDeploymentLive_Facade;
    }
}

export interface RaritySVGDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: RaritySVGOnChainValues;
}

export interface RaritySVGScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: RaritySVGDeploymentClass;
    deployScript?: RaritySVGDeployScript;
}

export type RaritySVGDeployArgType = (params: RaritySVGScriptParameters) => Promise<string[]> | string[];

export interface RaritySVGDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: RaritySVGScriptParameters) => Promise<void>;
    cleanup?: (script: RaritySVGScriptParameters) => Promise<void | string[]>;
    update?: (script: RaritySVGScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: RaritySVGScriptParameters) => Promise<void>;
    deploy?: (script: RaritySVGScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: RaritySVGScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | RaritySVGDeployArgType
;    values?: RaritySVGOnChainValues
;}

export const RaritySVG: RaritySVGDeployScript = {
    "unique": true,
    "module": "assets",
    "index": 4,
    "values": {
        "mustGenerateName": true,
        "nameCount": 3,
        "colourChunkSize": 32,
        "extraColours": 32,
        "randomRarity": true,
        "lowestRarity": true,
        "highestRarity": false,
        "stopDuplicateMint": false
    },
    "deployArgs": [
        "%token_name%",
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "minter"
    ],
    "key": "RaritySVG"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }
}

    export interface RaritySVGOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }

            export abstract class SeededRandomDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends SeededRandomDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): SeededRandomContract {
                    return super.getContract() as SeededRandomContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<SeededRandomContract> {
                    return super.getSignedContract<SeededRandomContract>();
                }
                
                public get values(): SeededRandomOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     SeededRandom?: SeededRandomDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     SeededRandom?: SeededRandomDeploymentLive_Facade;
    }
}

export interface SeededRandomDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: SeededRandomOnChainValues;
}

export interface SeededRandomScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: SeededRandomDeploymentClass;
    deployScript?: SeededRandomDeployScript;
}

export type SeededRandomDeployArgType = (params: SeededRandomScriptParameters) => Promise<string[]> | string[];

export interface SeededRandomDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: SeededRandomScriptParameters) => Promise<void>;
    cleanup?: (script: SeededRandomScriptParameters) => Promise<void | string[]>;
    update?: (script: SeededRandomScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: SeededRandomScriptParameters) => Promise<void>;
    deploy?: (script: SeededRandomScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: SeededRandomScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | SeededRandomDeployArgType
;    values?: SeededRandomOnChainValues
;}

export const SeededRandom: SeededRandomDeployScript = {
    "unique": true,
    "module": "random",
    "index": 4,
    "values": {
        "seedNumber": 230,
        "maxRandomNumber": 16777215
    },
    "solidityFolder": "alpha",
    "key": "SeededRandom"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        seedNumber?: number;
maxRandomNumber?: number;
    }
}

    export interface SeededRandomOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        seedNumber?: number;
maxRandomNumber?: number;
    }

            export abstract class SelectiveMinterDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends SelectiveMinterDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): SelectiveMinterContract {
                    return super.getContract() as SelectiveMinterContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<SelectiveMinterContract> {
                    return super.getSignedContract<SelectiveMinterContract>();
                }
                
                

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     SelectiveMinter?: SelectiveMinterDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     SelectiveMinter?: SelectiveMinterDeploymentLive_Facade;
    }
}

export interface SelectiveMinterDeploymentLive_Facade extends InfinityMintDeploymentLive {
}

export interface SelectiveMinterScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: SelectiveMinterDeploymentClass;
    deployScript?: SelectiveMinterDeployScript;
}

export type SelectiveMinterDeployArgType = (params: SelectiveMinterScriptParameters) => Promise<string[]> | string[];

export interface SelectiveMinterDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: SelectiveMinterScriptParameters) => Promise<void>;
    cleanup?: (script: SelectiveMinterScriptParameters) => Promise<void | string[]>;
    update?: (script: SelectiveMinterScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: SelectiveMinterScriptParameters) => Promise<void>;
    deploy?: (script: SelectiveMinterScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: SelectiveMinterScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | SelectiveMinterDeployArgType
;}

export const SelectiveMinter: SelectiveMinterDeployScript = {
    "module": "minter",
    "index": 7,
    "solidityFolder": "alpha",
    "deployArgs": [
        "values",
        "storage",
        "assets",
        "random"
    ],
    "permissions": [
        "erc721",
        "assets"
    ],
    "key": "SelectiveMinter"
};


            export abstract class SimpleAnyDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends SimpleAnyDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): SimpleAnyContract {
                    return super.getContract() as SimpleAnyContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<SimpleAnyContract> {
                    return super.getSignedContract<SimpleAnyContract>();
                }
                
                public get values(): SimpleAnyOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     SimpleAny?: SimpleAnyDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     SimpleAny?: SimpleAnyDeploymentLive_Facade;
    }
}

export interface SimpleAnyDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: SimpleAnyOnChainValues;
}

export interface SimpleAnyScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: SimpleAnyDeploymentClass;
    deployScript?: SimpleAnyDeployScript;
}

export type SimpleAnyDeployArgType = (params: SimpleAnyScriptParameters) => Promise<string[]> | string[];

export interface SimpleAnyDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: SimpleAnyScriptParameters) => Promise<void>;
    cleanup?: (script: SimpleAnyScriptParameters) => Promise<void | string[]>;
    update?: (script: SimpleAnyScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: SimpleAnyScriptParameters) => Promise<void>;
    deploy?: (script: SimpleAnyScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: SimpleAnyScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | SimpleAnyDeployArgType
;    values?: SimpleAnyOnChainValues
;}

export const SimpleAny: SimpleAnyDeployScript = {
    "unique": true,
    "module": "assets",
    "index": 4,
    "values": {
        "mustGenerateName": true,
        "nameCount": 3,
        "colourChunkSize": 32,
        "extraColours": 32,
        "randomRarity": true,
        "lowestRarity": true,
        "highestRarity": false,
        "stopDuplicateMint": false
    },
    "deployArgs": [
        "%token_name%",
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "minter"
    ],
    "key": "SimpleAny"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }
}

    export interface SimpleAnyOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }

            export abstract class SimpleImageDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends SimpleImageDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): SimpleImageContract {
                    return super.getContract() as SimpleImageContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<SimpleImageContract> {
                    return super.getSignedContract<SimpleImageContract>();
                }
                
                public get values(): SimpleImageOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     SimpleImage?: SimpleImageDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     SimpleImage?: SimpleImageDeploymentLive_Facade;
    }
}

export interface SimpleImageDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: SimpleImageOnChainValues;
}

export interface SimpleImageScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: SimpleImageDeploymentClass;
    deployScript?: SimpleImageDeployScript;
}

export type SimpleImageDeployArgType = (params: SimpleImageScriptParameters) => Promise<string[]> | string[];

export interface SimpleImageDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: SimpleImageScriptParameters) => Promise<void>;
    cleanup?: (script: SimpleImageScriptParameters) => Promise<void | string[]>;
    update?: (script: SimpleImageScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: SimpleImageScriptParameters) => Promise<void>;
    deploy?: (script: SimpleImageScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: SimpleImageScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | SimpleImageDeployArgType
;    values?: SimpleImageOnChainValues
;}

export const SimpleImage: SimpleImageDeployScript = {
    "unique": true,
    "module": "assets",
    "index": 4,
    "config": {
        "assets": {
            "rarityChunkSize": 64
        }
    },
    "values": {
        "mustGenerateName": true,
        "nameCount": 3,
        "colourChunkSize": 32,
        "extraColours": 32,
        "randomRarity": true,
        "lowestRarity": true,
        "highestRarity": false,
        "stopDuplicateMint": false
    },
    "deployArgs": [
        "%token_name%",
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "minter"
    ],
    "key": "SimpleImage"
};

declare module '@app/interfaces' {
    export interface  InfinityMintConfigSettingsDeploy {
        assets?: {
rarityChunkSize?: number;
};
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }
}

    export interface SimpleImageOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }

            export abstract class SimpleSVGDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends SimpleSVGDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): SimpleSVGContract {
                    return super.getContract() as SimpleSVGContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<SimpleSVGContract> {
                    return super.getSignedContract<SimpleSVGContract>();
                }
                
                public get values(): SimpleSVGOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     SimpleSVG?: SimpleSVGDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     SimpleSVG?: SimpleSVGDeploymentLive_Facade;
    }
}

export interface SimpleSVGDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: SimpleSVGOnChainValues;
}

export interface SimpleSVGScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: SimpleSVGDeploymentClass;
    deployScript?: SimpleSVGDeployScript;
}

export type SimpleSVGDeployArgType = (params: SimpleSVGScriptParameters) => Promise<string[]> | string[];

export interface SimpleSVGDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: SimpleSVGScriptParameters) => Promise<void>;
    cleanup?: (script: SimpleSVGScriptParameters) => Promise<void | string[]>;
    update?: (script: SimpleSVGScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: SimpleSVGScriptParameters) => Promise<void>;
    deploy?: (script: SimpleSVGScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: SimpleSVGScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | SimpleSVGDeployArgType
;    values?: SimpleSVGOnChainValues
;}

export const SimpleSVG: SimpleSVGDeployScript = {
    "unique": true,
    "module": "assets",
    "index": 4,
    "values": {
        "mustGenerateName": true,
        "nameCount": 3,
        "colourChunkSize": 32,
        "extraColours": 32,
        "randomRarity": true,
        "lowestRarity": true,
        "highestRarity": false,
        "stopDuplicateMint": false
    },
    "deployArgs": [
        "%token_name%",
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "minter"
    ],
    "key": "SimpleSVG"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }
}

    export interface SimpleSVGOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }

            export abstract class SimpleTokenDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends SimpleTokenDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): SimpleTokenContract {
                    return super.getContract() as SimpleTokenContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<SimpleTokenContract> {
                    return super.getSignedContract<SimpleTokenContract>();
                }
                
                public get values(): SimpleTokenOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     SimpleToken?: SimpleTokenDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     SimpleToken?: SimpleTokenDeploymentLive_Facade;
    }
}

export interface SimpleTokenDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: SimpleTokenOnChainValues;
}

export interface SimpleTokenScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: SimpleTokenDeploymentClass;
    deployScript?: SimpleTokenDeployScript;
}

export type SimpleTokenDeployArgType = (params: SimpleTokenScriptParameters) => Promise<string[]> | string[];

export interface SimpleTokenDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: SimpleTokenScriptParameters) => Promise<void>;
    cleanup?: (script: SimpleTokenScriptParameters) => Promise<void | string[]>;
    update?: (script: SimpleTokenScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: SimpleTokenScriptParameters) => Promise<void>;
    deploy?: (script: SimpleTokenScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: SimpleTokenScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | SimpleTokenDeployArgType
;    values?: SimpleTokenOnChainValues
;}

export const SimpleToken: SimpleTokenDeployScript = {
    "unique": true,
    "module": "assets",
    "index": 4,
    "values": {
        "mustGenerateName": true,
        "nameCount": 3,
        "colourChunkSize": 32,
        "extraColours": 32,
        "randomRarity": true,
        "lowestRarity": true,
        "highestRarity": false,
        "stopDuplicateMint": false
    },
    "deployArgs": [
        "%token_name%",
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "minter"
    ],
    "key": "SimpleToken"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }
}

    export interface SimpleTokenOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        mustGenerateName?: boolean;
nameCount?: number;
colourChunkSize?: number;
extraColours?: number;
randomRarity?: boolean;
lowestRarity?: boolean;
highestRarity?: boolean;
stopDuplicateMint?: boolean;
    }

            export abstract class SplitRoyaltyDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends SplitRoyaltyDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): SplitRoyaltyContract {
                    return super.getContract() as SplitRoyaltyContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<SplitRoyaltyContract> {
                    return super.getSignedContract<SplitRoyaltyContract>();
                }
                
                public get values(): SplitRoyaltyOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     SplitRoyalty?: SplitRoyaltyDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     SplitRoyalty?: SplitRoyaltyDeploymentLive_Facade;
    }
}

export interface SplitRoyaltyDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: SplitRoyaltyOnChainValues;
}

export interface SplitRoyaltyScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: SplitRoyaltyDeploymentClass;
    deployScript?: SplitRoyaltyDeployScript;
}

export type SplitRoyaltyDeployArgType = (params: SplitRoyaltyScriptParameters) => Promise<string[]> | string[];

export interface SplitRoyaltyDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: SplitRoyaltyScriptParameters) => Promise<void>;
    cleanup?: (script: SplitRoyaltyScriptParameters) => Promise<void | string[]>;
    update?: (script: SplitRoyaltyScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: SplitRoyaltyScriptParameters) => Promise<void>;
    deploy?: (script: SplitRoyaltyScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: SplitRoyaltyScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | SplitRoyaltyDeployArgType
;    values?: SplitRoyaltyOnChainValues
;}

export const SplitRoyalty: SplitRoyaltyDeployScript = {
    "unique": true,
    "module": "royalty",
    "index": 5,
    "deployArgs": [
        "values"
    ],
    "solidityFolder": "alpha",
    "permissions": [
        "erc721",
        "assets",
        "minter",
        "all"
    ],
    "values": {
        "baseTokenValue": 1000000000000000000,
        "stickerSplit": 20
    },
    "key": "SplitRoyalty"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        startingPrice?: ValuesReturnType;
baseTokenValue?: number;
stickerSplit?: number;
    }
}

    export interface SplitRoyaltyOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        startingPrice?: ValuesReturnType;
baseTokenValue?: number;
stickerSplit?: number;
    }

            export abstract class UnsafeRandomDeploymentClass extends InfinityMintDeployment {
                public getDeploymentScript<T extends UnsafeRandomDeployScript>(): T {
                    return this.deploymentScript as T;
                }

                
                
                /**
                 *  Returns a read only contract which you can use to read values on chain
                 *  @returns
                 */
                public get read(): UnsafeRandomContract {
                    return super.getContract() as UnsafeRandomContract;
                }
                
                /**
                 * Returns a signed contract which you can use to change values on chain. The signer is the current default signer. Call getSignedContract for more control on who is the signer!
                 * @returns
                 */
                public async write(): Promise<UnsafeRandomContract> {
                    return super.getSignedContract<UnsafeRandomContract>();
                }
                
                public get values(): UnsafeRandomOnChainValues {
                            return this.deploymentScript.values;
                        }

            }

        declare module '@app/interfaces' {
    export interface InfinityMintDeployments {
     UnsafeRandom?: UnsafeRandomDeploymentClass;
    }
}

declare module '@app/interfaces' {
    export interface InfinityMintLiveDeployments {
     UnsafeRandom?: UnsafeRandomDeploymentLive_Facade;
    }
}

export interface UnsafeRandomDeploymentLive_Facade extends InfinityMintDeploymentLive {
    values?: UnsafeRandomOnChainValues;
}

export interface UnsafeRandomScriptParameters extends InfinityMintDeploymentParameters {
    deployment?: UnsafeRandomDeploymentClass;
    deployScript?: UnsafeRandomDeployScript;
}

export type UnsafeRandomDeployArgType = (params: UnsafeRandomScriptParameters) => Promise<string[]> | string[];

export interface UnsafeRandomDeployScript extends InfinityMintDeploymentScript {
    setup?: (script: UnsafeRandomScriptParameters) => Promise<void>;
    cleanup?: (script: UnsafeRandomScriptParameters) => Promise<void | string[]>;
    update?: (script: UnsafeRandomScriptParameters) => Promise<Contract | Contract[]>;
    post?: (script: UnsafeRandomScriptParameters) => Promise<void>;
    deploy?: (script: UnsafeRandomScriptParameters) => Promise<{
        contract: Contract | Contract[];
        localDeployment: InfinityMintDeploymentLocal;
    }>;
    switch?: (script: UnsafeRandomScriptParameters) => Promise<Contract | Contract[]>;
    deployArgs?: string[] | UnsafeRandomDeployArgType
;    values?: UnsafeRandomOnChainValues
;}

export const UnsafeRandom: UnsafeRandomDeployScript = {
    "unique": true,
    "module": "random",
    "index": 4,
    "values": {
        "seedNumber": 230,
        "maxRandomNumber": 16777215
    },
    "solidityFolder": "alpha",
    "key": "UnsafeRandom"
};

declare module '@app/interfaces' {
    export interface InfinityMintProjectSettingsValues{
        seedNumber?: number;
maxRandomNumber?: number;
    }
}

    export interface UnsafeRandomOnChainValues extends Dictionary<number | boolean | ValuesReturnType> {
        [key: string]: number | boolean | ValuesReturnType;
        seedNumber?: number;
maxRandomNumber?: number;
    }