responses

type ActionInfo struct {
	Reference references.FPDF_ACTION
	Type      enums.FPDF_ACTION_ACTION
	DestInfo  *DestInfo // Is set when the action is GOTO. When the action is REMOTEGOTO, we will not fetch the destination.
	FilePath  *string   // When action is LAUNCH or REMOTEGOTO.
	URIPath   *string   // When action is URI.
}

type Attachment struct {
	Name    string
	Content []byte
	Values  []AttachmentValue
}

type AttachmentValue struct {
	Key         string
	ValueType   enums.FPDF_OBJECT_TYPE
	StringValue string
}

type CharPosition struct {
	Left   float64 // The position of this char from the left.
	Top    float64 // The position of this char from the top.
	Right  float64 // The position of this char from the right.
	Bottom float64 // The position of this char from the bottom.
}

type DestInfo struct {
	Reference references.FPDF_DEST
	PageIndex int
}

type FPDFAction_GetDest struct {
	Dest *references.FPDF_DEST // Reference to the bookmark dest. nil if not found.
}

type FPDFAction_GetFilePath struct {
	FilePath *string // nil when not set
}

type FPDFAction_GetType struct {
	Type enums.FPDF_ACTION_ACTION
}

type FPDFAction_GetURIPath struct {
	URIPath *string // nil when not set
}

type FPDFAttachment_GetFile struct {
	Contents []byte // nil when not found.
}

type FPDFAttachment_GetName struct {
	Name string
}

type FPDFAttachment_GetStringValue struct {
	Key   string
	Value string
}

type FPDFAttachment_GetValueType struct {
	Key       string
	ValueType enums.FPDF_OBJECT_TYPE
}

type FPDFAttachment_HasKey struct {
	Key    string
	HasKey bool
}

type FPDFAttachment_SetFile struct{}

type FPDFAttachment_SetStringValue struct {
	Key   string
	Value string
}

type FPDFBookmark_Find struct {
	Bookmark *references.FPDF_BOOKMARK // Reference to the found bookmark. nil if the title can't be found.
}

type FPDFBookmark_GetAction struct {
	Action *references.FPDF_ACTION // Reference to the bookmark action. nil if not found.
}

type FPDFBookmark_GetDest struct {
	Dest *references.FPDF_DEST // Reference to the bookmark dest. nil if not found.
}

type FPDFBookmark_GetFirstChild struct {
	Bookmark *references.FPDF_BOOKMARK // Reference to the first child or top level bookmark item. nil if no child or top level bookmark found.
}

type FPDFBookmark_GetNextSibling struct {
	Bookmark *references.FPDF_BOOKMARK // Reference to the next bookmark item at the same level. nil if this is the last bookmark at this level.
}

type FPDFBookmark_GetTitle struct {
	Title string // The title of the bookmark.
}

type FPDFCatalog_IsTagged struct {
	IsTagged bool
}

type FPDFDest_GetDestPageIndex struct {
	Index int
}

type FPDFDest_GetLocationInPage struct {
	X    *float32
	Y    *float32
	Zoom *float32
}

type FPDFDest_GetView struct {
	DestView enums.FPDF_PDFDEST_VIEW
	Params   []float32
}

type FPDFDoc_AddAttachment struct {
	Attachment references.FPDF_ATTACHMENT
}

type FPDFDoc_CloseJavaScriptAction struct{}

type FPDFDoc_DeleteAttachment struct {
	Index int
}

type FPDFDoc_GetAttachment struct {
	Index      int
	Attachment references.FPDF_ATTACHMENT
}

type FPDFDoc_GetAttachmentCount struct {
	AttachmentCount int
}

type FPDFDoc_GetJavaScriptAction struct {
	Index            int
	JavaScriptAction references.FPDF_JAVASCRIPT_ACTION
}

type FPDFDoc_GetJavaScriptActionCount struct {
	JavaScriptActionCount int
}

type FPDFDoc_GetPageMode struct {
	PageMode FPDFDoc_GetPageModeMode // The document's page mode, which describes how the document should be displayed when opened.
}

type FPDFDoc_GetPageModeMode int

type FPDFJavaScriptAction_GetName struct {
	Name string
}

type FPDFJavaScriptAction_GetScript struct {
	Script string
}

type FPDFLink_CloseWebLinks struct{}

type FPDFLink_CountQuadPoints struct {
	Count int
}

type FPDFLink_CountRects struct {
	Index int
	Count int // Number of rectangular areas for the link.
}

type FPDFLink_CountWebLinks struct {
	Count int
}

type FPDFLink_Enumerate struct {
	NextStartPos *int
	Link         *references.FPDF_LINK
}

type FPDFLink_GetAction struct {
	// Action is a handle to the action associated to a link, or nil if no action.
	Action *references.FPDF_ACTION
}

type FPDFLink_GetAnnot struct {
	Annotation *references.FPDF_ANNOTATION
}

type FPDFLink_GetAnnotRect struct {
	Rect *structs.FPDF_FS_RECTF // The rectangle for the link.
}

type FPDFLink_GetDest struct {
	// Dest is a handle to the destination, or nil if there is no destination
	// associated with the link. In this case, you should call FPDFLink_GetAction()
	// to retrieve the action associated with a link.
	Dest *references.FPDF_DEST
}

type FPDFLink_GetLinkAtPoint struct {
	Link *references.FPDF_LINK // Reference to the found link. nil if not found.
}

type FPDFLink_GetLinkZOrderAtPoint struct {
	ZOrder int // the Z-order of the link, or -1 if no link found at the given point. Larger Z-order numbers are closer to the front.
}

type FPDFLink_GetQuadPoints struct {
	Points *structs.FPDF_FS_QUADPOINTSF
}

type FPDFLink_GetRect struct {
	Index     int
	RectIndex int
	Left      float64
	Top       float64
	Right     float64
	Bottom    float64
}

type FPDFLink_GetTextRange struct {
	Index          int
	StartCharIndex int
	CharCount      int
}

type FPDFLink_GetURL struct {
	Index int
	URL   string
}

type FPDFLink_LoadWebLinks struct {
	PageLink references.FPDF_PAGELINK
}

type FPDFPage_Flatten struct {
	Page   int                    // The page number (0-index based).
	Result FPDFPage_FlattenResult // The result of the flatten.
}

type FPDFPage_FlattenResult int

type FPDFPage_GetDecodedThumbnailData struct {
	Thumbnail []byte // The thumbnail data, nil when it doesn't exist.
}

type FPDFPage_GetRawThumbnailData struct {
	RawThumbnail []byte // The raw thumbnail data, nil when it doesn't exist.
}

type FPDFPage_GetRotation struct {
	Page         int                      // The page number (0-index based).
	PageRotation enums.FPDF_PAGE_ROTATION // The page rotation.
}

type FPDFPage_GetThumbnailAsBitmap struct {
	Bitmap *references.FPDF_BITMAP // The thumbnail as bitmap, nil if it doesn't exist.
}

type FPDFPage_HasTransparency struct {
	Page            int  // The page number (0-index based).
	HasTransparency bool // Whether the page has transparency.
}

type FPDFPage_SetRotation struct{}

type FPDFSignatureObj_GetByteRange struct {
	ByteRange []int // ByteRange is an array of pairs of integers (starting byte offset, length in bytes) that describes the exact byte range for the digest calculation. nil when no byte range.
}

type FPDFSignatureObj_GetContents struct {
	Contents []byte // For public-key signatures, Contents is either a DER-encoded PKCS#1 binary or a DER-encoded PKCS#7 binary. nil when no content.
}

type FPDFSignatureObj_GetDocMDPPermission struct {
	DocMDPPermission int
}

type FPDFSignatureObj_GetReason struct {
	Reason *string // The reason (comment) of the signature object. nil when no reason.
}

type FPDFSignatureObj_GetSubFilter struct {
	SubFilter *string // The encoding of the value of a signature object. nil when no sub filter.
}

type FPDFSignatureObj_GetTime struct {
	Time *string // The time of signing of a signature object. The format of time is expected to be D:YYYYMMDDHHMMSS+XX'YY', i.e. it's precision is seconds, with timezone information. This value should be used only when the time of signing is not available in the (PKCS#7 binary) signature. nil when no time.
}

type FPDFText_ClosePage struct{}

type FPDFText_CountChars struct {
	Count int //Number of characters in the page. Generated characters, like additional space characters, new line characters, are also counted.
}

type FPDFText_CountRects struct {
	Count int
}

type FPDFText_FindClose struct{}

type FPDFText_FindNext struct {
	GotMatch bool
}

type FPDFText_FindPrev struct {
	GotMatch bool
}

type FPDFText_FindStart struct {
	Search references.FPDF_SCHHANDLE
}

type FPDFText_GetBoundedText struct {
	Text string
}

type FPDFText_GetCharAngle struct {
	Index     int
	CharAngle float32
}

type FPDFText_GetCharBox struct {
	Index  int
	Left   float64
	Right  float64
	Bottom float64
	Top    float64
}

type FPDFText_GetCharIndexAtPos struct {
	CharIndex int // -1 when not found
}

type FPDFText_GetCharIndexFromTextIndex struct {
	CharIndex int
}

type FPDFText_GetCharOrigin struct {
	Index int
	X     float64
	Y     float64
}

type FPDFText_GetFillColor struct {
	Index int
	R     uint
	G     uint
	B     uint
	A     uint
}

type FPDFText_GetFontInfo struct {
	Index    int
	FontName string
	Flags    int // Font flags. These flags should be interpreted per PDF spec 1.7 Section 5.7.1 Font Descriptor Flags.
}

type FPDFText_GetFontSize struct {
	Index    int
	FontSize float64 // The font size of the particular character, measured in points (about 1/72 inch). This is the typographic size of the font (so called "em size").
}

type FPDFText_GetFontWeight struct {
	Index      int
	FontWeight int
}

type FPDFText_GetLooseCharBox struct {
	Index int
	Rect  structs.FPDF_FS_RECTF
}

type FPDFText_GetMatrix struct {
	Index  int
	Matrix structs.FPDF_FS_MATRIX
}

type FPDFText_GetRect struct {
	Left   float64 // Left boundary.
	Top    float64 // Top boundary.
	Right  float64 // Right boundary.
	Bottom float64 // Bottom boundary.
}

type FPDFText_GetSchCount struct {
	Count int
}

type FPDFText_GetSchResultIndex struct {
	Index int
}

type FPDFText_GetStrokeColor struct {
	Index int
	R     uint
	G     uint
	B     uint
	A     uint
}

type FPDFText_GetText struct {
	Text string
}

type FPDFText_GetTextIndexFromCharIndex struct {
	TextIndex int
}

type FPDFText_GetTextRenderMode struct {
	Index          int
	TextRenderMode enums.FPDF_TEXT_RENDERMODE
}

type FPDFText_GetUnicode struct {
	Index   int
	Unicode uint //The Unicode of the particular character. If a character is not encoded in Unicode and PDFium can't convert to Unicode, the return value will be zero.
}

type FPDFText_LoadPage struct {
	TextPage references.FPDF_TEXTPAGE
}

type FPDF_CloseDocument struct{}

type FPDF_ClosePage struct{}

type FPDF_CloseXObject struct{}

type FPDF_CopyViewerPreferences struct{}

type FPDF_CreateNewDocument struct {
	Document references.FPDF_DOCUMENT
}

type FPDF_GetDocPermissions struct {
	DocPermissions                      uint32 // A 32-bit integer which indicates the permission flags. Please refer to "TABLE 3.20 User access permissions" in PDF Reference 1.7 P123 for detailed description. If the document is not protected, 0xffffffff (4294967295) will be returned.
	PrintDocument                       bool   // Bit position 3: (Security handlers of revision 2) Print the document, (Security handlers of revision 3 or greater) Print the document (possibly not at the highest quality level, depending on whether PrintDocumentAsFaithfulDigitalCopy (bit 12) is also set).
	ModifyContents                      bool   // Bit position 4: Modify the contents of the document by operations other than those controlled by AddOrModifyTextAnnotations (bit 6), FillInExistingInteractiveFormFields (bit 9), and AssembleDocument (bit 11).
	CopyOrExtractText                   bool   // Bit position 5: (Security handlers of revision 2) Copy or otherwise extract  text and graphics from the document, including extracting text and graphics (in support of accessibility to users with disabilities or for other purposes). (Security handlers of revision 3 or greater) Copy or otherwise extract text and graphics from the document by operations other than that controlled by ExtractTextAndGraphics (bit 10).
	AddOrModifyTextAnnotations          bool   // Bit position 6: Add or modify text annotations
	FillInInteractiveFormFields         bool   // Bit position 6: fill in interactive form fields
	CreateOrModifyInteractiveFormFields bool   // Bit position 6 & 4: create or modify interactive form fields (including signature fields).
	FillInExistingInteractiveFormFields bool   // Bit position 9: (Security handlers of revision 3 or greater) Fill in existing interactive form fields (including signature fields), even if FillInInteractiveFormFields (bit 6) is clear.
	ExtractTextAndGraphics              bool   // Bit position 10: (Security handlers of revision 3 or greater) Extract text and graphics (in support of accessibility to users with disabilities or for other purposes).
	AssembleDocument                    bool   // Bit position 11: (Security handlers of revision 3 or greater) Assemble the  document (insert, rotate, or delete pages and create bookmarks or thumbnail images), even if ModifyContents (bit 4) is clear.
	PrintDocumentAsFaithfulDigitalCopy  bool   // Bit position 12: (Security handlers of revision 3 or greater) Print the document to a representation from which a faithful digital copy of the PDF content could be generated. When this bit is clear (and PrintDocument (bit 3) is set), printing is limited to a low-level representation of the appearance, possibly of degraded quality.
}

type FPDF_GetFileIdentifier struct {
	FileIdType enums.FPDF_FILEIDTYPE
	Identifier []byte // Can be nil if no identifier was found
}

type FPDF_GetFileVersion struct {
	FileVersion int // The numeric version of the file: 14 for 1.4, 15 for 1.5, ...
}

type FPDF_GetLastError struct {
	Error FPDF_GetLastErrorError
}

type FPDF_GetLastErrorError int

type FPDF_GetMetaText struct {
	Tag   string // The requested metadata tag.
	Value string // The value of the tag if found, string is empty if the value is not found.
}

type FPDF_GetPageAAction struct {
	AAType *enums.FPDF_PAGE_AACTION
	Action *references.FPDF_ACTION
}

type FPDF_GetPageCount struct {
	PageCount int // The amount of pages of the document.
}

type FPDF_GetPageHeight struct {
	Page   int     // The page this size came from (0-index based).
	Height float64 // The height of the page in points. One point is 1/72 inch (around 0.3528 mm).
}

type FPDF_GetPageLabel struct {
	Page  int
	Label string
}

type FPDF_GetPageSizeByIndex struct {
	Page   int     // The page this size came from (0-index based).
	Width  float64 // The width of the page in points. One point is 1/72 inch (around 0.3528 mm).
	Height float64 // The height of the page in points. One point is 1/72 inch (around 0.3528 mm).
}

type FPDF_GetPageWidth struct {
	Page  int     // The page this size came from (0-index based).
	Width float64 // The width of the page in points. One point is 1/72 inch (around 0.3528 mm).
}

type FPDF_GetSecurityHandlerRevision struct {
	SecurityHandlerRevision int // The revision number of security handler. Please refer to key "R" in "TABLE 3.19 Additional encryption dictionary entries for the standard security handler" in PDF Reference 1.7 P122 for detailed description. If the document is not protected, -1 will be returned.
}

type FPDF_GetSignatureCount struct {
	Count int
}

type FPDF_GetSignatureObject struct {
	Index     int
	Signature references.FPDF_SIGNATURE
}

type FPDF_ImportNPagesToOne struct {
	Document references.FPDF_DOCUMENT
}

type FPDF_ImportPages struct{}

type FPDF_ImportPagesByIndex struct{}

type FPDF_LoadCustomDocument struct {
	Document references.FPDF_DOCUMENT
}

type FPDF_LoadDocument struct {
	Document references.FPDF_DOCUMENT
}

type FPDF_LoadMemDocument struct {
	Document references.FPDF_DOCUMENT
}

type FPDF_LoadMemDocument64 struct {
	Document references.FPDF_DOCUMENT
}

type FPDF_LoadPage struct {
	Page references.FPDF_PAGE
}

type FPDF_NewFormObjectFromXObject struct {
	PageObject references.FPDF_PAGEOBJECT
}

type FPDF_NewXObjectFromPage struct {
	XObject references.FPDF_XOBJECT
}

type FPDF_SaveAsCopy struct {
	FileBytes *[]byte // The byte array if no path or writer was given.
	FilePath  *string
}

type FPDF_SaveWithVersion struct {
	FileBytes *[]byte // The byte array if no path or writer was given.
	FilePath  *string
}

type FPDF_SetSandBoxPolicy struct{}

type FSDK_SetLocaltimeFunction struct {
}

type FSDK_SetTimeFunction struct {
}

type FSDK_SetUnSpObjProcessHandler struct {
}

type FontInformation struct {
	Size         float64 // Font size in points (also known as em).
	SizeInPixels *int    // Font size in pixels, only available when PixelPositions is used.
	Weight       int     // The weight of the font, can be negative for spaces and newlines.
	Name         string  // The name of the font, can be empty for spaces and newlines.
	Flags        int     // Font flags, should be interpreted per PDF spec 1.7, Section 5.7.1 Font Descriptor Flags.
}

type GetActionInfo struct {
	ActionInfo ActionInfo
}

type GetAttachments struct {
	Attachments []Attachment
}

type GetBookmarks struct {
	Bookmarks []GetBookmarksBookmark
}

type GetBookmarksBookmark struct {
	Title      string
	Reference  references.FPDF_BOOKMARK
	ActionInfo *ActionInfo
	DestInfo   *DestInfo
	Children   []GetBookmarksBookmark
}

type GetDestInfo struct {
	DestInfo DestInfo
}

type GetJavaScriptActions struct {
	JavaScriptActions []JavaScriptAction
}

type GetMetaData struct {
	Tags []GetMetaDataTag
}

type GetMetaDataTag struct {
	Tag   string // The requested metadata tag.
	Value string // The value of the tag if found, string is empty if the value is not found.
}

type GetPageSize struct {
	Page   int     // The page this size came from (0-index based).
	Width  float64 // The width of the page in points. One point is 1/72 inch (around 0.3528 mm).
	Height float64 // The height of the page in points. One point is 1/72 inch (around 0.3528 mm).
}

type GetPageSizeInPixels struct {
	Page              int     // The page this size came from (0-index based).
	Width             int     // The width of the page in pixels.
	Height            int     // The height of the page in pixels.
	PointToPixelRatio float64 // The point to pixel ratio for the rendered image. How many points is 1 pixel in this image.
}

type GetPageText struct {
	Page int    // The page this text came from (0-index based).
	Text string // The plain text of a page.
}

type GetPageTextStructured struct {
	Page              int                          // The page structured this text came from (0-index based).
	Chars             []*GetPageTextStructuredChar // A list of chars in a page. When Mode is GetPageTextStructuredModeChars or GetPageTextStructuredModeBoth.
	Rects             []*GetPageTextStructuredRect // A list of rects in a page. When Mode is GetPageTextStructuredModeRects or GetPageTextStructuredModeBoth.
	PointToPixelRatio float64                      // The point to pixel ratio for the calculated positions.
}

type GetPageTextStructuredChar struct {
	Text            string           // The text of this char.
	Angle           float64          // The angle this char is in.
	PointPosition   CharPosition     // The position of this char in points.
	PixelPosition   *CharPosition    // The position of this char in pixels. When PixelPositions are requested.
	FontInformation *FontInformation // The font information of this char. When CollectFontInformation is enabled.
}

type GetPageTextStructuredRect struct {
	Text            string           // The text of this rect.
	PointPosition   CharPosition     // The position of this rect in points.
	PixelPosition   *CharPosition    // The position of this rect in pixels. When PixelPositions are requested.
	FontInformation *FontInformation // The font information of this rect. When CollectFontInformation is enabled.
}

type JavaScriptAction struct {
	Name   string
	Script string
}

type NewPage struct {
	Page references.FPDF_PAGE
}

type OpenDocument struct {
	Document references.FPDF_DOCUMENT
}

type RenderPage struct {
	Page              int         // The rendered page number (0-index based).
	PointToPixelRatio float64     // The point to pixel ratio for the rendered image. How many points is 1 pixel in this image.
	Image             *image.RGBA // The rendered image.
	Width             int         // The width of the rendered image.
	Height            int         // The height of the rendered image.
}

type RenderPageInDPI struct {
	Result RenderPage
}

type RenderPageInPixels struct {
	Result RenderPage
}

type RenderPages struct {
	Pages  []RenderPagesPage // Information about the rendered pages inside this image.
	Image  *image.RGBA       // The rendered image.
	Width  int               // The width of the rendered image.
	Height int               // The height of the rendered image.
}

type RenderPagesInDPI struct {
	Result RenderPages
}

type RenderPagesInPixels struct {
	Result RenderPages
}

type RenderPagesPage struct {
	Page              int     // The rendered page number (0-index based).
	PointToPixelRatio float64 // The point to pixel ratio for the rendered image. How many points is 1 pixel for this page in this image.
	Width             int     // The width of the rendered page inside the image.
	Height            int     // The height of the rendered page inside the image.
	X                 int     // The X start position of this page inside the image.
	Y                 int     // The Y start position of this page inside the image.
}

type RenderToFile struct {
	Pages             []RenderPagesPage // Information about the rendered pages inside this image.
	ImageBytes        *[]byte           // The byte array of the rendered file when OutputTarget is RenderToFileOutputTargetBytes.
	ImagePath         string            // The file path when OutputTarget is RenderToFileOutputTargetFile, is a tmp path when TargetFilePath was empty in the request.
	Width             int               // The width of the rendered image.
	Height            int               // The height of the rendered image.
	PointToPixelRatio float64           // The point to pixel ratio for the rendered image. How many points is 1 pixel in this image. Only set when rendering one page.
}