public Query(QueryType type, long token, ReqlAst term, OptArgs globalOptions)
		{
			this.Type = type;
			this.Token = token;
			this.Term = term;
			this.GlobalOptions = globalOptions;
		}

///<summary>
/// "timeout": "T_NUM"
///</summary>
    public Javascript this[OptArgs optArgs] {
        get
        {
            var newOptArgs = OptArgs.FromMap(this.OptArgs).With(optArgs);
    
            return new Javascript (this.Args, newOptArgs);
        }
    }

///<summary>
/// "float": "T_BOOL"
///</summary>
    public Random this[OptArgs optArgs] {
        get
        {
            var newOptArgs = OptArgs.FromMap(this.OptArgs).With(optArgs);
    
            return new Random (this.Args, newOptArgs);
        }
    }

///<summary>
/// "index": "T_STR"
///</summary>
    public Min this[OptArgs optArgs] {
        get
        {
            var newOptArgs = OptArgs.FromMap(this.OptArgs).With(optArgs);
    
            return new Min (this.Args, newOptArgs);
        }
    }

///<summary>
/// "index": "T_STR"
///</summary>
    public GetAll this[OptArgs optArgs] {
        get
        {
            var newOptArgs = OptArgs.FromMap(this.OptArgs).With(optArgs);
    
            return new GetAll (this.Args, newOptArgs);
        }
    }

///<summary>
/// "overwrite": "T_BOOL"
///</summary>
    public IndexRename this[OptArgs optArgs] {
        get
        {
            var newOptArgs = OptArgs.FromMap(this.OptArgs).With(optArgs);
    
            return new IndexRename (this.Args, newOptArgs);
        }
    }

///<summary>
/// "default_timezone": "T_STR"
///</summary>
    public Iso8601 this[OptArgs optArgs] {
        get
        {
            var newOptArgs = OptArgs.FromMap(this.OptArgs).With(optArgs);
    
            return new Iso8601 (this.Args, newOptArgs);
        }
    }

///<summary>
/// "left_bound": "E_BOUND",
///  "right_bound": "E_BOUND"
///</summary>
    public Slice this[OptArgs optArgs] {
        get
        {
            var newOptArgs = OptArgs.FromMap(this.OptArgs).With(optArgs);
    
            return new Slice (this.Args, newOptArgs);
        }
    }

        /// <summary>
        /// Factory method for FormatOptions from OptArgs
        /// </summary>
        public static FormatOptions FromOptArgs(OptArgs args)
        {
            var fmt = new FormatOptions();
            // TODO: find a better way to do this.
            ReqlAst datum;
            var value = args.TryGetValue("time_format", out datum) ? ((Datum)datum).datum : new Datum("native").datum;
            fmt.RawTime = value.Equals("raw");

            value = args.TryGetValue("binary_format", out datum) ? ((Datum)datum).datum : new Datum("native").datum;
            fmt.RawBinary = value.Equals("raw");

            value = args.TryGetValue("group_format", out datum) ? ((Datum)datum).datum : new Datum("native").datum;
            fmt.RawGroups = value.Equals("raw");

            return fmt;
        }

/// <summary>
/// <para>Construct a circular line or polygon. A circle in RethinkDB is a polygon or line <em>approximating</em> a circle of a given radius around a given center, consisting of a specified number of vertices (default 32).</para>
/// </summary>
/// <example><para>Example: Define a circle.</para>
/// <code>r.table('geo').insert({
///     id: 300,
///     name: 'Hayes Valley',
///     neighborhood: r.circle([-122.423246,37.779388], 1000)
/// }).run(conn, callback);
/// </code></example>
        public Circle (Arguments args, OptArgs optargs)
             : this(TermType.CIRCLE, args, optargs) {
        }

/// <summary>
/// <para>The opposite of pluck; takes an object or a sequence of objects, and returns them with
/// the specified paths removed.</para>
/// </summary>
/// <example><para>Example: Since we don't need it for this computation we'll save bandwidth and leave
/// out the list of IronMan's romantic conquests.</para>
/// <code>r.table('marvel').get('IronMan').without('personalVictoriesList').run(conn, callback)
/// </code></example>
        public Without (Arguments args, OptArgs optargs)
             : this(TermType.WITHOUT, args, optargs) {
        }

 protected Binary (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs){
     
 }

/// <summary>
/// <para>Generate a random number between given (or implied) bounds. <code>random</code> takes zero, one or two arguments.</para>
/// </summary>
/// <example><para>Example: Generate a random number in the range <code>[0,1)</code></para>
/// <code>r.random().run(conn, callback)
/// </code></example>
        public Random (Arguments args, OptArgs optargs)
         : base(TermType.RANDOM, args, optargs) {
        }

/// <summary>
/// <para>Create a table. A RethinkDB table is a collection of JSON documents.</para>
/// </summary>
/// <example><para>Example: Create a table named 'dc_universe' with the default settings.</para>
/// <code>r.db('test').tableCreate('dc_universe').run(conn, callback)
/// </code></example>
        public TableCreate (Arguments args, OptArgs optargs)
         : base(TermType.TABLE_CREATE, args, optargs) {
        }

 protected IndexRename (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
 {
 }

/// <summary>
/// <para>Plucks out one or more attributes from either an object or a sequence of objects
/// (projection).</para>
/// </summary>
/// <example><para>Example: We just need information about IronMan's reactor and not the rest of the
/// document.</para>
/// <code>r.table('marvel').get('IronMan').pluck('reactorState', 'reactorPower').run(conn, callback)
/// </code></example>
        public Pluck (Arguments args, OptArgs optargs)
         : base(TermType.PLUCK, args, optargs) {
        }

/// <summary>
/// <para>Select a given number of elements from a sequence with uniform random distribution. Selection is done without replacement.</para>
/// </summary>
/// <example><para>Example: Select 3 random heroes.</para>
/// <code>r.table('marvel').sample(3).run(conn, callback)
/// </code></example>
        public Sample (Arguments args, OptArgs optargs)
         : base(TermType.SAMPLE, args, optargs) {
        }

 public January (Arguments args, OptArgs optargs)
      : this(TermType.JANUARY, args, optargs) {
 }

/// <summary>
/// <para>Construct a geometry object of type Point. The point is specified by two floating point numbers, the longitude (-180 to 180) and latitude (-90 to 90) of the point on a perfect sphere. See <a href="/docs/geo-support/">Geospatial support</a> for more information on ReQL's coordinate system.</para>
/// </summary>
/// <example><para>Example: Define a point.</para>
/// <code>r.table('geo').insert({
///     id: 1,
///     name: 'San Francisco',
///     location: r.point(-122.423246,37.779388)
/// }).run(conn, callback);
/// </code></example>
        public Point (Arguments args, OptArgs optargs)
         : base(TermType.POINT, args, optargs) {
        }

/// <summary>
/// <para>Convert a time object to a string in ISO 8601 format.</para>
/// </summary>
/// <example><para>Example: Return the current ISO 8601 time.</para>
/// <code>r.now().toISO8601().run(conn, callback)
/// // Result passed to callback
/// "2015-04-20T18:37:52.690+00:00"
/// </code></example>
        public ToIso8601 (Arguments args, OptArgs optargs)
         : base(TermType.TO_ISO8601, args, optargs) {
        }