pdf

type Array interface {
	ProtectedArray
	// Note that all objects added via Add(), PushFront(), or
	// Append() are Unprotect() before adding them so that owners
	// of the Array also own objects within it.
	Add(o Object)
	PushFront(o Object)
	Append(op ProtectedArray)
}

type AsciiHexFilter struct {
}

type AsciiHexReader struct {
	// contains filtered or unexported fields
}

type AsciiHexWriter struct {
	// contains filtered or unexported fields
}

type Boolean interface {
	Object
	Value() bool
}

type BufferCloser struct {
	bytes.Buffer
}

type Dictionary interface {
	ProtectedDictionary
	// Add() stores an object under the specified key.
	// The protection of the added Object is preserved.
	Add(key string, object Object)

	// Remove() removes the key and value stored under the
	// specified key.
	Remove(key string)
}

type Document struct {

	// DocumentInfo is initialized from a pre-existing documents
	// document info dictionary.  Otherwise it is initialized to
	// an empty dictionary.  It is not nil.
	DocumentInfo
	// contains filtered or unexported fields
}

type DocumentInfo struct {
	Dictionary
	// contains filtered or unexported fields
}

type ExistingPage struct {
	*PageDictionary
	// contains filtered or unexported fields
}

type FalseBoolean struct{}

type File interface {
	// WriteObject() adds the passed object to the File.  The
	// returned indirect reference may be used for backward
	// references to the object.  A new object is created
	// either at a new index in the xref or at an old index
	// using a new generation.
	WriteObject(Object) Indirect

	// WriteObjectAt() adds the object to the File at the specified
	// location.  ObjectNumber may have been obtained by an
	// earlier call to ReserveObjectNumber(), or ObjectNumber may
	// be a pre-existing (finalized) object that is being
	// overwritten with a modified copy.
	WriteObjectAt(ObjectNumber, Object)

	// Indirect() returns an Indirect that can be used to refer
	// to ObjectNumber in this file.  If an Indirect already
	// exists for this ObjectNumber, that Indirect is returned.
	// Otherwise a new one is created. In either case, this should
	// not return nil, even for a mock File.
	Indirect(ObjectNumber) Indirect

	// Object() used ObjectNumber to retrieve a direct object that
	// has already been written to a PDF file.
	Object(ObjectNumber) (Object, error)

	// ReserveObjectNumber() reserves a position (ObjectNumber)
	// for the passed object in the File.
	ReserveObjectNumber(Indirect) ObjectNumber

	// Info() returns a copy of the Info dictionary.  Caller may
	// modify the copy and use SetInfo() to replace the file's
	// info dictionary
	Info() Dictionary

	// Catalog() returns a copy of the Info dictionary.  Caller
	// may modify the copy and use SetCatalog() to replace the
	// file's info dictionary
	Catalog() ProtectedDictionary

	// SetCatalog() sets the catalog dictionary
	SetCatalog(Dictionary)

	// SetInfo() sets the Info dictionary
	SetInfo(DocumentInfo)

	// Trailer() returns a copy of the current contents of the
	// trailer dictionary
	Trailer() ProtectedDictionary

	// DeleteObject() deletes the specified object from the file.
	// It must be an indirect object.
	DeleteObject(Indirect)

	// Close() writes the xref, trailer, etc., and closes the
	// underlying file.
	Close()

	// Closed() returns true if the file has been closed.
	Closed() bool
}

type FlateFilter struct {
	// contains filtered or unexported fields
}

type FlateReader struct {
	io.Reader
}

type FlateWriter struct {
	io.WriteCloser
	// contains filtered or unexported fields
}

type Font interface {
	Indirect(f File) Indirect
}

type Indirect interface {
	ProtectedIndirect
	Write(o Object) Indirect
}

type IntNumeric struct {
	// contains filtered or unexported fields
}

type LZWFilter struct {
}

type LZWReader struct {
	io.Reader
}

type LZWWriter struct {
	io.WriteCloser
	// contains filtered or unexported fields
}

type Name interface {
	Object
	String() string
}

type Null struct{}

type Numeric interface {
	Value() interface{}
	Object
}

type Object interface {
	// Clone() copies the full state of the object so that future
	// changes to the clone do not affect the original object and
	// vice-versa.  For immutable objects Clone() may return the
	// original reference.  However, for container objects, a
	// clone is a deep copy.  As such it can be a relatively
	// expensive operation on a large container.  Protect() and
	// Unprotect() are less expensive and achieve a similar
	// effect.  If an interface has a protected and an unprotected
	// version, the valued returned from Clone() is the
	// unprotected version.  The returned value from Clone() can
	// safely be cast to the unprotected version of the interface
	// type whose Clone() method was invoked.
	Clone() Object

	// If the target is an indirect reference, Dereference()
	// returns an object that is not an indirect reference.
	// Otherwise it returns the target.
	Dereference() Object

	// Most PDF Objects have two versions of interfaces: a
	// protected one and an unprotected one.  The protected
	// interface is used when a method returns an object but wants
	// to be certain that the client cannot alter the object.
	// Protect() returns a protected interface instance. The
	// protected interface implements a subset of the methods
	// available for the unprotected version of the interface.
	// The returned value can safely be cast to the documented
	// protected version of the interface whose Protect() method
	// was invoked.  Although semantically protection is deep
	// (i.e., protecting a container protects all objects within
	// the container), the implementation is relatively efficient.
	Protect() Object

	// Unprotect() returns an unprotected interface instance.
	// When invoked on a protected interface, the semantics are
	// essentially copy-on-write.  When invoked on an unprotected
	// interface, it is a no-op.  Unprotecting is shallow.  It
	// applies to the container itself and not to the objects
	// within the container.  To modify a protected object in an
	// unprotected container, the protected object must be
	// unprotected, modified, and (because the unprotected object
	// is a copy) rewritten to the container.  The returned Object
	// may be cast to the documented unprotected version of the
	// interface whose Unprotect() method was invoked.
	Unprotect() Object

	// Serialize() write a serial byte representation (as defined
	// by the PDF specification) of the object to the Writer.
	// Indirect references are resolved and numbered as if they
	// were being written to the optional File argument.  Having
	// separate arguments for Writer and File allows writing an
	// object to any Writer interface (e.g., stdout for debugging
	// or a string writer for internal formatting), but using the
	// indirect reference object numbers as if it were contained
	// in a specific PDF file.  Objects can be unserialized using
	// Parser.Scan().
	Serialize(Writer, ...File)
}

type ObjectNumber struct {
	// contains filtered or unexported fields
}

type ObjectStringDecorator struct {
	Object
}

type Page struct {
	// contains filtered or unexported fields
}

type PageDictionary struct {
	ProtectedDictionary
	// contains filtered or unexported fields
}

type PageFactory struct {
	*StreamFactory
}

type Parser struct {
	// contains filtered or unexported fields
}

type ProtectString interface {
	Object
	Bytes() []byte
}

type ProtectedArray interface {
	Object
	Size() int
	At(i int) Object
}

type ProtectedDictionary interface {
	Object // A Dictionary must implement the Object interface.

	// Get() returns the object stored under the specified key.
	// or nil if the key doesn't exist.
	Get(key string) Object

	// GetArray() attempts to retrieve the dictionary entry as an
	// ProtectedArray, dereferencing as necessary.  It returns nil
	// if the entry doesn't exist or isn't a ProtectedArray.
	// ProtectedArray is a subset of the Array interface.  The
	// returned ProtectedArray may or may not implement the full
	// Array interface.
	GetArray(key string) ProtectedArray

	// GetBoolean() attempts to retrieve the dictionary entry as a
	// Boolean, dereferencing as necessary.  The second boolean
	// return value indicates whether the entry exists and is a
	// boolean.  If so, the first return value is the value of the
	// Boolean.
	GetBoolean(key string) (bool, bool)

	// GetDictionary() attempts to retrieve the dictionary entry
	// as a ProtectedDictionary, dereferencing as necessary.  It
	// returns nil if the entry doesn't exist or isn't a
	// ProtectedDictionary.  ProtectedDictionary is a subset of
	// the Dictionary interface. The returned ProtectedDictionary
	// may or may not implement the full Dictionary interface.
	GetDictionary(key string) ProtectedDictionary

	// GetIndirect() attempts to retrieve the dictionary entry as
	// a ProtectedIndirect object (no dereferencing is attempted).
	// The return value is nil if the entry doesn't exist or isn't
	// a ProtectedIndirect.  ProtectedIndirect is a subset of the
	// Indirect interface.  The returned ProtectedIndirect may or
	// may not implement the full Indirect interface.
	GetIndirect(key string) ProtectedIndirect

	// GetInt() attempts to retrieve the dictionary entry as an
	// integer, dereferencing as necessary.  The boolean return
	// value indicates whether the entry exists and is an Int.  If
	// so, the returned int represents the value of the integer.
	GetInt(key string) (int, bool)

	// GetName() attempts to retrieve the dictionary entry as a
	// Name, dereferencing as necessary.  The string value of the
	// name is returned.  The boolean return value indicates
	// whether the entry exists and is a name.  If so, the
	// returned string is the name, expressed as a string.
	GetName(key string) (string, bool)

	// GetReal() attempts to retrieve the dictionary entry as a
	// real, dereferencing as necessary.  The boolean return value
	// indicates whether the entry exists and is a Real.  If so,
	// the returned float32 is the value of the Real.
	GetReal(key string) (float32, bool)

	// GetStream() attempts to retrieve the dictionary entry as a
	// ProtectedStream, dereferencing as necessary.  It returns
	// nil if the entry doesn't exist or isn't a ProtectedStream.
	// ProtectedStream is a subset of the Stream interface.  The
	// return value may or may not implement the full Stream
	// interface.
	GetStream(key string) ProtectedStream

	// GetString() attempts to retrieve the dictionary entry as a
	// string, dereferencing as necessary.  The boolean return
	// value indicates whether the entry exists and is a String.
	// If so, the returned slice represents the byte sequence
	// represented by the string.
	GetString(key string) ([]byte, bool)

	// CheckNameValue() returns true if the value associated with
	// the key is a name represented by the expected string (after
	// applying name decoding).
	CheckNameValue(key string, expected string, file ...File) bool

	// Size() returns the number of key-value pairs
	Size() int

	// Keys() returns a slice of strings representing the
	// names in the dictionary
	Keys() []string
}

type ProtectedIndirect interface {
	Object
	ObjectNumber(f File) ObjectNumber
	BoundToFile(f File) bool
}

type ProtectedStream interface {
	Object
	Reader() (result io.Reader)
}

type RealNumeric struct {
	// contains filtered or unexported fields
}

type Rectangle struct {
	ProtectedArray
}

type Scanner interface {
	io.ByteScanner
	io.Reader
}

type StandardFont uint8

type Stream interface {
	ProtectedStream
	io.Writer
	AddFilter(filter StreamFilterFactory)
	Remove(key string)
}

type StreamFactory struct {
	// contains filtered or unexported fields
}

type StreamFilterFactory interface {
	Name() string
	NewEncoder(io.WriteCloser) io.WriteCloser
	NewDecoder(io.Reader) io.Reader
	DecodeParms(file ...File) Object
}

type String interface {
	ProtectString
	SetSerializer(func(String, Writer))
}

type TrueBoolean struct{}

type Writer interface {
	Write(p []byte) (nn int, err error)
	WriteByte(c byte) error
	WriteRune(r rune) (size int, err error)
	WriteString(s string) (int, error)
}