{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "ConfigResponse",
  "type": "object",
  "required": [
    "admin",
    "factory",
    "mint_price",
    "nft_data",
    "per_address_limit",
    "sg721_address",
    "sg721_code_id",
    "start_time"
  ],
  "properties": {
    "admin": {
      "type": "string"
    },
    "end_time": {
      "anyOf": [
        {
          "$ref": "#/definitions/Timestamp"
        },
        {
          "type": "null"
        }
      ]
    },
    "factory": {
      "type": "string"
    },
    "mint_price": {
      "$ref": "#/definitions/Coin"
    },
    "nft_data": {
      "$ref": "#/definitions/NftData"
    },
    "num_tokens": {
      "type": [
        "integer",
        "null"
      ],
      "format": "uint32",
      "minimum": 0.0
    },
    "payment_address": {
      "anyOf": [
        {
          "$ref": "#/definitions/Addr"
        },
        {
          "type": "null"
        }
      ]
    },
    "per_address_limit": {
      "type": "integer",
      "format": "uint32",
      "minimum": 0.0
    },
    "sg721_address": {
      "type": "string"
    },
    "sg721_code_id": {
      "type": "integer",
      "format": "uint64",
      "minimum": 0.0
    },
    "start_time": {
      "$ref": "#/definitions/Timestamp"
    },
    "whitelist": {
      "type": [
        "string",
        "null"
      ]
    }
  },
  "additionalProperties": false,
  "definitions": {
    "Addr": {
      "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.",
      "type": "string"
    },
    "Coin": {
      "type": "object",
      "required": [
        "amount",
        "denom"
      ],
      "properties": {
        "amount": {
          "$ref": "#/definitions/Uint128"
        },
        "denom": {
          "type": "string"
        }
      }
    },
    "Metadata": {
      "description": "OpenSea metadata standard, used by Stargaze marketplace. See [this link](https://docs.opensea.io/docs/metadata-standards) for details.",
      "type": "object",
      "properties": {
        "animation_url": {
          "description": "A URL to a multi-media attachment for the item. The file extensions GLTF, GLB, WEBM, MP4, M4V, OGV, and OGG are supported, along with the audio-only extensions MP3, WAV, and OGA.\n\nAnimation_url also supports HTML pages, allowing you to build rich experiences and interactive NFTs using JavaScript canvas, WebGL, and more. Scripts and relative paths within the HTML page are now supported. However, access to browser extensions is not supported.",
          "type": [
            "string",
            "null"
          ]
        },
        "attributes": {
          "description": "These are the attributes for the item, which will show up on the OpenSea page for the item.",
          "type": [
            "array",
            "null"
          ],
          "items": {
            "$ref": "#/definitions/Trait"
          }
        },
        "background_color": {
          "description": "Background color of the item on OpenSea. Must be a six-character hexadecimal without a pre-pended #.",
          "type": [
            "string",
            "null"
          ]
        },
        "description": {
          "description": "A human readable description of the item. Markdown is supported.",
          "type": [
            "string",
            "null"
          ]
        },
        "external_url": {
          "description": "This is the URL that will appear below the asset's image on OpenSea and will allow users to leave OpenSea and view the item on your site.",
          "type": [
            "string",
            "null"
          ]
        },
        "image": {
          "description": "This is the URL to the image of the item. Can be just about any type of image (including SVGs, which will be cached into PNGs by OpenSea), and can be [IPFS](https://github.com/ipfs/is-ipfs) URLs or paths. We recommend using a 350 x 350 image.",
          "type": [
            "string",
            "null"
          ]
        },
        "image_data": {
          "description": "Raw SVG image data, if you want to generate images on the fly (not recommended). Only use this if you're not including the `image` parameter.",
          "type": [
            "string",
            "null"
          ]
        },
        "name": {
          "description": "Name of the item.",
          "type": [
            "string",
            "null"
          ]
        },
        "youtube_url": {
          "description": "A URL to a YouTube video.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "NftData": {
      "type": "object",
      "required": [
        "nft_data_type"
      ],
      "properties": {
        "extension": {
          "anyOf": [
            {
              "$ref": "#/definitions/Metadata"
            },
            {
              "type": "null"
            }
          ]
        },
        "nft_data_type": {
          "$ref": "#/definitions/NftMetadataType"
        },
        "token_uri": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "additionalProperties": false
    },
    "NftMetadataType": {
      "type": "string",
      "enum": [
        "on_chain_metadata",
        "off_chain_metadata"
      ]
    },
    "Timestamp": {
      "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```",
      "allOf": [
        {
          "$ref": "#/definitions/Uint64"
        }
      ]
    },
    "Trait": {
      "description": "An attribute of the token as defined by the [OpenSea metadata standard](https://docs.opensea.io/docs/metadata-standards#attributes).",
      "type": "object",
      "required": [
        "trait_type",
        "value"
      ],
      "properties": {
        "display_type": {
          "type": [
            "string",
            "null"
          ]
        },
        "trait_type": {
          "type": "string"
        },
        "value": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "Uint128": {
      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
      "type": "string"
    },
    "Uint64": {
      "description": "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```",
      "type": "string"
    }
  }
}