How to use the babel-core/lib/types.literal function in babel-core

RelayQLMutation,
  RelayQLQuery,
  RelayQLType,
} = require('./RelayQLAST');

const find = require('./find');
const invariant = require('./invariant');
const t = require('babel-core/lib/types');

export type Printable = Object;
export type Substitution = {
  name: string;
  value: Printable;
};

const NULL = t.literal(null);

class RelayQLPrinter {
  tagName: string;

  constructor(tagName: string) {
    this.tagName = tagName;
  }

  print(
    definition: RelayQLDefinition,
    substitutions: Array
  ): Printable {
    let printedDocument;
    if (definition instanceof RelayQLQuery) {
      printedDocument = this.printQuery(definition);
    } else if (definition instanceof RelayQLFragment) {

printVariable(name: string): Printable {
    return t.newExpression(
      t.memberExpression(
        t.identifier('GraphQL'),
        t.identifier('CallVariable')
      ),
      [t.literal(name)]
    );
  }

printValue(value: mixed): Printable {
    if (Array.isArray(value)) {
      return t.arrayExpression(
        value.map(element => this.printArgumentValue(element))
      );
    }
    return t.newExpression(
      t.memberExpression(
        t.identifier('GraphQL'),
        t.identifier('CallValue')
      ),
      [t.literal(value)]
    );
  }

arg => t.objectExpression([
                property('name', t.literal(arg.getName())),
                property('value', this.printArgumentValue(arg)),
              ])
            )

requisiteFields.id = true;
    }
    if (fragmentType.isAbstract()) {
      requisiteFields.__typename = true;
    }
    const selection = this.printSelection(fragment, requisiteFields);
    const metadata = this.printRelayDirectiveMetadata(fragment);

    return t.newExpression(
      t.memberExpression(
        t.identifier('GraphQL'),
        t.identifier('QueryFragment')
      ),
      trimArguments([
        t.literal(fragment.getName()),
        t.literal(fragmentType.getName({modifiers: true})),
        selection.fields,
        selection.fragments,
        objectify(metadata),
        this.printDirectives(fragment.getDirectives())
      ])
    );
  }

const requisiteFields = {clientMutationId: true};
    const selection = this.printSelection(rootField, requisiteFields);
    const metadata = {
      inputType: this.printArgumentTypeForMetadata(
        rootField.getDeclaredArgument('input')
      ),
    };

    return t.newExpression(
      t.memberExpression(
        t.identifier('GraphQL'),
        t.identifier('Mutation')
      ),
      trimArguments([
        t.literal(mutation.getName()),
        t.literal(rootFieldType.getName({modifiers: true})),
        t.newExpression(
          t.memberExpression(
            t.identifier('GraphQL'),
            t.identifier('Callv')
          ),
          trimArguments([
            t.literal(rootField.getName()),
            this.printVariable('input')
          ])
        ),
        selection.fields,
        selection.fragments,
        objectify(metadata)
      ])
    );
  }

printArgument(arg: RelayQLArgument): Printable {
    const metadata = {};
    const inputType = this.printArgumentTypeForMetadata(arg.getType());
    if (inputType) {
      metadata.type = inputType;
    }
    return t.newExpression(
      t.memberExpression(
        t.identifier('GraphQL'),
        t.identifier('Callv')
      ),
      trimArguments([
        t.literal(arg.getName()),
        this.printArgumentValue(arg),
        objectify(metadata)
      ])
    );
  }