import * as Primitive from "../../../xml-primitives";

// Source files:
// file:///home/hasanbalci/Documents/Github_WP/gpml2pvjson-js/node_modules/@wikipathways/gpml/rdf.xsd


interface BaseType {
	_exists: boolean;
	_namespace: string;
}
/** this is a "union type"; use
  * xsi:type in the instance to discriminate between concrete subtypes.
  * @@hmm... can I mark this as "abstract" somehow? */
interface _item extends BaseType {}
export interface item extends _item { constructor: { new(): item }; }
export var item: { new(): item };

interface _members extends BaseType {
	ID?: string;
	li: item[];
}
export interface members extends _members { constructor: { new(): members }; }
export var members: { new(): members };

interface _propertyEltLiteral extends BaseType {
	ID?: string;
}
export interface propertyEltLiteral extends _propertyEltLiteral { constructor: { new(): propertyEltLiteral }; }
export var propertyEltLiteral: { new(): propertyEltLiteral };

interface _PropertyEltProxyType extends BaseType {}
interface PropertyEltProxyType extends _PropertyEltProxyType { constructor: { new(): PropertyEltProxyType }; }

interface _propertyEltRef extends BaseType {
	ID?: string;
	resource?: string[];
}
export interface propertyEltRef extends _propertyEltRef { constructor: { new(): propertyEltRef }; }
export var propertyEltRef: { new(): propertyEltRef };

interface _propertyEltResource extends BaseType {
	propertyElt: PropertyEltProxyType[];
}
export interface propertyEltResource extends _propertyEltResource { constructor: { new(): propertyEltResource }; }
export var propertyEltResource: { new(): propertyEltResource };

/** this is a "union type"; use
  * xsi:type in the instance to discriminate between concrete subtypes */
interface _propertyEltType extends BaseType {}
export interface propertyEltType extends _propertyEltType { constructor: { new(): propertyEltType }; }
export var propertyEltType: { new(): propertyEltType };

interface _propertyEltValue extends BaseType {
	ID?: string;
}
export interface propertyEltValue extends _propertyEltValue { constructor: { new(): propertyEltValue }; }
export var propertyEltValue: { new(): propertyEltValue };

interface _RDFType extends BaseType {
	Alt: members[];
	Bag: members[];
	Seq: members[];
	typedNode: TypedNodeProxyType[];
}
interface RDFType extends _RDFType { constructor: { new(): RDFType }; }

interface _referencedItem extends BaseType {
	resource?: string[];
}
export interface referencedItem extends _referencedItem { constructor: { new(): referencedItem }; }
export var referencedItem: { new(): referencedItem };

interface _TypedNodeProxyType extends BaseType {}
interface TypedNodeProxyType extends _TypedNodeProxyType { constructor: { new(): TypedNodeProxyType }; }

interface _typedNodeType extends BaseType {
	about?: string[];
	ID?: string;
	propertyElt: PropertyEltProxyType[];
}
export interface typedNodeType extends _typedNodeType { constructor: { new(): typedNodeType }; }
export var typedNodeType: { new(): typedNodeType };

interface _value extends BaseType {}
export interface value extends _value { constructor: { new(): value }; }
export var value: { new(): value };

interface _valueObj extends _TypedNodeProxyType {
	Alt: members;
	Bag: members;
	Seq: members;
}
export interface valueObj extends _valueObj { constructor: { new(): valueObj }; }
export var valueObj: { new(): valueObj };

interface _valueString extends BaseType {}
export interface valueString extends _valueString { constructor: { new(): valueString }; }
export var valueString: { new(): valueString };

export interface document extends BaseType {
	Alt: members;
	Bag: members;
	Description: typedNodeType;
	object: propertyEltRef;
	predicate: propertyEltRef;
	Property: typedNodeType;
	RDF: RDFType;
	Seq: members;
	Statement: typedNodeType;
	subject: propertyEltRef;
	type: propertyEltRef;
	value: valueString;
}
export var document: document;